@quanta-intellect/vessel-browser 0.1.140 → 0.1.141

package/out/main/index.js

@@ -5589,15 +5589,12 @@ const DEFAULT_SELECTOR_ATTRIBUTES = [
 ];
 function selectorHelpersJS(attributes = DEFAULT_SELECTOR_ATTRIBUTES) {
   const attrsExpr = JSON.stringify(attributes);
-  const q = '"';
-  const bs = "\\";
-  const escQ = bs + q;
   return [
     "function __escapeSelectorValue(value) {",
     '  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {',
     "    return CSS.escape(value);",
     "  }",
-    `  return String(value).replace(/[${q}${bs}${bs}]/g, ${q}${bs}${bs}$&${q});`,
+    '  return String(value).replace(/["\\\\]/g, "\\\\$&");',
     "}",
     "",
     "function __uniqueSelector(candidate) {",
@@ -5613,7 +5610,7 @@ function selectorHelpersJS(attributes = DEFAULT_SELECTOR_ATTRIBUTES) {
     '  var value = (el.getAttribute && el.getAttribute(attribute)) || "";',
     "  value = String(value).trim();",
     "  if (!value) return null;",
-    `  var candidate = el.tagName.toLowerCase() + ${q}[${q} + attribute + ${q}=${escQ}${q} + __escapeSelectorValue(value) + ${escQ}]${q};`,
+    '  var candidate = el.tagName.toLowerCase() + "[" + attribute + "=\\"" + __escapeSelectorValue(value) + "\\"]";',
     "  return __uniqueSelector(candidate);",
     "}",
     "",
@@ -8754,6 +8751,42 @@ function recoverNarratedActionToolCalls(text, availableToolNames) {
   }
   return recovered;
 }
+const DOLLAR_PRICE_RE = /\$\s?\d{2,4}(?:[,.]\d{2})?\b/;
+const FLIGHT_TASK_RE = /\b(?:flight|flights|airfare|air fare|plane ticket|airline|airport|google flights|pdx|sfo|san francisco|portland)\b/i;
+const SHOPPING_INTENT_RE = /\b(?:cheap|cheapest|price|prices|fare|fares|one[- ]?way|round[- ]?trip|depart|departure|arrive|arrival|from|to)\b/i;
+const FLIGHT_CLAIM_CONTEXT_RE = /\b(?:flight|flights|airline|airlines|departure|arrival|depart|arrive|nonstop|non-stop|stops?|duration|alaska|united|delta|american|southwest|frontier|spirit|jetblue|hawaiian)\b/i;
+const FLIGHT_RESULT_CONTEXT_RE = /\b(?:best departing flights|departing flights|returning flights|flight results|google flights|airline|airlines|duration|nonstop|non-stop|stops?|departure|arrival|depart|arrive|price|fare|fares|alaska|united|delta|american|southwest|frontier|spirit|jetblue|hawaiian)\b/i;
+const EMPTY_FORM_CONTEXT_RE = /\b(?:where to\?|search airports or cities|destination|from\?|departure date|calendar|google flights)\b/i;
+const TOOL_FAILURE_RE = /\b(?:error|failed|type-not-applied|did not type|could not type|not applied|unsupported|invalid args)\b/i;
+function normalizeEvidenceText(text) {
+  return (text || "").replace(/\s+/g, " ").trim();
+}
+function looksLikeFlightShoppingTask(userMessage) {
+  return FLIGHT_TASK_RE.test(userMessage) && SHOPPING_INTENT_RE.test(userMessage);
+}
+function answerIncludesFlightPriceClaims(assistantText) {
+  return DOLLAR_PRICE_RE.test(assistantText) && FLIGHT_CLAIM_CONTEXT_RE.test(assistantText);
+}
+function toolResultHasFlightPriceEvidence(latestToolResultPreview) {
+  const text = normalizeEvidenceText(latestToolResultPreview);
+  if (!text) return false;
+  if (TOOL_FAILURE_RE.test(text) && !DOLLAR_PRICE_RE.test(text)) return false;
+  return DOLLAR_PRICE_RE.test(text) && FLIGHT_RESULT_CONTEXT_RE.test(text);
+}
+function shouldBlockUnsupportedFlightPriceAnswer(userMessage, assistantText, latestToolResultPreview) {
+  return looksLikeFlightShoppingTask(userMessage) && answerIncludesFlightPriceClaims(assistantText) && !toolResultHasFlightPriceEvidence(latestToolResultPreview);
+}
+function buildFlightPriceEvidenceRecoveryPrompt(userMessage, assistantText, latestToolResultPreview) {
+  const latest = normalizeEvidenceText(latestToolResultPreview);
+  const maybeFormState = latest && EMPTY_FORM_CONTEXT_RE.test(latest) ? " The latest page state still looks like a flight search form, so verify the destination, route, and date before reading results." : "";
+  return [
+    `The user asked for live flight prices: ${userMessage}`,
+    `Your last answer included specific flight prices, but the latest browser/tool evidence does not show visible flight-result rows with prices.`,
+    `Erase that answer and continue with browser tools until the current page evidence shows the route/date and visible priced flight results.${maybeFormState}`,
+    `Do not report airline names, times, or prices unless they are visible in the latest browser/page evidence.`,
+    `Last unsupported answer: ${assistantText.replace(/\s+/g, " ").trim().slice(0, 500) || "(empty)"}`
+  ].join("\n");
+}
 const logger$v = createLogger("OpenAIProvider");
 function shouldDebugAgentLoop() {
   const value = process.env.VESSEL_DEBUG_AGENT_LOOP;
@@ -9137,6 +9170,7 @@ class OpenAICompatProvider {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
       let compactRecoveryCount = 0;
+      let flightPriceEvidenceRecoveryCount = 0;
       let compactCorrectionCount = 0;
       const recentCompactToolSignatures = [];
       const recentToolNames = [];
@@ -9273,6 +9307,24 @@ class OpenAICompatProvider {
         };
         messages.push(assistantMsg);
         if (toolCalls.length === 0) {
+          const latestToolResultContent = latestToolMessage ? String(latestToolMessage.content || "") : null;
+          if (flightPriceEvidenceRecoveryCount < 2 && shouldBlockUnsupportedFlightPriceAnswer(
+            userMessage,
+            textAccum,
+            latestToolResultContent
+          )) {
+            flightPriceEvidenceRecoveryCount += 1;
+            if (textAccum.trim()) onChunk("<<erase_prev>>");
+            messages.push({
+              role: "user",
+              content: `[System] ${buildFlightPriceEvidenceRecoveryPrompt(
+                userMessage,
+                textAccum,
+                latestToolResultContent
+              )}`
+            });
+            continue;
+          }
           if (compactRecoveryCount < 2 && shouldRetryCompactToolLoop(
             this.agentToolProfile,
             textAccum,
@@ -9285,7 +9337,7 @@ class OpenAICompatProvider {
               content: `[System] ${buildCompactRecoveryPrompt(
                 userMessage,
                 textAccum,
-                latestToolMessage ? String(latestToolMessage.content || "") : null
+                latestToolResultContent
               )}`
             });
             continue;
@@ -9293,6 +9345,7 @@ class OpenAICompatProvider {
           break;
         }
         compactRecoveryCount = 0;
+        flightPriceEvidenceRecoveryCount = 0;
         const iterationToolResultPreviews = [];
         for (const tc of toolCalls) {
           if (!availableToolNames.has(tc.name)) {
@@ -9837,10 +9890,17 @@ function summarizeToolArg(args) {
   const index = typeof args.index === "number" ? `#${args.index}` : typeof args.index === "string" && args.index.trim() ? `#${args.index.trim()}` : "";
   return [args.url, args.query, args.text, args.selector, index, args.direction].map((value) => typeof value === "string" ? value : "").find((value) => value.length > 0) ?? "";
 }
+function normalizeCodexText(text) {
+  return text.trim().toLowerCase().replace(/[‘’]/g, "'").replace(/[“”]/g, '"');
+}
 function looksLikeFailedToolOutput(output) {
-  const normalized = output.trim().toLowerCase();
+  const normalized = normalizeCodexText(output);
   return normalized.startsWith("error") || normalized.startsWith("warning") || normalized.startsWith("target") || normalized.startsWith("no active tab") || normalized.includes("same page — results may have loaded dynamically") || normalized.includes("could not ") || normalized.includes("did not ");
 }
+function looksLikeTravelFareContext(text) {
+  const normalized = normalizeCodexText(text);
+  return /\b(?:flight|flights|fare|fares|airline|airlines|one-way|roundtrip|nonstop|layover|departure|arrival)\b/.test(normalized) || /\b(?:pdx|sfo|oak|sjc)\b/.test(normalized) || /\$[\d,]+/.test(normalized);
+}
 function emitCodexToolChunk(onChunk, name, args, output) {
   const summary = summarizeToolArg(args);
   const argSummary = looksLikeFailedToolOutput(output) ? ["⚠ failed", summary].filter(Boolean).join(" ") : summary;
@@ -10056,7 +10116,7 @@ const REAL_PROGRESS_TOOLS = /* @__PURE__ */ new Set([
 ]);
 function shouldRetryCodexToolLoop(text, hasToolHistory) {
   if (!hasToolHistory) return false;
-  const trimmed = text.trim().toLowerCase();
+  const trimmed = normalizeCodexText(text);
   if (!trimmed) return true;
   if (trimmed.length <= 160 && trimmed.includes("?")) return true;
   const askingUserForDirection = [
@@ -10072,6 +10132,26 @@ function shouldRetryCodexToolLoop(text, hasToolHistory) {
   if (askingUserForDirection.some((signal) => trimmed.includes(signal))) {
     return true;
   }
+  const askingUserToContinue = [
+    "please let me",
+    "let me inspect",
+    "let me click",
+    "need to continue from",
+    "i need to continue",
+    "allow me to",
+    "can't access or reuse",
+    "cant access or reuse",
+    "can't access",
+    "cant access",
+    "visible context",
+    "surface it",
+    "send me the current",
+    "send me the results",
+    "send me the pricing"
+  ];
+  if (askingUserToContinue.some((signal) => trimmed.includes(signal))) {
+    return true;
+  }
   const cannotProceed = [
     "i cannot",
     "i can't",
@@ -10105,12 +10185,39 @@ function buildCodexRecoveryInput(userMessage, assistantText, latestToolResultPre
     content: [{ type: "input_text", text: lines.join("\n") }]
   };
 }
-function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview) {
+function buildCodexFlightPriceEvidenceRecoveryInput(userMessage, assistantText, latestToolResultPreview) {
+  return {
+    type: "message",
+    role: "user",
+    content: [
+      {
+        type: "input_text",
+        text: `[System] ${buildFlightPriceEvidenceRecoveryPrompt(
+          userMessage,
+          assistantText,
+          latestToolResultPreview
+        )}`
+      }
+    ]
+  };
+}
+function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1) {
   const stateReminder = buildCodexLatestStateReminder(latestToolResultPreview);
   const lines = [
     `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`,
-    `Take the next step: try a different target, refresh the page state with read_page, or call inspect_element on the intended element to verify its index and selector.`
+    `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
   ];
+  if (failedClickCount >= 2) {
+    lines.push(
+      `You have already had multiple failed clicks without making page progress. Do not keep clicking similar search result titles. Use the latest read_page/search result text to answer, or inspect a specific indexed result/control only if essential.`
+    );
+  }
+  if (looksLikeTravelFareContext(`${attemptedTarget}
+${latestToolResultPreview || ""}`)) {
+    lines.push(
+      `For flight-price tasks, visible fare snippets are enough to compare candidates. If the results show prices, stops, airlines, or route names, report the cheapest visible option with caveats instead of trying to open every aggregator result.`
+    );
+  }
   if (stateReminder) {
     lines.push(stateReminder);
   }
@@ -10307,11 +10414,13 @@ class CodexProvider {
     let turnState = null;
     let toolHistoryCount = 0;
     let recoveryCount = 0;
+    let flightPriceEvidenceRecoveryCount = 0;
     let correctionCount = 0;
     const recentToolSignatures = [];
     const recentToolNames = [];
     let clickReadLoopNudged = false;
     let latestToolResultPreview = null;
+    let failedClickCountSinceProgress = 0;
     const recentSuccessfulSearchQueries = [];
     const recentSuccessfulSearchToolByQuery = /* @__PURE__ */ new Map();
     let lastSuccessfulWebSearchQuery = null;
@@ -10351,6 +10460,22 @@ class CodexProvider {
           }
         }
         if (functionCalls.length === 0) {
+          if (flightPriceEvidenceRecoveryCount < 2 && shouldBlockUnsupportedFlightPriceAnswer(
+            userMessage,
+            result.text,
+            latestToolResultPreview
+          )) {
+            flightPriceEvidenceRecoveryCount += 1;
+            if (result.text.trim()) onChunk("<<erase_prev>>");
+            currentInput = [
+              buildCodexFlightPriceEvidenceRecoveryInput(
+                userMessage,
+                result.text,
+                latestToolResultPreview
+              )
+            ];
+            continue;
+          }
           if (recoveryCount < 1 && shouldRetryCodexToolLoop(result.text, toolHistoryCount > 0)) {
             recoveryCount += 1;
             if (result.text.trim()) onChunk("<<erase_prev>>");
@@ -10366,6 +10491,7 @@ class CodexProvider {
           break;
         }
         recoveryCount = 0;
+        flightPriceEvidenceRecoveryCount = 0;
         currentInput = [];
         for (const fc of functionCalls) {
           const functionCallInput = createCodexFunctionCallInput(fc);
@@ -10467,6 +10593,7 @@ ${latestToolResultPreview || ""}`
           if (!looksLikeFailedToolOutput(outputText)) {
             if (isRealProgressTool(prepared.prepared.name)) {
               lastSuccessfulWebSearchQuery = null;
+              failedClickCountSinceProgress = 0;
             }
           }
           if (searchToolQuery && !looksLikeFailedToolOutput(outputText) && !recentSuccessfulSearchQueries.includes(searchToolQuery)) {
@@ -10488,10 +10615,12 @@ ${latestToolResultPreview || ""}`
             }
           }
           if (prepared.prepared.name === "click" && looksLikeFailedToolOutput(outputText)) {
+            failedClickCountSinceProgress += 1;
             currentInput.push(
               buildCodexFailedClickRecoveryInput(
                 summarizeToolArg(prepared.prepared.args),
-                latestToolResultPreview
+                latestToolResultPreview,
+                failedClickCountSinceProgress
               )
             );
           }
@@ -12195,6 +12324,12 @@ function formatElementMeta(el) {
   if (el.checked !== void 0) {
     meta.push(el.checked ? "checked" : "unchecked");
   }
+  if (el.focused) {
+    meta.push("focused");
+  }
+  if (el.hasValue && !shouldRenderFieldValue(el)) {
+    meta.push("has-value");
+  }
   if (el.ariaExpanded !== void 0) {
     meta.push(`expanded=${el.ariaExpanded}`);
   }
@@ -12256,6 +12391,49 @@ function summarizeElementValue(el) {
   }
   return null;
 }
+function isTextEntryControl$1(el) {
+  if (el.disabled) return false;
+  if (el.type !== "input" && el.type !== "textarea") return false;
+  const inputType = (el.inputType || "text").toLowerCase();
+  return ![
+    "button",
+    "checkbox",
+    "file",
+    "hidden",
+    "image",
+    "radio",
+    "reset",
+    "submit"
+  ].includes(inputType);
+}
+function hasRenderedValue(el) {
+  return Boolean(summarizeElementValue(el));
+}
+function hasAnyFieldValue(el) {
+  return el.hasValue === true || typeof el.value === "string" && el.value.trim().length > 0;
+}
+function formatFillHint(el) {
+  if (el.index == null || el.disabled) return null;
+  if (el.focused && isTextEntryControl$1(el)) {
+    return `cursor is here; type_text(text="...") or type_text(index=${el.index})`;
+  }
+  if (hasAnyFieldValue(el) && isTextEntryControl$1(el)) {
+    return `already has value; use type_text(index=${el.index}) only to change it`;
+  }
+  if (isTextEntryControl$1(el)) return `use type_text(index=${el.index})`;
+  if (el.type === "select") return `use select_option(index=${el.index})`;
+  return null;
+}
+function appendFieldAffordances(parts, el) {
+  if (isTextEntryControl$1(el)) {
+    parts.push("fillable");
+    if (!hasAnyFieldValue(el)) parts.push("empty");
+  } else if (el.type === "select") {
+    if (!hasRenderedValue(el) && !hasAnyFieldValue(el)) parts.push("not-selected");
+  }
+  const hint = formatFillHint(el);
+  if (hint) parts.push(hint);
+}
 function isQuantityLike(el) {
   const text = [
     el.label,
@@ -12535,12 +12713,14 @@ function formatInteractiveElements(elements) {
       parts.push("input");
       const summary = summarizeElementValue(el);
       if (summary) parts.push(`${summary.label}="${summary.value}"`);
+      if (!isQuantityLike(el)) appendFieldAffordances(parts, el);
       if (el.required) parts.push("(required)");
     } else if (el.type === "select") {
       parts.push(`[${el.label || "Select"}]`);
       parts.push("dropdown");
       const summary = summarizeElementValue(el);
       if (summary) parts.push(`${summary.label}="${summary.value}"`);
+      appendFieldAffordances(parts, el);
       if (el.options?.length) {
         parts.push(
           `options=${el.options.slice(0, 5).map((o) => typeof o === "string" ? o : o.label || o.value).join("|")}`
@@ -12551,6 +12731,7 @@ function formatInteractiveElements(elements) {
       parts.push("textarea");
       const summary = summarizeElementValue(el);
       if (summary) parts.push(`${summary.label}="${summary.value}"`);
+      appendFieldAffordances(parts, el);
     }
     const meta = formatElementMeta(el);
     if (meta.length > 0) parts.push(`(${meta.join(", ")})`);
@@ -12595,12 +12776,14 @@ function formatForms(forms) {
           fieldParts.push(field.inputType || "text");
           const summary = summarizeElementValue(field);
           if (summary) fieldParts.push(`${summary.label}="${summary.value}"`);
+          if (!isQuantityLike(field)) appendFieldAffordances(fieldParts, field);
           if (field.required) fieldParts.push("(required)");
         } else if (field.type === "select") {
           fieldParts.push(`[${field.label || "Select"}]`);
           fieldParts.push("dropdown");
           const summary = summarizeElementValue(field);
           if (summary) fieldParts.push(`${summary.label}="${summary.value}"`);
+          appendFieldAffordances(fieldParts, field);
           if (field.options?.length) {
             fieldParts.push(
               `options=${field.options.slice(0, 5).map((o) => typeof o === "string" ? o : o.label || o.value).join("|")}`
@@ -12611,6 +12794,7 @@ function formatForms(forms) {
           fieldParts.push("textarea");
           const summary = summarizeElementValue(field);
           if (summary) fieldParts.push(`${summary.label}="${summary.value}"`);
+          appendFieldAffordances(fieldParts, field);
         }
         const meta = formatElementMeta(field);
         if (meta.length > 0) fieldParts.push(`(${meta.join(", ")})`);
@@ -13221,6 +13405,7 @@ function buildScopedContext(page, mode) {
       const cartSnapshot = formatCartSnapshot(visiblePage);
       const visibleForms = visiblePage.forms;
       const dialogFocus = formatDialogFocus(page);
+      const flightBookingFormHint = getFlightBookingFormHint(page);
       const sections = [];
       sections.push(`**URL:** ${page.url}`);
       sections.push(`**Title:** ${page.title}`);
@@ -13242,6 +13427,11 @@ function buildScopedContext(page, mode) {
         sections.push(formatPageIssues(page.pageIssues ?? []));
         sections.push("");
       }
+      if (flightBookingFormHint) {
+        sections.push("### Flight Booking Hint");
+        sections.push(flightBookingFormHint);
+        sections.push("");
+      }
       if (page.overlays.length > 0) {
         sections.push("### Active Overlays");
         sections.push(formatOverlays(page));
@@ -13379,9 +13569,41 @@ function detectPageType(page) {
     return "ARTICLE";
   return "GENERAL";
 }
+function isFlightBookingPage(page) {
+  const pageText = [
+    page.url,
+    page.title,
+    page.excerpt,
+    page.headings.map((heading) => heading.text).join(" ")
+  ].filter(Boolean).join(" ").toLowerCase();
+  if (/google\.com\/travel\/flights|google flights/.test(pageText)) {
+    return true;
+  }
+  const controlsText = [
+    ...page.interactiveElements,
+    ...page.forms.flatMap((form) => form.fields)
+  ].map(
+    (el) => [el.label, el.placeholder, el.name, el.text, el.role, el.inputType].filter(Boolean).join(" ")
+  ).join(" ").toLowerCase();
+  const hasRouteControls = /\b(?:where from|where to|origin|destination|from|to)\b/.test(
+    controlsText
+  );
+  const hasDateControls = /\b(?:departure|depart|return|date)\b/.test(
+    controlsText
+  );
+  const hasFlightLanguage = /\b(?:flight|flights|airfare|airline)\b/.test(
+    `${pageText} ${controlsText}`
+  );
+  return hasFlightLanguage && hasRouteControls && hasDateControls;
+}
+function getFlightBookingFormHint(page) {
+  if (!isFlightBookingPage(page)) return null;
+  return "Flight booking form: use the visible route, destination, and date controls with type_text/select_option/click/submit_form before constructing direct Google Flights or travel-search URLs. Direct travel URLs are a fallback only after visible controls fail or the page is unusable.";
+}
 function analyzePageIntent(page) {
   const hints = [];
   const pageType = detectPageType(page);
+  const flightBookingFormHint = getFlightBookingFormHint(page);
   const hasPagination = page.interactiveElements.some(
     (el) => (el.text || "").toLowerCase() === "next" || el.text === "›" || el.text === "»" || (el.label || "").toLowerCase().includes("next page")
   );
@@ -13409,6 +13631,7 @@ function analyzePageIntent(page) {
       hints.push(
         "Treat the visible site search box as the primary navigation control before jumping to direct URLs."
       );
+      if (flightBookingFormHint) hints.push(flightBookingFormHint);
       break;
     case "SEARCH_RESULTS":
       hints.push("Page type: SEARCH RESULTS");
@@ -13429,6 +13652,7 @@ function analyzePageIntent(page) {
         `Page type: FORM (${formCount} form${formCount > 1 ? "s" : ""}, ${totalFields} fields)`
       );
       hints.push("Suggested: vessel_fill_form → fill all fields in one call");
+      if (flightBookingFormHint) hints.push(flightBookingFormHint);
       break;
     }
     case "PAGINATED_LIST":
@@ -13440,7 +13664,10 @@ function analyzePageIntent(page) {
       hints.push("Suggested: vessel_extract_content for readable text");
       break;
   }
-  if (hints.length === 0) return "";
+  if (hints.length === 0 && !flightBookingFormHint) return "";
+  if (flightBookingFormHint && pageType !== "SEARCH_READY" && pageType !== "FORM") {
+    hints.push(flightBookingFormHint);
+  }
   return `### Page Intent (Speedee)
 ${hints.join("\n")}`;
 }
@@ -13712,11 +13939,45 @@ function elementLabel(element) {
     96
   ) || "Element";
 }
+function isTextEntryControl(element) {
+  if (element.disabled) return false;
+  if (element.type !== "input" && element.type !== "textarea") return false;
+  const inputType = (element.inputType || "text").toLowerCase();
+  return ![
+    "button",
+    "checkbox",
+    "file",
+    "hidden",
+    "image",
+    "radio",
+    "reset",
+    "submit"
+  ].includes(inputType);
+}
+function formatFieldAffordance(element) {
+  if (element.index == null || element.disabled) return "";
+  const hasValue = element.hasValue === true || typeof element.value === "string" && element.value.trim();
+  const empty = hasValue ? "" : "; empty";
+  if (isTextEntryControl(element)) {
+    if (element.focused) {
+      return `${empty}; focused; type_text(text="...") targets this`;
+    }
+    if (hasValue) {
+      return `; has value; type_text(index=${element.index}) changes it`;
+    }
+    return `${empty}; use type_text(index=${element.index})`;
+  }
+  if (element.type === "select") {
+    return `; use select_option(index=${element.index})`;
+  }
+  return "";
+}
 function formatElement(element) {
   const prefix = element.index != null ? `[#${element.index}] ` : "";
   const kind = element.type === "input" ? `${element.inputType || "text"} input` : element.type === "select" ? "select" : element.type;
   const href = element.type === "link" && element.href ? ` -> ${element.href}` : "";
-  return `${prefix}${elementLabel(element)} (${kind})${href}`;
+  const affordance = formatFieldAffordance(element);
+  return `${prefix}${elementLabel(element)} (${kind}${affordance})${href}`;
 }
 function uniqueElements(elements) {
   const seen = /* @__PURE__ */ new Set();
@@ -14676,6 +14937,26 @@ function buildDefaultEngineShortcut(rawQuery) {
     appliedFilters: []
   };
 }
+function looksLikeFlightSearchText(text) {
+  const lower = text.toLowerCase();
+  return /\b(flight|flights|airfare|air fare|plane ticket|plane tickets)\b/.test(
+    lower
+  ) || /\b(one-way|one way|roundtrip|round trip)\b/.test(lower) && /\b(to|from)\b/.test(lower);
+}
+function buildFlightSearchShortcut(rawQuery, taskGoal) {
+  const goalQuery = normalizeSearchQuery(taskGoal || "");
+  const toolQuery = normalizeSearchQuery(rawQuery);
+  const combined = normalizeSearchQuery(`${goalQuery} ${toolQuery}`);
+  if (!looksLikeFlightSearchText(combined)) return null;
+  const searchQuery = looksLikeFlightSearchText(goalQuery) ? goalQuery : toolQuery;
+  if (!searchQuery) return null;
+  return {
+    url: `https://www.google.com/travel/flights?q=${encodeURIComponent(searchQuery)}`,
+    source: "Google Flights",
+    section: "flight search",
+    appliedFilters: []
+  };
+}
 function buildSearchEngineLandingShortcut(currentUrl, rawQuery) {
   let url;
   try {
@@ -14794,6 +15075,304 @@ function describeFillField(field) {
   if (field.placeholder) return `placeholder=${field.placeholder}`;
   return "field";
 }
+const FILLABLE_CONTROL_HELPERS = `
+function vesselText(value) {
+  return value == null ? "" : String(value).trim();
+}
+
+function vesselControlLabel(el, original) {
+  var source = el || original;
+  return vesselText(source && source.getAttribute && source.getAttribute("aria-label")) ||
+    vesselText(source && source.getAttribute && source.getAttribute("placeholder")) ||
+    vesselText(source && source.getAttribute && source.getAttribute("name")) ||
+    vesselText(original && original.getAttribute && original.getAttribute("aria-label")) ||
+    vesselText(original && original.textContent).slice(0, 80) ||
+    "input";
+}
+
+function vesselIsVisible(el) {
+  if (!(el instanceof HTMLElement)) return false;
+  var style = window.getComputedStyle(el);
+  if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+  if (el.hasAttribute("hidden") || el.getAttribute("aria-hidden") === "true") return false;
+  var rect = el.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+
+function vesselIsDisabled(el) {
+  return !!(el && (el.disabled || el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true"));
+}
+
+function vesselIsNativeField(el) {
+  return el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement;
+}
+
+function vesselIsEditableElement(el) {
+  if (!(el instanceof HTMLElement)) return false;
+  var role = (el.getAttribute("role") || "").toLowerCase();
+  return el.isContentEditable ||
+    el.getAttribute("contenteditable") === "true" ||
+    role === "textbox" ||
+    role === "searchbox";
+}
+
+function vesselResolveFillableControl(el) {
+  if (!el) return null;
+  if (vesselIsNativeField(el) || vesselIsEditableElement(el)) return el;
+  if (!(el instanceof Element)) return null;
+  var nested = el.querySelector("input:not([type='hidden']):not([type='submit']):not([type='button']), textarea, select, [contenteditable='true'], [role='textbox'], [role='searchbox']");
+  return nested instanceof HTMLElement ? nested : null;
+}
+
+function vesselIsTextEntryActivator(el) {
+  if (!(el instanceof HTMLElement)) return false;
+  var role = (el.getAttribute("role") || "").toLowerCase();
+  return role === "combobox" ||
+    el.getAttribute("aria-haspopup") === "listbox" ||
+    !!el.getAttribute("aria-controls");
+}
+
+function vesselFindVisibleFillableControl(original) {
+  var active = vesselResolveFillableControl(document.activeElement);
+  if (active && vesselIsVisible(active) && !vesselIsDisabled(active)) return active;
+
+  var scopes = Array.from(document.querySelectorAll("dialog[open], [role='dialog'], [role='alertdialog'], [aria-modal='true'], [role='listbox'], [role='combobox'][aria-expanded='true']"));
+  scopes.push(document.body);
+  var selector = "input:not([type='hidden']):not([type='submit']):not([type='button']), textarea, select, [contenteditable='true'], [role='textbox'], [role='searchbox']";
+  for (var i = 0; i < scopes.length; i += 1) {
+    var scope = scopes[i];
+    if (!scope || !(scope instanceof Element)) continue;
+    var candidates = Array.from(scope.querySelectorAll(selector));
+    for (var j = 0; j < candidates.length; j += 1) {
+      var candidate = vesselResolveFillableControl(candidates[j]);
+      if (candidate && candidate !== original && vesselIsVisible(candidate) && !vesselIsDisabled(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+
+async function vesselFindFillTarget(original) {
+  var direct = vesselResolveFillableControl(original);
+  if (direct && !vesselIsDisabled(direct)) return { el: direct, activated: false };
+
+  if (vesselIsTextEntryActivator(original)) {
+    original.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+    original.focus();
+    original.click();
+    await new Promise(function(resolve) { setTimeout(resolve, 180); });
+    var opened = vesselFindVisibleFillableControl(original);
+    if (opened) return { el: opened, activated: true };
+  }
+
+  return null;
+}
+
+function vesselSetNativeValue(el, value) {
+  var proto = el instanceof HTMLTextAreaElement
+    ? HTMLTextAreaElement.prototype
+    : el instanceof HTMLSelectElement
+      ? HTMLSelectElement.prototype
+      : HTMLInputElement.prototype;
+  var desc = Object.getOwnPropertyDescriptor(proto, "value");
+  if (desc && desc.set) {
+    desc.set.call(el, value);
+  } else {
+    el.value = value;
+  }
+}
+
+function vesselDispatchTextEvents(el, value) {
+  try {
+    el.dispatchEvent(new InputEvent("beforeinput", {
+      bubbles: true,
+      cancelable: true,
+      data: value,
+      inputType: "insertText",
+    }));
+  } catch {}
+  try {
+    el.dispatchEvent(new InputEvent("input", {
+      bubbles: true,
+      cancelable: true,
+      data: value,
+      inputType: "insertText",
+    }));
+  } catch {
+    el.dispatchEvent(new Event("input", { bubbles: true }));
+  }
+  el.dispatchEvent(new Event("change", { bubbles: true }));
+}
+
+function vesselReadFillableControlValue(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    return el.value || "";
+  }
+  return el.textContent || "";
+}
+
+function vesselValueWasApplied(el, value) {
+  var actual = vesselReadFillableControlValue(el);
+  if (!value) return !actual;
+  return actual === value || actual.toLowerCase().indexOf(value.toLowerCase()) >= 0;
+}
+
+async function vesselSetFillableControlValue(original, value) {
+  var target = await vesselFindFillTarget(original);
+  if (!target || !target.el) {
+    return "Error[not-input]: Element is not text-editable. Click it first, then type into the opened text field.";
+  }
+  var el = target.el;
+  if (vesselIsDisabled(el)) return "Error[disabled]: Input is disabled";
+
+  if (el instanceof HTMLSelectElement) {
+    var requested = value.trim().toLowerCase();
+    var option = Array.from(el.options).find(function(item) {
+      return item.value.trim().toLowerCase() === requested ||
+        (item.textContent || "").trim().toLowerCase() === requested;
+    });
+    if (!option) return "Error[option-not-found]: Option not found";
+    el.value = option.value;
+    el.focus();
+    el.dispatchEvent(new Event("input", { bubbles: true }));
+    el.dispatchEvent(new Event("change", { bubbles: true }));
+    return "Selected: " + ((option.textContent || option.value).trim().slice(0, 100));
+  }
+
+  el.focus();
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+    vesselSetNativeValue(el, value);
+  } else {
+    el.textContent = value;
+  }
+  vesselDispatchTextEvents(el, value);
+  await new Promise(function(resolve) { setTimeout(resolve, 80); });
+  if (!vesselValueWasApplied(el, value)) {
+    return "Error[type-not-applied]: The page did not keep the typed text. Retry with type_text(index=..., text=..., mode=\\"keystroke\\") or click the focused text box and type again.";
+  }
+
+  var label = vesselControlLabel(el, original);
+  var displayValue = el instanceof HTMLInputElement && el.type === "password"
+    ? "[hidden]"
+    : value.slice(0, 80);
+  return "Typed into: " + label + " = " + displayValue + (target.activated ? " (opened field)" : "");
+}
+
+async function vesselTypeFillableControlKeystrokes(original, value) {
+  var target = await vesselFindFillTarget(original);
+  if (!target || !target.el) {
+    return "Error[not-input]: Element is not text-editable. Click it first, then type into the opened text field.";
+  }
+  var el = target.el;
+  if (vesselIsDisabled(el)) return "Error[disabled]: Input is disabled";
+  if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || vesselIsEditableElement(el))) {
+    return "Error[not-input]: Element is not a text input";
+  }
+
+  el.focus();
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+    vesselSetNativeValue(el, "");
+  } else {
+    el.textContent = "";
+  }
+  vesselDispatchTextEvents(el, "");
+
+  var chars = value.split("");
+  for (var i = 0; i < chars.length; i += 1) {
+    var ch = chars[i];
+    el.dispatchEvent(new KeyboardEvent("keydown", { key: ch, bubbles: true, cancelable: true }));
+    el.dispatchEvent(new KeyboardEvent("keypress", { key: ch, bubbles: true, cancelable: true }));
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+      vesselSetNativeValue(el, el.value + ch);
+    } else {
+      el.textContent = (el.textContent || "") + ch;
+    }
+    el.dispatchEvent(new InputEvent("input", {
+      bubbles: true,
+      cancelable: true,
+      data: ch,
+      inputType: "insertText",
+    }));
+    el.dispatchEvent(new KeyboardEvent("keyup", { key: ch, bubbles: true, cancelable: true }));
+  }
+  el.dispatchEvent(new Event("change", { bubbles: true }));
+  await new Promise(function(resolve) { setTimeout(resolve, 80); });
+  if (!vesselValueWasApplied(el, value)) {
+    return "Error[type-not-applied]: The page did not keep the typed text after keystrokes. Click the text box again or use press_key for the active field.";
+  }
+  return "Typed into: " + vesselControlLabel(el, original) + " = " + value.slice(0, 80) + (target.activated ? " (opened field)" : "");
+}
+`;
+function shouldRetryWithNativeTyping(result) {
+  return typeof result === "string" && result.startsWith("Error[type-not-applied]");
+}
+async function typeTextWithNativeInput(wc, selector, value) {
+  const focusResult = await executePageScript(
+    wc,
+    `
+    (async function() {
+      ${FILLABLE_CONTROL_HELPERS}
+      const el = ${selector.includes(" >>> ") ? `window.__vessel?.resolveShadowSelector?.(${JSON.stringify(selector)})` : `document.querySelector(${JSON.stringify(selector)})`};
+      if (!el) return { error: 'Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh.' };
+      const target = await vesselFindFillTarget(el);
+      if (!target || !target.el) {
+        return { error: "Error[not-input]: Element is not text-editable. Click it first, then type into the opened text field." };
+      }
+      target.el.focus();
+      return { label: vesselControlLabel(target.el, el) };
+    })()
+  `,
+    {
+      timeoutMs: 2500,
+      label: "prepare native typing"
+    }
+  );
+  if (focusResult === PAGE_SCRIPT_TIMEOUT) return pageBusyError("type_text");
+  if (!focusResult || typeof focusResult !== "object") {
+    return "Error: Could not prepare native typing";
+  }
+  if (typeof focusResult.error === "string") return focusResult.error;
+  wc.focus();
+  const selectModifier = process.platform === "darwin" ? "meta" : "control";
+  wc.sendInputEvent({ type: "keyDown", keyCode: "A", modifiers: [selectModifier] });
+  await sleep(8);
+  wc.sendInputEvent({ type: "keyUp", keyCode: "A", modifiers: [selectModifier] });
+  await sleep(8);
+  wc.sendInputEvent({ type: "keyDown", keyCode: "Backspace" });
+  await sleep(4);
+  wc.sendInputEvent({ type: "keyUp", keyCode: "Backspace" });
+  for (const char of value) {
+    wc.sendInputEvent({ type: "keyDown", keyCode: char });
+    wc.sendInputEvent({ type: "char", keyCode: char });
+    wc.sendInputEvent({ type: "keyUp", keyCode: char });
+    await sleep(2);
+  }
+  await sleep(120);
+  const verify = await executePageScript(
+    wc,
+    `
+    (function() {
+      ${FILLABLE_CONTROL_HELPERS}
+      const active = vesselResolveFillableControl(document.activeElement);
+      if (!active) return { ok: false, actual: "" };
+      const actual = vesselReadFillableControlValue(active);
+      return { ok: vesselValueWasApplied(active, ${JSON.stringify(value)}), actual: actual.slice(0, 80) };
+    })()
+  `,
+    {
+      timeoutMs: 1500,
+      label: "verify native typing"
+    }
+  );
+  if (verify === PAGE_SCRIPT_TIMEOUT) return pageBusyError("type_text");
+  if (!verify || verify.ok !== true) {
+    const actual = verify && typeof verify.actual === "string" && verify.actual ? ` Current field text: "${verify.actual}".` : "";
+    return `Error[type-not-applied]: The page did not accept the typed text.${actual} Click the field again or use a different indexed text box.`;
+  }
+  const label = typeof focusResult.label === "string" && focusResult.label ? focusResult.label : "input";
+  return `Typed into: ${label} = ${value.slice(0, 80)} (native input)`;
+}
 async function resolveFieldSelector(wc, field) {
   const directSelector = await resolveSelector(wc, field.index, field.selector);
   if (directSelector) return directSelector;
@@ -14849,8 +15428,22 @@ async function resolveFieldSelector(wc, field) {
           return normalize(parts.join(" "));
         }
 
+        function isNativeField(el) {
+          return el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement;
+        }
+
+        function isCustomTextField(el) {
+          if (!(el instanceof HTMLElement)) return false;
+          var role = (el.getAttribute("role") || "").toLowerCase();
+          return el.isContentEditable ||
+            el.getAttribute("contenteditable") === "true" ||
+            role === "textbox" ||
+            role === "searchbox" ||
+            role === "combobox";
+        }
+
         function scoreField(el) {
-          if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
+          if (!isNativeField(el) && !isCustomTextField(el)) {
             return -1;
           }
           if (!isVisible(el) || el.disabled || el.getAttribute("aria-disabled") === "true") {
@@ -14879,10 +15472,11 @@ async function resolveFieldSelector(wc, field) {
 
           if (score === 0) return -1;
           if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) score += 5;
+          if (isCustomTextField(el)) score += 3;
           return score;
         }
 
-        const candidates = Array.from(document.querySelectorAll("input, textarea, select"));
+        const candidates = Array.from(document.querySelectorAll("input, textarea, select, [contenteditable='true'], [role='textbox'], [role='searchbox'], [role='combobox']"));
         let best = null;
         let bestScore = -1;
         for (const el of candidates) {
@@ -14932,136 +15526,73 @@ async function setElementValue(wc, selector, value) {
     const result2 = await executePageScript(
       wc,
       `
-      (function() {
+      (async function() {
+        ${FILLABLE_CONTROL_HELPERS}
         var el = window.__vessel?.resolveShadowSelector?.(${JSON.stringify(selector)});
         if (!el) return "Error[stale-index]: Shadow DOM element not found — call read_page to refresh.";
-        if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) return "Error[not-input]: Element is not a fillable input";
-        if (el.disabled || el.getAttribute("aria-disabled") === "true") return "Error[disabled]: Input is disabled";
-        if (el instanceof HTMLSelectElement) {
-          var requested = ${JSON.stringify(value)}.trim().toLowerCase();
-          var option = Array.from(el.options).find(function(item) {
-            return item.value.trim().toLowerCase() === requested ||
-              (item.textContent || "").trim().toLowerCase() === requested;
-          });
-          if (!option) return "Error[option-not-found]: Option not found";
-          el.value = option.value;
-          el.focus();
-          el.dispatchEvent(new Event("input", { bubbles: true }));
-          el.dispatchEvent(new Event("change", { bubbles: true }));
-          return "Selected: " + ((option.textContent || option.value).trim().slice(0, 100));
-        }
-        var proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
-        var desc = Object.getOwnPropertyDescriptor(proto, "value");
-        if (desc && desc.set) { desc.set.call(el, ${JSON.stringify(value)}); } else { el.value = ${JSON.stringify(value)}; }
-        el.focus();
-        el.dispatchEvent(new Event("input", { bubbles: true }));
-        el.dispatchEvent(new Event("change", { bubbles: true }));
-        return "Typed into: " + (el.getAttribute("aria-label") || el.placeholder || el.name || "input");
+        return vesselSetFillableControlValue(el, ${JSON.stringify(value)});
       })()
     `,
       {
         label: "type text in shadow input"
       }
     );
-    return result2 === PAGE_SCRIPT_TIMEOUT ? pageBusyError("type_text") : result2 || "Error: Could not type into element";
+    if (result2 === PAGE_SCRIPT_TIMEOUT) return pageBusyError("type_text");
+    if (shouldRetryWithNativeTyping(result2)) {
+      return typeTextWithNativeInput(wc, selector, value);
+    }
+    return result2 || "Error: Could not type into element";
   }
   const result = await executePageScript(
     wc,
     `
-    (function() {
+    (async function() {
+      ${FILLABLE_CONTROL_HELPERS}
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return 'Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh.';
-      if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
-        return 'Error[not-input]: Element is not a fillable input';
-      }
-      if (el.disabled || el.getAttribute('aria-disabled') === 'true') {
-        return 'Error[disabled]: Input is disabled';
-      }
-
-      if (el instanceof HTMLSelectElement) {
-        const requested = ${JSON.stringify(value)}.trim().toLowerCase();
-        const option = Array.from(el.options).find((item) => {
-          const label = (item.textContent || '').trim().toLowerCase();
-          return label === requested || item.value.trim().toLowerCase() === requested;
-        });
-        if (!option) {
-          return 'Error[option-not-found]: Option not found';
-        }
-        el.value = option.value;
-        el.focus();
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return 'Selected: ' + ((option.textContent || option.value).trim().slice(0, 100));
-      }
-
-      const prototype = el instanceof HTMLTextAreaElement
-        ? HTMLTextAreaElement.prototype
-        : HTMLInputElement.prototype;
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
-      if (descriptor && descriptor.set) {
-        descriptor.set.call(el, ${JSON.stringify(value)});
-      } else {
-        el.value = ${JSON.stringify(value)};
-      }
-
-      el.focus();
-      el.dispatchEvent(new InputEvent('input', {
-        bubbles: true,
-        cancelable: true,
-        data: ${JSON.stringify(value)},
-        inputType: 'insertText',
-      }));
-      el.dispatchEvent(new Event('change', { bubbles: true }));
-      return 'Typed into: ' +
-        (el.getAttribute('aria-label') || el.placeholder || el.name || 'input') +
-        ' = ' + (el.type === 'password' ? '[hidden]' : String(el.value).slice(0, 80));
+      return vesselSetFillableControlValue(el, ${JSON.stringify(value)});
     })()
   `,
     {
       label: "type text"
     }
   );
-  return result === PAGE_SCRIPT_TIMEOUT ? pageBusyError("type_text") : result || "Error: Could not type into element";
+  if (result === PAGE_SCRIPT_TIMEOUT) return pageBusyError("type_text");
+  if (shouldRetryWithNativeTyping(result)) {
+    return typeTextWithNativeInput(wc, selector, value);
+  }
+  return result || "Error: Could not type into element";
 }
 async function typeKeystroke(wc, selector, value) {
+  if (selector.startsWith("__vessel_idx:")) {
+    return setElementValue(wc, selector, value);
+  }
+  if (selector.includes(" >>> ")) {
+    const result2 = await executePageScript(
+      wc,
+      `
+      (async function() {
+        ${FILLABLE_CONTROL_HELPERS}
+        var el = window.__vessel?.resolveShadowSelector?.(${JSON.stringify(selector)});
+        if (!el) return "Error[stale-index]: Shadow DOM element not found — call read_page to refresh.";
+        return vesselTypeFillableControlKeystrokes(el, ${JSON.stringify(value)});
+      })()
+    `,
+      {
+        timeoutMs: 2500,
+        label: "type keystrokes in shadow input"
+      }
+    );
+    return result2 === PAGE_SCRIPT_TIMEOUT ? pageBusyError("type_text") : result2 || "Error: Could not type into element";
+  }
   const result = await executePageScript(
     wc,
     `
     (async function() {
+      ${FILLABLE_CONTROL_HELPERS}
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return 'Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh.';
-      if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
-        return 'Error[not-input]: Element is not a text input';
-      }
-      if (el.disabled || el.getAttribute('aria-disabled') === 'true') {
-        return 'Error[disabled]: Input is disabled';
-      }
-      el.focus();
-      const prototype = el instanceof HTMLTextAreaElement
-        ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
-      if (descriptor && descriptor.set) {
-        descriptor.set.call(el, '');
-      } else {
-        el.value = '';
-      }
-      el.dispatchEvent(new InputEvent('input', { bubbles: true, cancelable: true, data: '', inputType: 'deleteContentBackward' }));
-      const chars = ${JSON.stringify(value)}.split('');
-      for (const ch of chars) {
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: ch, bubbles: true, cancelable: true }));
-        el.dispatchEvent(new KeyboardEvent('keypress', { key: ch, bubbles: true, cancelable: true }));
-        if (descriptor && descriptor.set) {
-          descriptor.set.call(el, el.value + ch);
-        } else {
-          el.value += ch;
-        }
-        el.dispatchEvent(new InputEvent('input', { bubbles: true, cancelable: true, data: ch, inputType: 'insertText' }));
-        el.dispatchEvent(new KeyboardEvent('keyup', { key: ch, bubbles: true, cancelable: true }));
-      }
-      el.dispatchEvent(new Event('change', { bubbles: true }));
-      return 'Typed into: ' +
-        (el.getAttribute('aria-label') || el.placeholder || el.name || 'input') +
-        ' = ' + (el.type === 'password' ? '[hidden]' : String(el.value).slice(0, 80));
+      return vesselTypeFillableControlKeystrokes(el, ${JSON.stringify(value)});
     })()
   `,
     {
@@ -17427,8 +17958,25 @@ async function locateImplicitTextTarget(wc) {
         }
 
         function isFillable(el) {
+          if (!(el instanceof HTMLElement)) return false;
+          if (
+            el.getAttribute("aria-disabled") === "true" ||
+            (el instanceof HTMLInputElement && (el.disabled || el.readOnly)) ||
+            (el instanceof HTMLTextAreaElement && (el.disabled || el.readOnly))
+          ) {
+            return false;
+          }
+          const role = normalize(el.getAttribute("role"));
+          if (
+            el.isContentEditable ||
+            el.getAttribute("contenteditable") === "true" ||
+            role === "textbox" ||
+            role === "searchbox" ||
+            role === "combobox"
+          ) {
+            return true;
+          }
           if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return false;
-          if (el.disabled || el.readOnly || el.getAttribute("aria-disabled") === "true") return false;
           const type = el instanceof HTMLTextAreaElement ? "text" : normalize(el.getAttribute("type") || el.type || "text");
           return ["", "search", "text", "email", "url", "tel", "number", "password"].includes(type);
         }
@@ -17445,7 +17993,7 @@ async function locateImplicitTextTarget(wc) {
         }
 
         const candidates = Array.from(
-          document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="image"]), textarea')
+          document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="image"]), textarea, [contenteditable="true"], [role="textbox"], [role="searchbox"], [role="combobox"]')
         ).filter((el) => isFillable(el) && isVisible(el));
 
         let best = null;
@@ -17697,7 +18245,8 @@ async function handleWebSearch(ctx, tabId, args) {
   if (!tab || !tabId) return "Error: No active tab";
   const query = String(args.query || "").trim();
   if (!query) return "Error: No web search query provided.";
-  const shortcut = buildDefaultEngineShortcut(query);
+  const taskGoal = ctx.runtime.getState().taskTracker?.goal;
+  const shortcut = buildFlightSearchShortcut(query, taskGoal) ?? buildDefaultEngineShortcut(query);
   if (!shortcut) {
     return "Error: No default search engine is configured. Navigate to a search engine or set a default search engine first.";
   }
@@ -22402,6 +22951,8 @@ const SHARED_NAVIGATION_INSTRUCTIONS = [
   "Prefer select_option for dropdowns and submit_form for forms instead of guessing with clicks.",
   "After navigating to a new site, do not call read_page immediately unless you are genuinely stuck. Prefer the site's search box, known navigation patterns, or clicking a visible section first.",
   "For open-web discovery, current facts, prices, flights, news, or search-engine home pages, call web_search(query). Use search(query) only to search within the current site or app.",
+  "For flight price-shopping, include the route, date, and trip type in web_search(query); do not send vague or partial flight queries.",
+  "On flight/travel booking pages with visible route, destination, or date fields, use those visible controls before constructing direct Google Flights or travel-search URLs. Direct travel URLs are a fallback only after the visible controls fail or the page is unusable.",
   "On retail and marketplace sites, prefer the site's visible search box, filters, and result pages over direct product URLs.",
   "For broad discovery tasks, prefer direct sources and site-specific search over generic search engines."
 ];

package/out/preload/content-script.js

@@ -2195,6 +2195,7 @@ let pageDiffActivityThrottleTimer = null;
 let lastPageDiffSignature = "";
 const PAGE_DIFF_ACTIVITY_THROTTLE_MS = 350;
 const PAGE_DIFF_MUTATION_DEBOUNCE_MS = 1200;
+const CUSTOM_TEXT_FIELD_SELECTOR = '[contenteditable="true"], [role="textbox"], [role="searchbox"], [role="combobox"]';
 function normalizeSignatureText(value) {
   return (value || "").replace(/\s+/g, " ").trim();
 }
@@ -2938,6 +2939,37 @@ function getInputLabelWithSource(el) {
   if (placeholder) return { label: placeholder, source: "placeholder" };
   return {};
 }
+function getCustomTextFieldLabelWithSource(el) {
+  const ariaLabel = getTrimmedText(el.getAttribute("aria-label"));
+  if (ariaLabel) return { label: ariaLabel, source: "aria-label" };
+  const labelledBy = getNodeTextByIds(el.getAttribute("aria-labelledby"));
+  if (labelledBy) return { label: labelledBy, source: "label" };
+  const placeholder = getTrimmedText(el.getAttribute("placeholder"));
+  if (placeholder) return { label: placeholder, source: "placeholder" };
+  const text = getTrimmedText(el.textContent);
+  if (text) return { label: text, source: "text" };
+  return {};
+}
+function isNativeFormField(el) {
+  return el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement;
+}
+function shouldExposeCustomTextField(el) {
+  if (!(el instanceof HTMLElement) || isNativeFormField(el)) return false;
+  if (!isElementVisible(el) || isElementDisabled(el)) return false;
+  const role = getElementRole(el);
+  return el.isContentEditable || el.getAttribute("contenteditable") === "true" || role === "textbox" || role === "searchbox" || role === "combobox";
+}
+function getCustomTextFieldInputType(el) {
+  const role = getElementRole(el);
+  if (role === "searchbox") return "search";
+  if (role === "combobox") return "combobox";
+  if (role === "textbox") return "text";
+  return el.getAttribute("contenteditable") === "true" ? "text" : void 0;
+}
+function getCustomTextFieldHasValue(el) {
+  const value = getTrimmedText(el.textContent) || getTrimmedText(el.getAttribute("aria-valuetext")) || getTrimmedText(el.getAttribute("value"));
+  return value ? true : void 0;
+}
 function getButtonTextWithSource(el) {
   const textContent = getTrimmedText(el.textContent);
   if (textContent) return { text: textContent, source: "text" };
@@ -2986,6 +3018,18 @@ function getElementValue(el) {
   }
   return void 0;
 }
+function getElementHasValue(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+    if (el.type === "password" || el.type === "checkbox" || el.type === "radio") {
+      return void 0;
+    }
+    return getTrimmedText(el.value) ? true : void 0;
+  }
+  if (el instanceof HTMLSelectElement) {
+    return getTrimmedText(el.value) ? true : void 0;
+  }
+  return void 0;
+}
 function getSelectOptions(el) {
   const options = Array.from(el.options).map((option) => ({
     label: option.textContent?.trim() || option.value.trim(),
@@ -2999,6 +3043,13 @@ function getAriaBoolean(el, attr) {
   if (val === "false") return false;
   return void 0;
 }
+function getDeepActiveElement() {
+  let active = document.activeElement;
+  while (active instanceof HTMLElement && active.shadowRoot?.activeElement) {
+    active = active.shadowRoot.activeElement;
+  }
+  return active;
+}
 function buildBaseMetadata(el) {
   return {
     context: getElementContext(el),
@@ -3009,6 +3060,7 @@ function buildBaseMetadata(el) {
     description: getElementDescription(el),
     ...getVisibilityState(el),
     disabled: isElementDisabled(el),
+    focused: getDeepActiveElement() === el || void 0,
     ariaExpanded: getAriaBoolean(el, "aria-expanded"),
     ariaPressed: getAriaBoolean(el, "aria-pressed"),
     ariaSelected: getAriaBoolean(el, "aria-selected")
@@ -3120,6 +3172,7 @@ function extractInteractiveElements() {
       placeholder: element.getAttribute("placeholder") || void 0,
       required: element.hasAttribute("required") || void 0,
       value: getElementValue(element),
+      hasValue: getElementHasValue(element),
       options: element instanceof HTMLSelectElement ? getSelectOptions(element) : void 0,
       ...buildBaseMetadata(input),
       role,
@@ -3128,6 +3181,20 @@ function extractInteractiveElements() {
       ...getFieldMetadata(element)
     });
   });
+  deepQuerySelectorAll(CUSTOM_TEXT_FIELD_SELECTOR).forEach((field) => {
+    if (!shouldExposeCustomTextField(field)) return;
+    const label = getCustomTextFieldLabelWithSource(field);
+    const role = getElementRole(field);
+    elements.push({
+      type: "input",
+      label: label.label?.slice(0, MAX_LABEL_LENGTH),
+      labelSource: label.source,
+      inputType: getCustomTextFieldInputType(field),
+      hasValue: getCustomTextFieldHasValue(field),
+      ...buildBaseMetadata(field),
+      role
+    });
+  });
   return elements;
 }
 function extractForms() {
@@ -3143,23 +3210,28 @@ function extractForms() {
     const form = formEl;
     const fields = [];
     form.querySelectorAll(
-      "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='image']), select, textarea"
+      `input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='image']), select, textarea, ${CUSTOM_TEXT_FIELD_SELECTOR}`
     ).forEach((input) => {
+      if (!isNativeFormField(input) && !shouldExposeCustomTextField(input)) {
+        return;
+      }
       const element = input;
       const tag = input.tagName.toLowerCase();
       const label = getInputLabelWithSource(element);
+      const customLabel = isNativeFormField(input) ? {} : getCustomTextFieldLabelWithSource(input);
       const role = getElementRole(input);
       const radioText = role === "radio" || element instanceof HTMLInputElement && element.type === "radio" ? getTrimmedText(
         element.getAttribute("value") || element.getAttribute("aria-label") || label.label
       ) : void 0;
       fields.push({
         type: tag === "select" ? "select" : tag === "textarea" ? "textarea" : "input",
-        label: label.label?.slice(0, MAX_LABEL_LENGTH),
-        labelSource: label.source,
-        inputType: element.getAttribute("type") || void 0,
+        label: (label.label || customLabel.label)?.slice(0, MAX_LABEL_LENGTH),
+        labelSource: label.source || customLabel.source,
+        inputType: element.getAttribute("type") || getCustomTextFieldInputType(input) || void 0,
         placeholder: element.getAttribute("placeholder") || void 0,
         required: element.hasAttribute("required") || void 0,
         value: getElementValue(element),
+        hasValue: isNativeFormField(input) ? getElementHasValue(element) : getCustomTextFieldHasValue(input),
         options: element instanceof HTMLSelectElement ? getSelectOptions(element) : void 0,
         ...buildBaseMetadata(input),
         role,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quanta-intellect/vessel-browser",
   "mcpName": "io.github.unmodeled-tyler/vessel-browser",
-  "version": "0.1.140",
+  "version": "0.1.141",
   "description": "AI-native web browser runtime for autonomous agents with human supervision",
   "main": "./out/main/index.js",
   "bin": {