@quanta-intellect/vessel-browser 0.1.33 → 0.1.44

package/out/main/index.js

@@ -2067,8 +2067,8 @@ class TabManager {
   window;
   onStateChange;
   highlightCaptureCallback = null;
-  constructor(window, onStateChange) {
-    this.window = window;
+  constructor(window2, onStateChange) {
+    this.window = window2;
     this.onStateChange = onStateChange;
   }
   createTab(url = "about:blank", options) {
@@ -5126,214 +5126,6 @@ function makeImageResult(base64, description, mediaType = "image/png") {
   };
   return JSON.stringify(result);
 }
-class AnthropicProvider {
-  client;
-  model;
-  abortController = null;
-  constructor(apiKey, model) {
-    this.client = new Anthropic({ apiKey });
-    this.model = model || "claude-sonnet-4-20250514";
-  }
-  async streamQuery(systemPrompt, userMessage, onChunk, onEnd, history) {
-    this.abortController = new AbortController();
-    const messages = [
-      ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
-      { role: "user", content: userMessage }
-    ];
-    try {
-      const stream = this.client.messages.stream(
-        {
-          model: this.model,
-          max_tokens: 4096,
-          system: systemPrompt,
-          messages
-        },
-        { signal: this.abortController.signal }
-      );
-      for await (const event of stream) {
-        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-          onChunk(event.delta.text);
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error && err.name !== "AbortError") {
-        onChunk(`
-
-[Error: ${err.message}]`);
-      }
-    } finally {
-      this.abortController = null;
-      onEnd();
-    }
-  }
-  async streamAgentQuery(systemPrompt, userMessage, tools, onChunk, onToolCall, onEnd, history) {
-    this.abortController = new AbortController();
-    const messages = [
-      ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
-      { role: "user", content: userMessage }
-    ];
-    try {
-      const maxIterations = getEffectiveMaxIterations();
-      let iterationsUsed = 0;
-      for (let i = 0; i < maxIterations; i++) {
-        iterationsUsed = i + 1;
-        const stream = this.client.messages.stream(
-          {
-            model: this.model,
-            max_tokens: 4096,
-            system: systemPrompt,
-            messages,
-            tools
-          },
-          { signal: this.abortController.signal }
-        );
-        let textContent = "";
-        const toolUseBlocks = [];
-        let currentToolUse = null;
-        const STREAM_IDLE_TIMEOUT_MS = 3e4;
-        let idleTimer = null;
-        const resetIdleTimer = () => {
-          if (idleTimer) clearTimeout(idleTimer);
-          idleTimer = setTimeout(() => {
-            this.abortController?.abort();
-          }, STREAM_IDLE_TIMEOUT_MS);
-        };
-        resetIdleTimer();
-        try {
-          for await (const event of stream) {
-            resetIdleTimer();
-            if (event.type === "content_block_start") {
-              if (event.content_block.type === "tool_use") {
-                currentToolUse = {
-                  id: event.content_block.id,
-                  name: event.content_block.name,
-                  inputJson: ""
-                };
-              }
-            } else if (event.type === "content_block_delta") {
-              if (event.delta.type === "text_delta") {
-                textContent += event.delta.text;
-                onChunk(event.delta.text);
-              } else if (event.delta.type === "input_json_delta" && currentToolUse) {
-                currentToolUse.inputJson += event.delta.partial_json;
-              }
-            } else if (event.type === "content_block_stop" && currentToolUse) {
-              try {
-                toolUseBlocks.push({
-                  id: currentToolUse.id,
-                  name: currentToolUse.name,
-                  input: JSON.parse(currentToolUse.inputJson || "{}")
-                });
-              } catch {
-                toolUseBlocks.push({
-                  id: currentToolUse.id,
-                  name: currentToolUse.name,
-                  input: {},
-                  _malformedArgs: currentToolUse.inputJson
-                });
-              }
-              currentToolUse = null;
-            }
-          }
-        } finally {
-          if (idleTimer) clearTimeout(idleTimer);
-        }
-        const finalMessage = await stream.finalMessage();
-        const assistantContent = [];
-        if (textContent) {
-          assistantContent.push({ type: "text", text: textContent });
-        }
-        for (const tb of toolUseBlocks) {
-          assistantContent.push({
-            type: "tool_use",
-            id: tb.id,
-            name: tb.name,
-            input: tb.input
-          });
-        }
-        messages.push({ role: "assistant", content: assistantContent });
-        if (toolUseBlocks.length === 0) {
-          break;
-        }
-        const toolResults = [];
-        for (const tb of toolUseBlocks) {
-          if (tb._malformedArgs !== void 0) {
-            onChunk(`
-<<tool:${tb.name}:⚠ invalid args>>
-`);
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: tb.id,
-              content: `Error: Invalid JSON in tool arguments — could not parse. Please retry with valid JSON. Raw input: ${tb._malformedArgs.slice(0, 200)}`,
-              is_error: true
-            });
-            continue;
-          }
-          const argSummary = tb.input.url || tb.input.text || tb.input.direction || "";
-          onChunk(`
-<<tool:${tb.name}${argSummary ? ":" + argSummary : ""}>>
-`);
-          let result;
-          try {
-            result = await onToolCall(tb.name, tb.input);
-          } catch (toolErr) {
-            const msg = toolErr instanceof Error ? toolErr.message : String(toolErr);
-            result = `Error: Tool execution failed — ${msg}. Try a different approach or call read_page to refresh context.`;
-          }
-          let parsedRich = null;
-          try {
-            const parsed = JSON.parse(result);
-            if (isRichToolResult(parsed)) parsedRich = parsed;
-          } catch {
-          }
-          if (parsedRich) {
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: tb.id,
-              content: parsedRich.content.map((block) => {
-                if (block.type === "image") {
-                  return {
-                    type: "image",
-                    source: {
-                      type: "base64",
-                      media_type: block.mediaType,
-                      data: block.base64
-                    }
-                  };
-                }
-                return { type: "text", text: block.text };
-              })
-            });
-          } else {
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: tb.id,
-              content: result
-            });
-          }
-        }
-        messages.push({ role: "user", content: toolResults });
-      }
-      if (iterationsUsed >= maxIterations) {
-        onChunk(`
-
-[Reached maximum tool call limit (${maxIterations} steps). You can adjust this in Settings → Max Tool Iterations, or continue by sending another message.]`);
-      }
-    } catch (err) {
-      if (err instanceof Error && err.name !== "AbortError") {
-        onChunk(`
-
-[Error: ${err.message}]`);
-      }
-    } finally {
-      this.abortController = null;
-      onEnd();
-    }
-  }
-  cancel() {
-    this.abortController?.abort();
-  }
-}
 const PROVIDERS = {
   anthropic: {
     id: "anthropic",
@@ -5383,6 +5175,16 @@ const PROVIDERS = {
     apiKeyPlaceholder: "",
     apiKeyHint: "No API key needed — runs locally via Ollama"
   },
+  llama_cpp: {
+    id: "llama_cpp",
+    name: "llama.cpp (Local)",
+    defaultModel: "",
+    models: [],
+    requiresApiKey: false,
+    defaultBaseUrl: "http://localhost:8080/v1",
+    apiKeyPlaceholder: "",
+    apiKeyHint: "No API key needed — scans the active llama-server model on localhost:8080"
+  },
   mistral: {
     id: "mistral",
     name: "Mistral AI",
@@ -5423,20 +5225,609 @@ const PROVIDERS = {
     apiKeyPlaceholder: "Bearer token or API key",
     apiKeyHint: "Optional — only if your endpoint requires authentication"
   }
-};
-function toOpenAITools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.name,
-      description: t.description ?? "",
-      parameters: t.input_schema
+};
+const SAFE_TOOL_ALIASES = {
+  goto_url: "navigate",
+  go_to_url: "navigate",
+  browser_goto: "navigate",
+  browser_navigate: "navigate",
+  open_url: "navigate",
+  visit_url: "navigate",
+  navigate_to: "navigate",
+  open_page: "navigate",
+  google_search: "search",
+  site_search: "search",
+  search_site: "search",
+  page_search: "search",
+  scroll_down: "scroll",
+  scroll_up: "scroll",
+  read: "read_page",
+  read_current_page: "read_page",
+  scan_page: "read_page"
+};
+function normalizeToolAlias(name) {
+  const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+  return SAFE_TOOL_ALIASES[normalized] ?? name;
+}
+function parseModelSizeInBillions(model) {
+  const match = model.toLowerCase().match(/(?:^|[:/_\-\s])(\d+(?:\.\d+)?)b(?:$|[:/_\-\s])/i);
+  if (!match) return null;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isLoopbackBaseUrl(baseUrl) {
+  if (!baseUrl) return false;
+  try {
+    const url = new URL(baseUrl);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+function resolveAgentToolProfile(config) {
+  const providerId = config.id;
+  const isLocalProvider = providerId === "ollama" || providerId === "llama_cpp" || providerId === "custom" && isLoopbackBaseUrl(config.baseUrl);
+  if (!isLocalProvider) return "default";
+  const sizeInBillions = parseModelSizeInBillions(config.model);
+  if (sizeInBillions === null) {
+    return "compact";
+  }
+  return sizeInBillions <= 14 ? "compact" : "default";
+}
+const LLAMA_CPP_MIN_CTX_TOKENS$1 = 16384;
+const LLAMA_CPP_RECOMMENDED_CTX_TOKENS$1 = 32768;
+function shouldDebugAgentLoop() {
+  const value = process.env.VESSEL_DEBUG_AGENT_LOOP;
+  return value === "1" || value === "true";
+}
+function previewDebugValue(value, maxLength = 800) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength)}…`;
+}
+function previewToolDebugContent(content) {
+  return previewDebugValue(content, 500);
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description ?? "",
+      parameters: t.input_schema
+    }
+  }));
+}
+function agentTemperatureForProfile(profile) {
+  return profile === "compact" ? 0.2 : void 0;
+}
+function followUpReminderForProfile(profile, userMessage, assistantText, latestToolResultPreview) {
+  if (profile !== "compact") return null;
+  const phaseReminder = buildPhaseReminder(userMessage, assistantText || "");
+  const stateReminder = buildLatestStateReminder(latestToolResultPreview || "");
+  return {
+    role: "user",
+    content: `[System] Task reminder: Continue working on the user's original request until it is completed: ${userMessage}
+Do not ask the user what they want next unless the request is genuinely ambiguous or blocked. After navigation or page reads, keep executing the same task.` + (stateReminder ? `
+${stateReminder}` : "") + (phaseReminder ? `
+${phaseReminder}` : "")
+  };
+}
+function extractSingleGoalDomain(goal) {
+  const matches = goal.toLowerCase().match(/\b(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+\.(?:com|org|net|io|dev|app|ai|co|edu|gov))\b/g);
+  if (!matches || matches.length !== 1) return null;
+  return matches[0].replace(/^https?:\/\//, "").replace(/^www\./, "").toLowerCase();
+}
+function buildCompactRecoveryPrompt(userMessage, assistantText, latestToolResultPreview) {
+  const phaseReminder = buildPhaseReminder(userMessage, assistantText);
+  const stateReminder = buildLatestStateReminder(latestToolResultPreview || "");
+  const goalDomain = extractSingleGoalDomain(userMessage);
+  const latest = (latestToolResultPreview || "").toLowerCase();
+  const assistant = assistantText.toLowerCase();
+  const alreadyOnGoalSite = !!goalDomain && (latest.includes(goalDomain) || assistant.includes(`https://${goalDomain}`) || assistant.includes(`https://www.${goalDomain}`));
+  const lines = [
+    `The task is still in progress: ${userMessage}`,
+    `Do not ask the user for permission to continue. Choose the next tool now unless the request is fully complete.`
+  ];
+  if (alreadyOnGoalSite) {
+    lines.push(
+      `You are already on the requested site (${goalDomain}). Do not navigate to the homepage again and do not restart discovery from scratch.`
+    );
+  }
+  if (stateReminder) {
+    lines.push(stateReminder);
+  }
+  if (phaseReminder) {
+    lines.push(phaseReminder);
+  }
+  return lines.join("\n");
+}
+function buildPhaseReminder(userMessage, assistantText) {
+  const goal = userMessage.toLowerCase();
+  const text = assistantText.toLowerCase();
+  if (!goal || !text) return "";
+  const wantsCart = /\b(cart|bag|basket|checkout)\b/.test(goal);
+  const wantsExplanation = /\b(explain|reason|why)\b/.test(goal);
+  const wantsBookRecommendations = /\b(book|books|recommend|recommended|interesting|novel|fiction|nonfiction)\b/.test(
+    goal
+  );
+  const hasFiveItemList = /(?:^|\n)\s*1\./.test(assistantText) && /(?:^|\n)\s*2\./.test(assistantText) && /(?:^|\n)\s*3\./.test(assistantText) && /(?:^|\n)\s*4\./.test(assistantText) && /(?:^|\n)\s*5\./.test(assistantText);
+  const selectedItems = hasFiveItemList || /i(?:'| a)?ve chosen/.test(text) || /i have chosen/.test(text) || /i selected/.test(text) || /here are the books/i.test(assistantText) || /here are the items/i.test(assistantText);
+  const intendsCart = /next[, ]+i will add/.test(text) || /i(?:'| a)?ll start with the first/.test(text) || /proceed systematically/.test(text) || /add (these|the chosen|the selected).*(cart|bag|basket)/.test(text);
+  const cartDone = /(added to cart|added them to the cart|cart confirmation|view cart|checkout)/.test(
+    text
+  );
+  const explanationDone = /here is why i chose/.test(text) || /here are my reasons/.test(text) || /reason:/.test(text) || /reasons:/.test(text) || /why i chose/.test(text);
+  const listingLoopSignals = /page contains a list of books|book listings|book cards|visible book|load more results|scroll further|scroll down|inspect the visible|focus on the book listings|targeting the book images|limited to interactive elements|identify the book cards|click one of the visible book/.test(
+    text
+  );
+  const missedResultsSignals = /visible_only mode did not return specific book titles|did not yield a book title link|did not yield specific book titles|navigation links rather than book titles|inspect elements did not yield|inspect the page to find a specific book title|inspect the page to locate a book title|book title link from the search results/.test(
+    text
+  );
+  const falseCartSuccessSignals = /added\s+to\s+the\s+cart\s*:\s*["“”'a-z0-9 ,:&-]+|added\s+to\s+cart\s*:\s*["“”'a-z0-9 ,:&-]+|added\s+["“”'a-z0-9 ,:&-]+\s+to the cart|added\s+["“”'a-z0-9 ,:&-]+\s+to cart|added\s+.*\s+by\s+.*\s+to the cart/.test(
+    text
+  ) && !/(cart confirmation|view cart|shopping cart|checkout|continue shopping)/.test(
+    text
+  );
+  const skippedSingleResultSignals = /did not yield a direct match|no direct match|no matches|unavailable on powell|out of stock or unavailable/.test(
+    text
+  ) && /proceed to (?:add|search for) the next book|move on to the next book|next book from my list/.test(
+    text
+  );
+  const selectedItemsRestartSignals = /navigate back to the search results page|search for ".*" directly in the search box|search for .* directly|page structure has shifted|refresh the page|restart search/.test(
+    text
+  );
+  const multiClickSelectionSignals = /i(?:'| a)?ll start by clicking on the following books|i will start by clicking on the following books|i will click on the following books|clicked on five different book titles|clicked on \d+ different book titles|clicking through the selected titles|click each of the selected titles/.test(
+    text
+  );
+  const staleSelectionSignals = /cannot locate the elements to click|page structure is not being reliably captured|specific titles failed|page may have changed|stale-index/.test(
+    text
+  );
+  const intermediateCartDialogSignals = /(added to cart|has been added to the cart|cart confirmation)/.test(text) && /(continue shopping|search results page|return to the search results page|back button|go back)/.test(
+    text
+  ) && !/(all requested books are now in the cart|all 5 books are now in the cart|5 of 5 requested books are now in the cart)/.test(
+    text
+  );
+  if (wantsCart && wantsBookRecommendations && !selectedItems && !cartDone && listingLoopSignals) {
+    return `Progress reminder: If product results or primary results are already visible, do not keep rereading or rescrolling the same listing page. Open one promising result now. On the detail page, add that item to the cart before returning for the next unseen result.`;
+  }
+  if (wantsCart && wantsBookRecommendations && !selectedItems && !cartDone && missedResultsSignals) {
+    return `Progress reminder: On a results page, do not use visible_only or generic inspect_element to hunt product results. Call read_page(mode="results_only") once. If Primary Results are shown, click a listed result directly.`;
+  }
+  if (wantsCart && falseCartSuccessSignals && !selectedItems && !explanationDone) {
+    return `Progress reminder: Do not assume an item was added just because its product page is open or you inspected it. Only treat the cart step as complete after a successful Add to Cart click followed by cart confirmation, View Cart, Continue Shopping, or the cart page itself.`;
+  }
+  if (wantsCart && skippedSingleResultSignals && !selectedItems) {
+    return `Progress reminder: Do not skip to a new query just because the match is not exact. If the results page shows even one plausible product result, inspect or click that result before concluding there is no match.`;
+  }
+  if (wantsCart && intermediateCartDialogSignals && !explanationDone) {
+    return `Progress reminder: After an Add to Cart success, prefer the cart-confirmation dialog action Continue Shopping while more items remain. Do not click View Cart or Go to Basket yet, and do not use the browser back button while the dialog is still open.`;
+  }
+  if (wantsCart && selectedItems && !cartDone && selectedItemsRestartSignals) {
+    return `Progress reminder: The chosen items are already decided. Do not restart search, refresh the results page, or navigate back to browse again unless a specific saved link fails. Use the current results page or the chosen result links you already have: open one chosen result, add it to the cart, confirm success, then continue to the next chosen result.`;
+  }
+  if (wantsCart && wantsBookRecommendations && !cartDone && (multiClickSelectionSignals || staleSelectionSignals)) {
+    return `Progress reminder: Do not batch-click multiple results from a listing or category page. Open exactly one visible result, finish that item's Add to Cart flow, confirm success, then use Continue Shopping or go back once to choose the next unseen result. If a remembered label or index fails, trust the latest page state and refresh it with one read_page call before continuing.`;
+  }
+  if (wantsCart && selectedItems && (intendsCart || !cartDone)) {
+    return `Progress reminder: You already selected the requested items. Do not restart browsing or searching unless a specific cart step fails. Continue adding the selected items to the cart one by one. Use the chosen result links you already have, add one selected item to the cart, confirm success, then continue to the next one. Do not click multiple chosen results in a row from the same listing page.`;
+  }
+  if (wantsCart && wantsExplanation && cartDone && !explanationDone) {
+    return `Progress reminder: The cart step appears complete. Do not resume browsing. Finish by explaining why the chosen items were recommended.`;
+  }
+  return "";
+}
+function buildLatestStateReminder(toolResultPreview) {
+  const text = toolResultPreview.trim();
+  if (!text) return "";
+  const stateMatch = text.match(
+    /\[state:\s+url=([^,\]\n]+),\s+title=(?:"([^"]*)"|([^,\]\n]+))/i
+  );
+  if (stateMatch) {
+    const url = stateMatch[1]?.trim();
+    const title = (stateMatch[2] ?? stateMatch[3] ?? "").trim();
+    if (url) {
+      return `Latest browser state: URL ${url}${title ? `, title "${title}"` : ""}. Trust the latest tool result over the initial page context.`;
+    }
+  }
+  const structuredUrl = text.match(/\*\*URL:\*\*\s*([^\n]+)/i)?.[1]?.trim();
+  const structuredTitle = text.match(/\*\*Title:\*\*\s*([^\n]+)/i)?.[1]?.trim();
+  if (structuredUrl) {
+    return `Latest browser state: URL ${structuredUrl}${structuredTitle ? `, title "${structuredTitle}"` : ""}. Trust the latest tool result over the initial page context.`;
+  }
+  const navigatedUrl = text.match(/\b(?:navigated to|went back to|went forward to|searched "[^"]+"(?: \(via search button\))? →)\s+([^\s\n]+)/i)?.[1]?.trim();
+  const pageTitle = text.match(/\bPage title:\s*([^\n]+)/i)?.[1]?.trim();
+  if (navigatedUrl) {
+    return `Latest browser state: URL ${navigatedUrl}${pageTitle ? `, title "${pageTitle}"` : ""}. Trust the latest tool result over the initial page context.`;
+  }
+  return "";
+}
+function shouldRecoverCompactStall(text, userMessage) {
+  const trimmed = text.trim().toLowerCase();
+  if (!trimmed) return true;
+  if (trimmed.length <= 160 && trimmed.includes("?")) return true;
+  if (userMessage && buildPhaseReminder(userMessage, text)) {
+    return true;
+  }
+  const repetitivePlanningSignals = [
+    "next step:",
+    "i will now inspect",
+    "i will now read",
+    "i will now click",
+    "i'll use readpage",
+    "i'll use read_page",
+    "i'll start by clicking",
+    "i have clicked on five different book titles",
+    "clicked on five different book titles",
+    "i'll begin with",
+    "if the selection is unclear"
+  ];
+  if (repetitivePlanningSignals.some((pattern) => trimmed.includes(pattern))) {
+    return true;
+  }
+  const falseCartSuccessWithoutConfirmation = /added\s+to\s+the\s+cart\s*:\s*["“”'a-z0-9 ,:&-]+|added\s+to\s+cart\s*:\s*["“”'a-z0-9 ,:&-]+|added\s+["“”'a-z0-9 ,:&-]+\s+to the cart|added\s+["“”'a-z0-9 ,:&-]+\s+to cart|added\s+.*\s+by\s+.*\s+to the cart/.test(
+    trimmed
+  ) && !/(cart confirmation|view cart|continue shopping|shopping cart|checkout|why i chose|here is why i chose|here are my reasons)/.test(
+    trimmed
+  );
+  if (falseCartSuccessWithoutConfirmation) {
+    return true;
+  }
+  const completionSignals = [
+    "i found",
+    "i chose",
+    "i selected",
+    "i added",
+    "here are",
+    "these are",
+    "recommendations",
+    "reasoning",
+    "why i chose",
+    "added them to the cart"
+  ];
+  if (completionSignals.some((pattern) => trimmed.includes(pattern))) {
+    return false;
+  }
+  return [
+    "what are you hoping",
+    "what would you like",
+    "how can i help",
+    "let me know",
+    "are you looking for",
+    "just browsing",
+    "i need to",
+    "i will",
+    "i'll",
+    "since i cannot see",
+    "since i can't see",
+    "cannot see the current page",
+    "scroll down to",
+    "load more results",
+    "as placeholders",
+    "would you like me to proceed",
+    "action:",
+    "one moment",
+    "i will now navigate",
+    "navigating to ",
+    "this will take me",
+    "i will use the browser"
+  ].some((pattern) => trimmed.includes(pattern));
+}
+function shouldRetryCompactToolLoop(profile, text, hasToolHistory, userMessage) {
+  return profile === "compact" && hasToolHistory && shouldRecoverCompactStall(text, userMessage);
+}
+function stableToolSignature(name, args) {
+  const canonicalArgs = canonicalizeArgsForTool(name, args);
+  const sortedEntries = Object.entries(canonicalArgs).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  return JSON.stringify([name, sortedEntries]);
+}
+function hasRecentDuplicateToolCall(recentToolSignatures, signature) {
+  return recentToolSignatures.includes(signature);
+}
+function isClickReadLoop(names) {
+  if (names.length < 6) return false;
+  const tail = names.slice(-6);
+  let clickReadPairs = 0;
+  for (let i = 0; i < tail.length - 1; i++) {
+    if (tail[i] === "click" && tail[i + 1] === "read_page") {
+      clickReadPairs++;
+    }
+  }
+  return clickReadPairs >= 2;
+}
+function normalizeToolToken(value) {
+  return value.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+}
+function canonicalizeUrlLike(value) {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      url.hostname = url.hostname.replace(/^www\./, "");
+      url.hash = "";
+      if (url.pathname.endsWith("/") && url.pathname !== "/") {
+        url.pathname = url.pathname.replace(/\/+$/, "");
+      }
+      return url.toString();
+    }
+  } catch {
+  }
+  return value.trim();
+}
+function toLikelyUrl(value) {
+  const trimmed = value.trim().replace(/^["']|["']$/g, "");
+  if (!trimmed) return null;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (/^[a-z0-9-]+\.(com|org|net|io|dev|app|ai|co|edu|gov)(\/\S*)?$/i.test(trimmed)) {
+    return `https://${trimmed}`;
+  }
+  return null;
+}
+function scalarArgsForTool(name, scalar) {
+  const trimmed = scalar.trim();
+  if (!trimmed) return null;
+  if (name === "navigate") {
+    const url = toLikelyUrl(trimmed);
+    return url ? { url } : null;
+  }
+  if (name === "search") {
+    return { query: trimmed.replace(/^["']|["']$/g, "") };
+  }
+  if (name === "click" || name === "inspect_element" || name === "scroll_to_element") {
+    return { text: trimmed.replace(/^["']|["']$/g, "") };
+  }
+  if (name === "read_page") {
+    const mode = trimmed.replace(/^["']|["']$/g, "").toLowerCase();
+    if (mode) return { mode };
+  }
+  return null;
+}
+function tryParseJsonWithCommonRepairs(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  const candidates = /* @__PURE__ */ new Set([trimmed]);
+  const objectMatch = trimmed.match(/\{[\s\S]*\}/);
+  if (objectMatch?.[0]) candidates.add(objectMatch[0]);
+  if (!trimmed.startsWith("{") && trimmed.includes(":")) {
+    candidates.add(`{${trimmed}}`);
+  }
+  for (const candidate of candidates) {
+    const normalized = candidate.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+    if (!normalized) continue;
+    const repaired = normalized.replace(/([{,]\s*)([A-Za-z_][A-Za-z0-9_-]*)(\s*:)/g, '$1"$2"$3').replace(/([{,]\s*)'([^']+)'(\s*:)/g, '$1"$2"$3').replace(
+      /:\s*'([^'\\]*(?:\\.[^'\\]*)*)'/g,
+      (_match, value) => `: ${JSON.stringify(value)}`
+    ).replace(/,\s*([}\]])/g, "$1");
+    try {
+      return JSON.parse(repaired);
+    } catch {
+    }
+  }
+  throw new Error("invalid-json");
+}
+function parseToolArgsWithRepair(name, argsJson) {
+  const trimmed = (argsJson || "").trim();
+  if (!trimmed) return { args: {}, repaired: false };
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { args: parsed, repaired: false };
+    }
+    if (typeof parsed === "string") {
+      const scalarArgs2 = scalarArgsForTool(name, parsed);
+      return scalarArgs2 ? { args: scalarArgs2, repaired: true } : null;
+    }
+    return null;
+  } catch {
+  }
+  try {
+    const repaired = tryParseJsonWithCommonRepairs(trimmed);
+    if (repaired && typeof repaired === "object" && !Array.isArray(repaired)) {
+      return { args: repaired, repaired: true };
+    }
+    if (typeof repaired === "string") {
+      const scalarArgs2 = scalarArgsForTool(name, repaired);
+      return scalarArgs2 ? { args: scalarArgs2, repaired: true } : null;
+    }
+  } catch {
+  }
+  const scalarArgs = scalarArgsForTool(name, trimmed);
+  return scalarArgs ? { args: scalarArgs, repaired: true } : null;
+}
+function coerceToolArgsForExecution(name, args) {
+  const coerced = { ...args };
+  if (name === "search") {
+    if (typeof coerced.query !== "string" || !coerced.query.trim()) {
+      if (typeof coerced.text === "string" && coerced.text.trim()) {
+        coerced.query = coerced.text.trim();
+      } else if (typeof coerced.term === "string" && coerced.term.trim()) {
+        coerced.query = coerced.term.trim();
+      }
+    }
+  }
+  if (name === "navigate") {
+    if (typeof coerced.url !== "string" || !coerced.url.trim()) {
+      if (typeof coerced.href === "string" && coerced.href.trim()) {
+        coerced.url = coerced.href.trim();
+      } else if (typeof coerced.link === "string" && coerced.link.trim()) {
+        coerced.url = coerced.link.trim();
+      } else if (typeof coerced.text === "string" && /^https?:\/\//i.test(coerced.text.trim())) {
+        coerced.url = coerced.text.trim();
+      }
+    }
+  }
+  return coerced;
+}
+function canonicalizeArgsForTool(name, args) {
+  const canonical = coerceToolArgsForExecution(name, args);
+  if (typeof canonical.url === "string") {
+    canonical.url = canonicalizeUrlLike(canonical.url);
+  }
+  if (typeof canonical.query === "string") {
+    canonical.query = canonical.query.trim().replace(/\s+/g, " ").toLowerCase();
+    delete canonical.text;
+  }
+  if (typeof canonical.text === "string") {
+    canonical.text = canonical.text.trim().replace(/\s+/g, " ");
+  }
+  return canonical;
+}
+function resolveToolCallName(rawName, args, availableToolNames) {
+  const aliased = normalizeToolAlias(rawName);
+  if (availableToolNames.has(aliased)) return aliased;
+  const normalized = normalizeToolToken(rawName);
+  if (availableToolNames.has(normalized)) return normalized;
+  const hasUrl = typeof args.url === "string" && args.url.trim().length > 0;
+  if (availableToolNames.has("navigate") && (hasUrl || /goto|navigate|open|visit|browser|url|link/.test(normalized))) {
+    return "navigate";
+  }
+  if (availableToolNames.has("search") && (/search|find|lookup|query/.test(normalized) || normalized === "google" || normalized.startsWith("google_"))) {
+    return "search";
+  }
+  if (availableToolNames.has("scroll") && /scroll|page_?down|page_?up/.test(normalized)) {
+    return "scroll";
+  }
+  if (availableToolNames.has("read_page") && /read|scan|inspect|analy[sz]e|summari[sz]e/.test(normalized)) {
+    return "read_page";
+  }
+  return aliased;
+}
+function logAgentLoopDebug(payload) {
+  if (!shouldDebugAgentLoop()) return;
+  try {
+    console.log(`[Vessel agent-debug] ${JSON.stringify(payload)}`);
+  } catch (err) {
+    console.warn("[Vessel agent-debug] Failed to serialize debug payload:", err);
+  }
+}
+function recoverTextEncodedToolCalls(text, availableToolNames) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  const candidates = trimmed.match(
+    /([A-Za-z0-9._ -]+)\s*\[ARGS\]\s*(\{[\s\S]*?\})(?=\s*$|\n{2,}|[A-Za-z0-9._ -]+\s*\[ARGS\])/g
+  );
+  if (!candidates || candidates.length === 0) return [];
+  const recovered = [];
+  for (const candidate of candidates) {
+    const match = candidate.match(
+      /^\s*([A-Za-z0-9._ -]+)\s*\[ARGS\]\s*(\{[\s\S]*\})\s*$/
+    );
+    if (!match) continue;
+    const rawName = match[1] ?? "";
+    const argsJson = match[2] ?? "{}";
+    let parsedArgs = {};
+    try {
+      parsedArgs = JSON.parse(argsJson);
+    } catch {
+      continue;
     }
-  }));
+    const resolvedName = resolveToolCallName(
+      rawName,
+      parsedArgs,
+      availableToolNames
+    );
+    recovered.push({
+      id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      name: resolvedName,
+      argsJson
+    });
+  }
+  return recovered;
+}
+function recoverNarratedActionToolCalls(text, availableToolNames) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  const recovered = [];
+  const actionLines = trimmed.match(/^action:\s+.+$/gim) ?? [];
+  for (const rawLine of actionLines) {
+    const line = rawLine.replace(/^action:\s*/i, "").trim();
+    if (!line) continue;
+    const quotedValue = line.match(/"([^"]+)"/)?.[1]?.trim() ?? line.match(/'([^']+)'/)?.[1]?.trim() ?? "";
+    const navigateMatch = line.match(
+      /\b(?:navigate|open|go)\b(?:\s+(?:to|the url))?\s+(https?:\/\/[^\s)]+)\.?/i
+    );
+    if (navigateMatch?.[1]) {
+      const argsJson = JSON.stringify({ url: navigateMatch[1].replace(/\.$/, "") });
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: resolveToolCallName("navigate", { url: navigateMatch[1] }, availableToolNames),
+        argsJson
+      });
+      continue;
+    }
+    const isSearchAction = /\bsearch\b/i.test(line) || /\btype\b/i.test(line) && /\bsearch box\b/i.test(line);
+    if (isSearchAction && quotedValue && availableToolNames.has("search")) {
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: "search",
+        argsJson: JSON.stringify({ query: quotedValue })
+      });
+      continue;
+    }
+    if (/\b(?:read|scan)\b.*\bpage\b/i.test(line) && availableToolNames.has("read_page")) {
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: "read_page",
+        argsJson: JSON.stringify({ mode: "visible_only" })
+      });
+      continue;
+    }
+    const toolRefMatch = line.match(
+      /\b(?:use|call)\s+([a-z_][a-z0-9_]*)(?:\s+tool)?\b/i
+    );
+    if (toolRefMatch?.[1]) {
+      const toolName = resolveToolCallName(toolRefMatch[1], {}, availableToolNames);
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: toolName,
+        argsJson: "{}"
+      });
+    }
+  }
+  const inlineReadMatch = trimmed.match(
+    /\bread_?page\b\s*\(\s*mode\s*=\s*["']?([a-z_]+)["']?\s*\)/i
+  ) ?? trimmed.match(
+    /\breadpage\b\s*\(\s*mode\s*=\s*["']?([a-z_]+)["']?\s*\)/i
+  );
+  if (inlineReadMatch && availableToolNames.has("read_page")) {
+    const rawMode = (inlineReadMatch[1] || "").trim().toLowerCase();
+    const normalizedMode = rawMode === "visibleonly" ? "visible_only" : rawMode === "resultsonly" ? "results_only" : rawMode;
+    if (normalizedMode) {
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: "read_page",
+        argsJson: JSON.stringify({ mode: normalizedMode })
+      });
+      return recovered;
+    }
+  }
+  const inlineInspectMatch = trimmed.match(
+    /\binspect_?element\b(?:\s+tool)?\b/i
+  ) ?? trimmed.match(/\binspectelement\b\b/i);
+  if (inlineInspectMatch && availableToolNames.has("inspect_element")) {
+    recovered.push({
+      id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      name: "inspect_element",
+      argsJson: "{}"
+    });
+    return recovered;
+  }
+  return recovered;
+}
+function formatOpenAICompatErrorMessage(providerId, message) {
+  if (providerId === "llama_cpp" && /(available context size|context size exceeded|exceeds the available context size|try increasing it)/i.test(
+    message
+  )) {
+    return `${message} llama.cpp sets context size at server startup, not per request. Vessel's agent prompt plus tool schema is about 6.5k tokens before browsing history, so run llama-server with --ctx-size ${LLAMA_CPP_MIN_CTX_TOKENS$1} minimum (${LLAMA_CPP_RECOMMENDED_CTX_TOKENS$1} recommended).`;
+  }
+  return message;
 }
 class OpenAICompatProvider {
+  agentToolProfile;
   client;
   model;
+  providerId;
   abortController = null;
   constructor(config) {
     const meta = PROVIDERS[config.id];
@@ -5445,7 +5836,9 @@ class OpenAICompatProvider {
       apiKey: config.apiKey || "ollama",
       baseURL
     });
+    this.providerId = config.id;
     this.model = config.model || meta?.defaultModel || "gpt-4o";
+    this.agentToolProfile = resolveAgentToolProfile(config);
   }
   async streamQuery(systemPrompt, userMessage, onChunk, onEnd, history) {
     this.abortController = new AbortController();
@@ -5458,22 +5851,31 @@ class OpenAICompatProvider {
       const stream = await this.client.chat.completions.create(
         {
           model: this.model,
+          max_tokens: 4096,
           stream: true,
           messages
         },
         { signal: this.abortController.signal }
       );
       for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta?.content;
-        if (delta) {
-          onChunk(delta);
+        const choice = chunk.choices[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        const reasoning = delta?.reasoning_content;
+        if (typeof reasoning === "string" && reasoning.length > 0) {
+          onChunk(reasoning);
+        }
+        if (delta.content) {
+          onChunk(delta.content);
         }
       }
     } catch (err) {
       if (err instanceof Error && err.name !== "AbortError") {
-        onChunk(`
+        onChunk(
+          `
 
-[Error: ${err.message}]`);
+[Error: ${formatOpenAICompatErrorMessage(this.providerId, err.message)}]`
+        );
       }
     } finally {
       this.abortController = null;
@@ -5483,6 +5885,7 @@ class OpenAICompatProvider {
   async streamAgentQuery(systemPrompt, userMessage, tools, onChunk, onToolCall, onEnd, history) {
     this.abortController = new AbortController();
     const openAITools = toOpenAITools(tools);
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
     const messages = [
       { role: "system", content: systemPrompt },
       ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
@@ -5491,18 +5894,31 @@ class OpenAICompatProvider {
     try {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
+      let compactRecoveryCount = 0;
+      let compactCorrectionCount = 0;
+      const recentCompactToolSignatures = [];
+      const recentToolNames = [];
+      let clickReadLoopNudged = false;
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         let textAccum = "";
         const toolCallAccums = {};
         let finishReason = null;
+        const hasToolHistory = messages.some((message) => message.role === "tool");
+        const priorToolMessages = messages.filter(
+          (message) => message.role === "tool"
+        );
+        const latestToolMessage = priorToolMessages.length > 0 ? priorToolMessages[priorToolMessages.length - 1] : null;
+        const debugRoundLabel = hasToolHistory ? "post_tool" : "initial";
         const stream = await this.client.chat.completions.create(
           {
             model: this.model,
+            max_tokens: 4096,
             stream: true,
             messages,
             tools: openAITools,
-            tool_choice: "auto"
+            tool_choice: "auto",
+            temperature: agentTemperatureForProfile(this.agentToolProfile)
           },
           { signal: this.abortController.signal }
         );
@@ -5511,6 +5927,10 @@ class OpenAICompatProvider {
           if (!choice) continue;
           const delta = choice.delta;
           if (choice.finish_reason) finishReason = choice.finish_reason;
+          const reasoning = delta?.reasoning_content;
+          if (typeof reasoning === "string" && reasoning.length > 0) {
+            onChunk(reasoning);
+          }
           if (delta.content) {
             textAccum += delta.content;
             onChunk(delta.content);
@@ -5527,17 +5947,62 @@ class OpenAICompatProvider {
             }
           }
         }
-        const toolCalls = Object.values(toolCallAccums);
+        let toolCalls = Object.values(toolCallAccums);
         for (const tc of Object.values(toolCallAccums)) {
           if (!tc.id) tc.id = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          let parsedArgs = {};
+          const repairedArgs = parseToolArgsWithRepair(tc.name, tc.argsJson || "{}");
+          if (repairedArgs) {
+            parsedArgs = repairedArgs.args;
+            if (repairedArgs.repaired) {
+              tc.argsJson = JSON.stringify(parsedArgs);
+            }
+          }
+          tc.name = resolveToolCallName(tc.name, parsedArgs, availableToolNames);
+        }
+        if (toolCalls.length === 0) {
+          const recoveredToolCalls = recoverTextEncodedToolCalls(
+            textAccum,
+            availableToolNames
+          );
+          if (recoveredToolCalls.length > 0) {
+            toolCalls = recoveredToolCalls;
+          } else {
+            const narratedToolCalls = recoverNarratedActionToolCalls(
+              textAccum,
+              availableToolNames
+            );
+            if (narratedToolCalls.length > 0) {
+              toolCalls = narratedToolCalls;
+            }
+          }
         }
+        logAgentLoopDebug({
+          model: this.model,
+          profile: this.agentToolProfile,
+          iteration: i + 1,
+          round: debugRoundLabel,
+          priorToolCount: priorToolMessages.length,
+          latestToolResultPreview: latestToolMessage ? previewToolDebugContent(String(latestToolMessage.content || "")) : null,
+          finishReason,
+          streamedText: previewDebugValue(textAccum),
+          recoveredFromText: Object.keys(toolCallAccums).length === 0 && toolCalls.length > 0,
+          toolCalls: toolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            argsJson: previewDebugValue(tc.argsJson || "{}", 300)
+          }))
+        });
         const malformedToolCalls = /* @__PURE__ */ new Set();
         for (const tc of toolCalls) {
-          try {
-            JSON.parse(tc.argsJson || "{}");
-          } catch {
+          const repairedArgs = parseToolArgsWithRepair(tc.name, tc.argsJson || "{}");
+          if (!repairedArgs) {
             malformedToolCalls.add(tc.id);
             tc.argsJson = "{}";
+            continue;
+          }
+          if (repairedArgs.repaired) {
+            tc.argsJson = JSON.stringify(repairedArgs.args);
           }
         }
         const assistantMsg = {
@@ -5552,7 +6017,28 @@ class OpenAICompatProvider {
           }
         };
         messages.push(assistantMsg);
-        if (toolCalls.length === 0) break;
+        if (toolCalls.length === 0) {
+          if (compactRecoveryCount < 2 && shouldRetryCompactToolLoop(
+            this.agentToolProfile,
+            textAccum,
+            hasToolHistory,
+            userMessage
+          )) {
+            compactRecoveryCount += 1;
+            messages.push({
+              role: "user",
+              content: `[System] ${buildCompactRecoveryPrompt(
+                userMessage,
+                textAccum,
+                latestToolMessage ? String(latestToolMessage.content || "") : null
+              )}`
+            });
+            continue;
+          }
+          break;
+        }
+        compactRecoveryCount = 0;
+        const iterationToolResultPreviews = [];
         for (const tc of toolCalls) {
           if (malformedToolCalls.has(tc.id)) {
             onChunk(`
@@ -5565,43 +6051,341 @@ class OpenAICompatProvider {
             });
             continue;
           }
-          let args = {};
-          try {
-            args = JSON.parse(tc.argsJson || "{}");
-          } catch {
+          let args = {};
+          const repairedArgs = parseToolArgsWithRepair(tc.name, tc.argsJson || "{}");
+          if (!repairedArgs) {
+            onChunk(`
+<<tool:${tc.name}:⚠ invalid args>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `Error: Invalid JSON in tool arguments. Please retry with valid JSON.`
+            });
+            continue;
+          }
+          args = repairedArgs.args;
+          args = coerceToolArgsForExecution(tc.name, args);
+          if (!availableToolNames.has(tc.name)) {
+            onChunk(`
+<<tool:unsupported_tool:⚠ unsupported>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `Error: ${tc.name} is not a supported tool. Choose one of the available browser tools instead.`
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "user",
+                content: `[System] You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
+              });
+            }
+            continue;
+          }
+          const toolSignature = stableToolSignature(tc.name, args);
+          const neverSuppressDuplicate = [
+            "read_page",
+            "current_tab",
+            "inspect_element",
+            "screenshot",
+            "go_back",
+            "go_forward",
+            "click"
+          ].includes(tc.name);
+          if (this.agentToolProfile === "compact" && !neverSuppressDuplicate && hasRecentDuplicateToolCall(
+            recentCompactToolSignatures,
+            toolSignature
+          )) {
+            onChunk(`
+<<tool:${tc.name}:↻ duplicate suppressed>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `Error: Repeated the same tool call (${tc.name}) with the same arguments twice in a row. Do not repeat it. Continue with the next logical step for the original task.`
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "user",
+                content: `[System] You are stuck repeating the same action. Stop repeating navigate/search. Use a different supported tool that advances the task, such as click, read_page, or scroll.`
+              });
+            }
+            continue;
+          }
+          const argSummary = args.url || args.query || args.text || args.direction || "";
+          onChunk(`
+<<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
+`);
+          let result;
+          try {
+            result = await onToolCall(tc.name, args);
+          } catch (toolErr) {
+            const msg = toolErr instanceof Error ? toolErr.message : String(toolErr);
+            result = `Error: Tool execution failed — ${msg}. Try a different approach or call read_page to refresh context.`;
+          }
+          let toolContent = result;
+          try {
+            const parsed = JSON.parse(result);
+            if (isRichToolResult(parsed)) {
+              toolContent = parsed.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+            }
+          } catch {
+          }
+          if (this.agentToolProfile === "compact") {
+            recentCompactToolSignatures.push(toolSignature);
+            if (recentCompactToolSignatures.length > 4) {
+              recentCompactToolSignatures.shift();
+            }
+          }
+          recentToolNames.push(tc.name);
+          if (recentToolNames.length > 8) recentToolNames.shift();
+          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
+            clickReadLoopNudged = true;
+            messages.push({
+              role: "user",
+              content: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
+            });
+          }
+          compactCorrectionCount = 0;
+          iterationToolResultPreviews.push(toolContent);
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: toolContent
+          });
+        }
+        const followUpReminder = followUpReminderForProfile(
+          this.agentToolProfile,
+          userMessage,
+          textAccum,
+          iterationToolResultPreviews.length > 0 ? iterationToolResultPreviews[iterationToolResultPreviews.length - 1] : null
+        );
+        if (followUpReminder) {
+          messages.push(followUpReminder);
+        }
+      }
+      if (iterationsUsed >= maxIterations) {
+        onChunk(`
+
+[Reached maximum tool call limit (${maxIterations} steps). You can adjust this in Settings → Max Tool Iterations, or continue by sending another message.]`);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name !== "AbortError") {
+        onChunk(
+          `
+
+[Error: ${formatOpenAICompatErrorMessage(this.providerId, err.message)}]`
+        );
+      }
+    } finally {
+      this.abortController = null;
+      onEnd();
+    }
+  }
+  cancel() {
+    this.abortController?.abort();
+  }
+}
+class AnthropicProvider {
+  agentToolProfile = "default";
+  client;
+  model;
+  abortController = null;
+  constructor(apiKey, model) {
+    this.client = new Anthropic({ apiKey });
+    this.model = model || "claude-sonnet-4-20250514";
+  }
+  async streamQuery(systemPrompt, userMessage, onChunk, onEnd, history) {
+    this.abortController = new AbortController();
+    const messages = [
+      ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
+      { role: "user", content: userMessage }
+    ];
+    try {
+      const stream = this.client.messages.stream(
+        {
+          model: this.model,
+          max_tokens: 4096,
+          system: systemPrompt,
+          messages
+        },
+        { signal: this.abortController.signal }
+      );
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          onChunk(event.delta.text);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name !== "AbortError") {
+        onChunk(`
+
+[Error: ${err.message}]`);
+      }
+    } finally {
+      this.abortController = null;
+      onEnd();
+    }
+  }
+  async streamAgentQuery(systemPrompt, userMessage, tools, onChunk, onToolCall, onEnd, history) {
+    this.abortController = new AbortController();
+    const messages = [
+      ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
+      { role: "user", content: userMessage }
+    ];
+    try {
+      const maxIterations = getEffectiveMaxIterations();
+      let iterationsUsed = 0;
+      const recentToolNames = [];
+      let clickReadLoopNudged = false;
+      for (let i = 0; i < maxIterations; i++) {
+        iterationsUsed = i + 1;
+        const stream = this.client.messages.stream(
+          {
+            model: this.model,
+            max_tokens: 4096,
+            system: systemPrompt,
+            messages,
+            tools
+          },
+          { signal: this.abortController.signal }
+        );
+        let textContent = "";
+        const toolUseBlocks = [];
+        let currentToolUse = null;
+        const STREAM_IDLE_TIMEOUT_MS = 3e4;
+        let idleTimer = null;
+        const resetIdleTimer = () => {
+          if (idleTimer) clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => {
+            this.abortController?.abort();
+          }, STREAM_IDLE_TIMEOUT_MS);
+        };
+        resetIdleTimer();
+        try {
+          for await (const event of stream) {
+            resetIdleTimer();
+            if (event.type === "content_block_start") {
+              if (event.content_block.type === "tool_use") {
+                currentToolUse = {
+                  id: event.content_block.id,
+                  name: event.content_block.name,
+                  inputJson: ""
+                };
+              }
+            } else if (event.type === "content_block_delta") {
+              if (event.delta.type === "text_delta") {
+                textContent += event.delta.text;
+                onChunk(event.delta.text);
+              } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+                currentToolUse.inputJson += event.delta.partial_json;
+              }
+            } else if (event.type === "content_block_stop" && currentToolUse) {
+              try {
+                toolUseBlocks.push({
+                  id: currentToolUse.id,
+                  name: currentToolUse.name,
+                  input: JSON.parse(currentToolUse.inputJson || "{}")
+                });
+              } catch {
+                toolUseBlocks.push({
+                  id: currentToolUse.id,
+                  name: currentToolUse.name,
+                  input: {},
+                  _malformedArgs: currentToolUse.inputJson
+                });
+              }
+              currentToolUse = null;
+            }
+          }
+        } finally {
+          if (idleTimer) clearTimeout(idleTimer);
+        }
+        const finalMessage = await stream.finalMessage();
+        const assistantContent = [];
+        if (textContent) {
+          assistantContent.push({ type: "text", text: textContent });
+        }
+        for (const tb of toolUseBlocks) {
+          assistantContent.push({
+            type: "tool_use",
+            id: tb.id,
+            name: tb.name,
+            input: tb.input
+          });
+        }
+        messages.push({ role: "assistant", content: assistantContent });
+        if (toolUseBlocks.length === 0) {
+          break;
+        }
+        const toolResults = [];
+        for (const tb of toolUseBlocks) {
+          if (tb._malformedArgs !== void 0) {
             onChunk(`
-<<tool:${tc.name}:⚠ invalid args>>
+<<tool:${tb.name}:⚠ invalid args>>
 `);
-            messages.push({
-              role: "tool",
-              tool_call_id: tc.id,
-              content: `Error: Invalid JSON in tool arguments. Please retry with valid JSON.`
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: `Error: Invalid JSON in tool arguments — could not parse. Please retry with valid JSON. Raw input: ${tb._malformedArgs.slice(0, 200)}`,
+              is_error: true
             });
             continue;
           }
-          const argSummary = args.url || args.text || args.direction || "";
+          const argSummary = tb.input.url || tb.input.text || tb.input.direction || "";
           onChunk(`
-<<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
+<<tool:${tb.name}${argSummary ? ":" + argSummary : ""}>>
 `);
           let result;
           try {
-            result = await onToolCall(tc.name, args);
+            result = await onToolCall(tb.name, tb.input);
           } catch (toolErr) {
             const msg = toolErr instanceof Error ? toolErr.message : String(toolErr);
             result = `Error: Tool execution failed — ${msg}. Try a different approach or call read_page to refresh context.`;
           }
-          let toolContent = result;
+          let parsedRich = null;
           try {
             const parsed = JSON.parse(result);
-            if (isRichToolResult(parsed)) {
-              toolContent = parsed.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-            }
+            if (isRichToolResult(parsed)) parsedRich = parsed;
           } catch {
           }
+          if (parsedRich) {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: parsedRich.content.map((block) => {
+                if (block.type === "image") {
+                  return {
+                    type: "image",
+                    source: {
+                      type: "base64",
+                      media_type: block.mediaType,
+                      data: block.base64
+                    }
+                  };
+                }
+                return { type: "text", text: block.text };
+              })
+            });
+          } else {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: result
+            });
+          }
+          recentToolNames.push(tb.name);
+          if (recentToolNames.length > 8) recentToolNames.shift();
+        }
+        messages.push({ role: "user", content: toolResults });
+        if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
+          clickReadLoopNudged = true;
           messages.push({
-            role: "tool",
-            tool_call_id: tc.id,
-            content: toolContent
+            role: "user",
+            content: `You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
           });
         }
       }
@@ -5653,6 +6437,55 @@ function validateProviderConnection(config, options = { requireModel: true }) {
   }
   return null;
 }
+const LLAMA_CPP_MIN_CTX_TOKENS = 16384;
+const LLAMA_CPP_RECOMMENDED_CTX_TOKENS = 32768;
+function extractLlamaCppCtxSize(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [payload];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== "object" || visited.has(current)) continue;
+    visited.add(current);
+    for (const [key, value] of Object.entries(current)) {
+      if (typeof value === "number" && Number.isFinite(value) && /^(n_ctx|ctx_size|context_size)$/i.test(key)) {
+        return value;
+      }
+      if (value && typeof value === "object") {
+        queue.push(value);
+      }
+    }
+  }
+  return null;
+}
+function buildLlamaCppCtxWarning(ctxSize) {
+  if (ctxSize == null) {
+    return `Could not detect llama-server context size. Run llama-server with --ctx-size ${LLAMA_CPP_MIN_CTX_TOKENS} minimum (${LLAMA_CPP_RECOMMENDED_CTX_TOKENS} recommended for Vessel agent loops).`;
+  }
+  if (ctxSize < LLAMA_CPP_MIN_CTX_TOKENS) {
+    return `Detected llama-server ctx-size ${ctxSize}, which is too small for reliable Vessel agent loops. Run llama-server with --ctx-size ${LLAMA_CPP_MIN_CTX_TOKENS} minimum (${LLAMA_CPP_RECOMMENDED_CTX_TOKENS} recommended).`;
+  }
+  if (ctxSize < LLAMA_CPP_RECOMMENDED_CTX_TOKENS) {
+    return `Detected llama-server ctx-size ${ctxSize}. This should work, but ${LLAMA_CPP_RECOMMENDED_CTX_TOKENS} is recommended for longer Vessel agent runs.`;
+  }
+  return void 0;
+}
+async function probeLlamaCppCtxWarning(baseURL) {
+  try {
+    const root = new URL(baseURL);
+    root.pathname = "/props";
+    root.search = "";
+    root.hash = "";
+    const response = await fetch(root.toString());
+    if (!response.ok) {
+      return buildLlamaCppCtxWarning(null);
+    }
+    const payload = await response.json();
+    return buildLlamaCppCtxWarning(extractLlamaCppCtxSize(payload));
+  } catch {
+    return buildLlamaCppCtxWarning(null);
+  }
+}
 async function fetchProviderModels(config) {
   const normalized = sanitizeProviderConfig(config);
   const error = validateProviderConnection(normalized, { requireModel: false });
@@ -5662,7 +6495,7 @@ async function fetchProviderModels(config) {
   if (normalized.id === "anthropic") {
     const client2 = new Anthropic({ apiKey: normalized.apiKey });
     const page2 = await client2.models.list();
-    return page2.data.map((model) => model.id);
+    return { ok: true, models: page2.data.map((model) => model.id) };
   }
   const meta = PROVIDERS[normalized.id];
   const baseURL = normalized.baseUrl || meta?.defaultBaseUrl || "https://api.openai.com/v1";
@@ -5671,7 +6504,13 @@ async function fetchProviderModels(config) {
     baseURL
   });
   const page = await client.models.list();
-  return page.data.map((model) => model.id);
+  const models = page.data.map((model) => model.id);
+  const warning = normalized.id === "llama_cpp" ? await probeLlamaCppCtxWarning(baseURL) : void 0;
+  return {
+    ok: true,
+    models,
+    ...warning ? { warning } : {}
+  };
 }
 function createProvider(config) {
   const normalized = sanitizeProviderConfig(config);
@@ -5728,7 +6567,7 @@ function createTraceSession(query, url, title) {
 }
 const CORRECT_HINT_RE = /\b(correct|right choice|this is correct|correct answer|pick this|select this|choose this|right answer)\b/i;
 const WRONG_HINT_RE = /\b(wrong|incorrect|not this|don't pick|do not pick|bad option|decoy)\b/i;
-function elementLabel(el) {
+function elementLabel$1(el) {
   return el.text?.trim() || el.label?.trim() || el.value?.trim() || el.placeholder?.trim() || void 0;
 }
 function isOverlayAction(el) {
@@ -5744,11 +6583,11 @@ function isRadioOption(el) {
 function normalizeAction(el) {
   return {
     index: el.index,
-    label: elementLabel(el),
+    label: elementLabel$1(el),
     selector: el.selector,
     role: el.role,
     labelSource: el.labelSource,
-    looksCorrect: el.looksCorrect !== void 0 ? el.looksCorrect : looksLikeCorrectOption(elementLabel(el))
+    looksCorrect: el.looksCorrect !== void 0 ? el.looksCorrect : looksLikeCorrectOption(elementLabel$1(el))
   };
 }
 function normalizeStoredAction(action) {
@@ -6044,7 +6883,7 @@ function getCartItemLinks(page) {
       return false;
     }
     if (blockedText.test(text) || blockedHref.test(href)) return false;
-    const key = `${normalizeComparable(text)}|${normalizeUrlForMatch(href) || href}`;
+    const key = `${normalizeComparable$1(text)}|${normalizeUrlForMatch$1(href) || href}`;
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -6113,6 +6952,67 @@ function formatCartSnapshot(page) {
 function isVisibleToUser(el) {
   return el.visible === true && el.inViewport === true && el.obscured !== true && el.blockedByOverlay !== true;
 }
+function purchaseActionPriority(el) {
+  const haystack = normalizeComparable$1(
+    [
+      el.text,
+      el.label,
+      el.name,
+      el.placeholder,
+      el.description,
+      el.href
+    ].filter(Boolean).join(" ")
+  );
+  if (!haystack) return Number.POSITIVE_INFINITY;
+  if (/\badd(?: item)? to (?:cart|bag|basket)\b/.test(haystack)) return 0;
+  if (/\b(?:buy now|preorder|pre-order|reserve now|shop now)\b/.test(haystack)) {
+    return 1;
+  }
+  if (/\b(?:checkout|view cart|view basket|go to cart|view bag)\b/.test(haystack)) {
+    return 2;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function isPurchaseActionElement(el) {
+  if (el.type !== "button" && el.type !== "link" && !(el.type === "input" && (el.inputType === "submit" || el.inputType === "button"))) {
+    return false;
+  }
+  return Number.isFinite(purchaseActionPriority(el));
+}
+function getPurchaseActionElements(page, options) {
+  const visibleOnly = options?.visibleOnly !== false;
+  const seen = /* @__PURE__ */ new Set();
+  return page.interactiveElements.filter((el) => {
+    if (!isPurchaseActionElement(el)) return false;
+    if (visibleOnly && !isVisibleToUser(el)) return false;
+    if (el.blockedByOverlay) return false;
+    const key = String(
+      el.index ?? el.selector ?? `${el.type}|${el.text || ""}|${el.label || ""}|${el.href || ""}`
+    );
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).sort((a, b) => {
+    const delta = purchaseActionPriority(a) - purchaseActionPriority(b);
+    if (delta !== 0) return delta;
+    return (a.index ?? Number.MAX_SAFE_INTEGER) - (b.index ?? Number.MAX_SAFE_INTEGER);
+  }).slice(0, 8);
+}
+function getOffscreenPurchaseActionElements(page) {
+  const visibleKeys = new Set(
+    getPurchaseActionElements(page, { visibleOnly: true }).map(
+      (el) => String(
+        el.index ?? el.selector ?? `${el.type}|${el.text || ""}|${el.label || ""}|${el.href || ""}`
+      )
+    )
+  );
+  return getPurchaseActionElements(page, { visibleOnly: false }).filter((el) => {
+    const key = String(
+      el.index ?? el.selector ?? `${el.type}|${el.text || ""}|${el.label || ""}|${el.href || ""}`
+    );
+    return !visibleKeys.has(key) && el.visible !== false;
+  });
+}
 function getDialogFocusedElements(page) {
   return page.interactiveElements.filter(
     (el) => isVisibleToUser(el) && el.context === "dialog"
@@ -6166,6 +7066,10 @@ function formatInteractiveElements(elements) {
     const scoreEl = (el) => {
       let s = 0;
       if (el.context === "dialog") s -= 40;
+      const purchasePriority = purchaseActionPriority(el);
+      if (Number.isFinite(purchasePriority)) {
+        s -= 25 - purchasePriority * 5;
+      }
       if (el.visible === false) s += 100;
       if (el.inViewport === false) s += 50;
       if (el.context === "nav" || el.context === "footer" || el.context === "sidebar")
@@ -6525,10 +7429,10 @@ function chooseAgentReadMode(page) {
       return "visible_only";
   }
 }
-function normalizeComparable(value) {
+function normalizeComparable$1(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
 }
-function normalizeUrlForMatch(value) {
+function normalizeUrlForMatch$1(value) {
   if (!value) return null;
   try {
     const url = new URL(value);
@@ -6538,7 +7442,7 @@ function normalizeUrlForMatch(value) {
     return value.trim().replace(/\/+$/, "").toLowerCase() || null;
   }
 }
-function getUrlPathSegments(value) {
+function getUrlPathSegments$1(value) {
   if (!value) return [];
   try {
     return new URL(value).pathname.split("/").filter(Boolean);
@@ -6547,7 +7451,7 @@ function getUrlPathSegments(value) {
   }
 }
 function isSearchOrListingPage(page) {
-  const haystack = normalizeComparable(
+  const haystack = normalizeComparable$1(
     [
       page.url,
       page.title,
@@ -6587,30 +7491,30 @@ function getResultCandidates(page) {
   const entityItems = collectJsonLdEntityItems(page.jsonLd ?? []);
   const entityNames = new Set(
     entityItems.map(
-      (item) => typeof item.name === "string" ? normalizeComparable(item.name) : ""
+      (item) => typeof item.name === "string" ? normalizeComparable$1(item.name) : ""
     ).filter(Boolean)
   );
   const entityUrls = new Set(
     entityItems.map(
-      (item) => typeof item.url === "string" ? normalizeUrlForMatch(item.url) : null
+      (item) => typeof item.url === "string" ? normalizeUrlForMatch$1(item.url) : null
     ).filter((value) => Boolean(value))
   );
-  const pageHost = normalizeUrlForMatch(page.url);
+  const pageHost = normalizeUrlForMatch$1(page.url);
   const searchOrListingPage = isSearchOrListingPage(page);
   const scored = page.interactiveElements.filter(
     (element) => element.type === "link" && element.text?.trim() && element.href
   ).map((element) => {
     const text = element.text?.trim() || "";
-    const comparableText = normalizeComparable(text);
-    const href = normalizeUrlForMatch(element.href);
-    const haystack = normalizeComparable(
+    const comparableText = normalizeComparable$1(text);
+    const href = normalizeUrlForMatch$1(element.href);
+    const haystack = normalizeComparable$1(
       [element.text, element.description, element.selector, element.href].filter(Boolean).join(" ")
     );
     let score = 0;
     if (entityNames.has(comparableText)) score += 6;
     if (href && entityUrls.has(href)) score += 6;
     if (entityItems.some((item) => {
-      const name = typeof item.name === "string" ? normalizeComparable(item.name) : "";
+      const name = typeof item.name === "string" ? normalizeComparable$1(item.name) : "";
       return Boolean(name) && (name.includes(comparableText) || comparableText.includes(name));
     })) {
       score += 4;
@@ -6624,7 +7528,7 @@ function getResultCandidates(page) {
       } catch {
       }
     }
-    const hrefSegments = getUrlPathSegments(element.href);
+    const hrefSegments = getUrlPathSegments$1(element.href);
     if (hrefSegments.length >= 2) score += 1;
     if (text.includes("/")) score += 1;
     if (searchOrListingPage && (element.context === "article" || element.context === "main" || element.context === "content")) {
@@ -6657,7 +7561,7 @@ function getResultCandidates(page) {
   );
   const seen = /* @__PURE__ */ new Set();
   return scored.map(({ element }) => element).filter((element) => {
-    const key = `${normalizeComparable(element.text || "")}|${normalizeUrlForMatch(element.href) || ""}`;
+    const key = `${normalizeComparable$1(element.text || "")}|${normalizeUrlForMatch$1(element.href) || ""}`;
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -6893,6 +7797,10 @@ function buildScopedContext(page, mode) {
         })).filter((form) => form.fields.length > 0)
       };
       const quantityElements = getQuantityElements(visiblePage);
+      const purchaseActions = getPurchaseActionElements(visiblePage, {
+        visibleOnly: true
+      });
+      const offscreenPurchaseActions = getOffscreenPurchaseActionElements(page);
       const cartSnapshot = formatCartSnapshot(visiblePage);
       const visibleForms = visiblePage.forms;
       const dialogFocus = formatDialogFocus(page);
@@ -6948,6 +7856,19 @@ function buildScopedContext(page, mode) {
         sections.push(formatQuantityElements(quantityElements));
         sections.push("");
       }
+      if (purchaseActions.length > 0) {
+        sections.push("### Primary Purchase Actions");
+        sections.push(formatInteractiveElements(purchaseActions));
+        sections.push("");
+      }
+      if (offscreenPurchaseActions.length > 0) {
+        sections.push("### Offscreen Purchase Actions");
+        sections.push(
+          "These purchase controls are present on the page but currently outside the viewport. You can scroll to reveal them or click them by index."
+        );
+        sections.push(formatInteractiveElements(offscreenPurchaseActions));
+        sections.push("");
+      }
       if (visiblePage.interactiveElements.length > 0) {
         sections.push(
           `### Visible In-Viewport Interactive Elements (${visiblePage.interactiveElements.length})`
@@ -7216,28 +8137,466 @@ ${truncateContent(page.content)}
 **Task:** Summarize this web page based on the structure and content above. Identify the main purpose, key sections, and important interactive elements.`
   };
 }
-function buildQuestionPrompt(page, question) {
-  const structuredContext = buildStructuredContext(page);
-  return {
-    system: "You are Vessel, an AI browsing assistant. Use the provided page structure and content to answer questions accurately. You can reference specific elements by their labels or positions.",
-    user: `${structuredContext}
-
-## PAGE CONTENT
-
-${truncateContent(page.content)}
-
----
-
-**Question:** ${question}
-
-**Instructions:** Answer based on the page structure and content above. If the question asks about interactive elements, forms, or navigation, use the structured context to provide specific details.`
-  };
+function buildQuestionPrompt(page, question) {
+  const structuredContext = buildStructuredContext(page);
+  return {
+    system: "You are Vessel, an AI browsing assistant. Use the provided page structure and content to answer questions accurately. You can reference specific elements by their labels or positions.",
+    user: `${structuredContext}
+
+## PAGE CONTENT
+
+${truncateContent(page.content)}
+
+---
+
+**Question:** ${question}
+
+**Instructions:** Answer based on the page structure and content above. If the question asks about interactive elements, forms, or navigation, use the structured context to provide specific details.`
+  };
+}
+function buildGeneralPrompt(query) {
+  return {
+    system: "You are Vessel, an AI assistant embedded in a web browser. You can normally see the content of the page the user is viewing, but no page is currently active. Help the user with their browsing needs. Be concise and helpful.",
+    user: query
+  };
+}
+const SHARED_CORE_INSTRUCTIONS = [
+  "You can see the page the user is viewing. The content above is from the page.",
+  "The structured page context always refers to the tab currently visible to the human unless a later tool call changes tabs.",
+  "Use tools to interact with the page when asked to do something (navigate, click, type, select options, submit forms, press keys, scroll).",
+  "Only say you completed an action after the corresponding tool succeeds. If no tool supports the request, say so plainly.",
+  "Call one tool at a time unless you are certain your provider supports parallel tool calls. Sequential calls are more reliable.",
+  "ACT, DON'T HEDGE: You have a full browser. If the user asks you to go somewhere and do something, start doing it immediately."
+];
+const SHARED_NAVIGATION_INSTRUCTIONS = [
+  "Use current_tab when you only need to know what the human is currently looking at. Use list_tabs before switching context across multiple tabs.",
+  "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.",
+  "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."
+];
+const SHARED_READ_INSTRUCTIONS = [
+  "The page brief you start with is intentionally sparse. It is optimized for navigation speed, not completeness.",
+  "When you only need detail on one result, card, or form section, use inspect_element instead of reading the whole page.",
+  'Escalate page reads progressively: read_page(mode="glance"), then visible_only/results_only/forms_only/summary/text_only as needed. Use read_page(mode="debug") only as a last resort.',
+  'If read_page returns empty or times out, do not retry with the same mode. Switch to read_page(mode="glance") or use screenshot.',
+  "Use screenshot when you need the exact rendered page or text extraction is failing.",
+  "read_page inspects the page without moving the human-visible viewport. If you say you are going to scroll, call scroll or scroll_to_element so the user sees the page move too.",
+  "After clicking or submitting a form, prefer wait_for on a specific result signal or a narrow read_page mode. When a click navigates to a new page, the click result includes a page snapshot — you only need read_page if you need details beyond what the snapshot shows."
+];
+const DEFAULT_EXTRA_INSTRUCTIONS = [
+  "Create a checkpoint before risky multi-step flows or before leaving an important state.",
+  "Use save_session after completing a login flow you may need again later, and load_session to resume that authenticated state in future runs.",
+  "If the user says they highlighted or selected text, use read_page before falling back to screenshots because it includes active selection and visible unsaved highlights.",
+  "If a page behaves abnormally or key UI fails to load, consider disabling ad blocking for that tab and reloading before retrying.",
+  "If the page context reports a rate limit, human verification, or access warning, stop using that page and switch to a different source.",
+  "Reference interactive elements by their index number (shown as [#N] in the listings above).",
+  "Be concise. Explain what you're doing as you go.",
+  "For simple questions about the page, just answer directly without using tools.",
+  "VISUAL AWARENESS: The human is watching the browser alongside this chat. Use highlights proactively when you reference specific on-page findings or errors.",
+  "After completing a task or answering a question, offer 1-2 brief, natural follow-up suggestions that make sense in context.",
+  'MINIMIZE TOOL CALLS: Every tool call takes time and costs a round trip. Be efficient. The fastest path is usually: navigate -> search -> wait_for or read_page(mode="results_only") -> click.',
+  "USE YOUR KNOWLEDGE: When the user asks for recommendations, make a clear recommendation, explain your reasoning briefly, and then execute.",
+  "NEVER USE EMOJIS unless the user uses them first.",
+  "When adding multiple items to a cart, track which products you've already added. After adding an item, go back and select a DIFFERENT product. The system blocks duplicate cart additions and shows 'Already in cart' warnings."
+];
+const COMPACT_FOCUS_INSTRUCTIONS = [
+  "Trust the latest tool result over the initial page context. If a tool result shows a new URL/title/results page, that is the current truth.",
+  "Do not ask the user for permission to continue a task they already requested.",
+  "Stay on the current task until it is complete. Do not restart completed phases such as re-navigating to the same site or redoing discovery after you already have candidates.",
+  "If you are already on the requested site, do not navigate to its homepage again unless the current page is clearly unusable.",
+  "If search or read_page returns results on the target site, continue from those results. Do not assume the search failed unless the tool result says it failed.",
+  "Use current_tab only if you are genuinely unsure of the current page after reading the latest tool result.",
+  "On retail tasks, prefer this sequence: navigate -> site search or curated section -> inspect/read results -> click a product -> add to cart -> explain.",
+  'On product/detail pages, prefer read_page(mode="visible_only") to find indexed purchase controls like Add to Cart, quantity, and checkout actions.',
+  "When read_page or inspect_element gives you an element index, prefer click(index=N) over selector-based clicks.",
+  'If a product page has no visible purchase control, scroll and call read_page(mode="visible_only") again. Do not loop on generic inspect_element calls against navigation or unrelated regions.',
+  "After adding an item to cart and going back, ALWAYS call read_page to see the current results. The system shows which products are already in your cart — do NOT click those again. Pick a DIFFERENT product from the list. If all visible results are already in cart, scroll down for more.",
+  "Keep your reasoning short. Prefer taking the next tool action over writing a long plan."
+];
+function buildInstructionBlock(instructions) {
+  return instructions.map((line) => `- ${line}`).join("\n");
+}
+function buildContextBlock(input) {
+  return `You are Vessel, an AI agent embedded in a web browser. You can see the current page and interact with it using tools.
+
+THE USER IS CURRENTLY LOOKING AT:
+  Title: ${input.activeTabTitle}
+  URL: ${input.activeTabUrl}${input.tabSummary || ""}
+
+When the user says "this page", "this article", "this site", or asks about what they're viewing, they mean the page above. The context below is from that page.
+
+Current page context:
+This brief is intentionally minimal and filtered for speed. It omits most page text and low-value chrome unless you explicitly ask for more.
+Default brief mode: ${input.defaultReadMode}
+Detected page type: ${input.pageType}
+
+${input.structuredContext}
+
+Supervisor state:
+- paused: ${input.supervisorPaused ? "yes" : "no"}
+- approval mode: ${input.approvalMode}
+- pending approvals: ${input.pendingApprovals}
+
+Recent checkpoints:
+${input.recentCheckpoints || "- none"}
+
+Task tracker:
+${input.taskTrackerContext || "- none"}`;
+}
+function buildAgentSystemPrompt(input) {
+  const instructionBlocks = input.profile === "compact" ? [
+    buildInstructionBlock(SHARED_CORE_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_NAVIGATION_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_READ_INSTRUCTIONS),
+    buildInstructionBlock(COMPACT_FOCUS_INSTRUCTIONS)
+  ] : [
+    buildInstructionBlock(SHARED_CORE_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_NAVIGATION_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_READ_INSTRUCTIONS),
+    buildInstructionBlock(DEFAULT_EXTRA_INSTRUCTIONS)
+  ];
+  return [
+    buildContextBlock(input),
+    "Instructions:",
+    ...instructionBlocks
+  ].join("\n\n");
+}
+function normalizeComparable(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
+}
+function normalizeUrlForMatch(value) {
+  if (!value) return null;
+  try {
+    const url = new URL(value);
+    const pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return `${url.origin}${pathname}`.toLowerCase();
+  } catch {
+    return value.trim().replace(/\/+$/, "").toLowerCase() || null;
+  }
+}
+function getUrlPathSegments(value) {
+  if (!value) return [];
+  try {
+    return new URL(value).pathname.split("/").filter(Boolean);
+  } catch {
+    return value.split("?")[0].split("#")[0].split("/").filter(Boolean);
+  }
+}
+function isVisible(element) {
+  return element.visible !== false && element.obscured !== true && element.blockedByOverlay !== true;
+}
+function isInViewport(element) {
+  return element.inViewport !== false;
+}
+function looksLikeListingPage(page) {
+  const haystack = normalizeComparable(
+    [
+      page.url,
+      page.title,
+      page.excerpt,
+      page.content.slice(0, 2e3),
+      page.headings.map((heading) => heading.text).join(" ")
+    ].filter(Boolean).join(" ")
+  );
+  return /\b(search|results|browse|discover|arrivals|new arrivals|staff picks|picks of the month|monthly picks|featured|bestsellers|best sellers|category|categories|books|book list|fiction|nonfiction|poetry|history|science|children)\b/.test(
+    haystack
+  );
+}
+function isBlockedLabel(label) {
+  return /\b(home|menu|about|contact|privacy|terms|login|sign in|sign up|subscribe|newsletter|facebook|instagram|pinterest|share|print|next|previous|prev|sort|filter|wishlist|account|cart|checkout|view all|see all|refine|narrow|clear all|remove filter)\b/.test(
+    label
+  );
+}
+function resultScore(page, element, listingLike) {
+  if (element.type !== "link" || !element.href || !element.text?.trim()) return -1;
+  const text = element.text.trim();
+  const comparableText = normalizeComparable(text);
+  const href = normalizeUrlForMatch(element.href);
+  const pageUrl = normalizeUrlForMatch(page.url);
+  const hrefSegments = getUrlPathSegments(element.href);
+  const haystack = normalizeComparable(
+    [text, element.description, element.selector, element.href, element.context].filter(Boolean).join(" ")
+  );
+  if (!comparableText || isBlockedLabel(comparableText)) return -1;
+  let score = 0;
+  if (element.context === "article") score += 5;
+  if (element.context === "main" || element.context === "content") score += 4;
+  if (!element.context) score += 1;
+  if (isVisible(element)) score += 2;
+  if (isInViewport(element)) score += 3;
+  if (text.length >= 8 && text.length <= 140) score += 2;
+  if (text.split(/\s+/).length >= 2) score += 2;
+  if (text.split(/\s+/).length >= 4) score += 1;
+  if (hrefSegments.length >= 2) score += 1;
+  if (hrefSegments.some((segment) => /book|books|item|product|title|catalog/.test(segment))) {
+    score += 3;
+  }
+  if (href && pageUrl) {
+    try {
+      if (new URL(href).origin === new URL(pageUrl).origin) score += 2;
+    } catch {
+    }
+  }
+  if (listingLike) score += 2;
+  if (/\b(book|novel|story|poems|poetry|essays|memoir|history|science|fiction)\b/.test(haystack)) {
+    score += 2;
+  }
+  if (/\b(author|hardcover|paperback|preorder|pre-order|signed edition)\b/.test(haystack)) {
+    score += 1;
+  }
+  if (element.context === "nav" || element.context === "header" || element.context === "footer" || element.context === "sidebar" || element.context === "dialog") {
+    score -= 6;
+  }
+  if (/\b(filter|sort|format|price|signed|staff picks|more results|view all)\b/.test(comparableText)) {
+    score -= 3;
+  }
+  try {
+    const linkUrl = new URL(element.href);
+    const filterParams = ["condition", "binding", "format", "availability", "sort", "filter", "price", "category_id", "view"];
+    if (filterParams.some((p) => linkUrl.searchParams.has(p))) {
+      score -= 10;
+    }
+    const filterPathSegments = ["format", "condition", "binding", "availability", "sort"];
+    const hasFilterPath = filterPathSegments.some(
+      (seg) => hrefSegments.some((s) => s.toLowerCase() === seg)
+    );
+    if (hasFilterPath) {
+      score -= 10;
+    }
+  } catch {
+  }
+  return score;
+}
+function getCompactPrimaryResultLinks(page, options) {
+  const listingLike = looksLikeListingPage(page);
+  const max = options?.max ?? 8;
+  const visibleOnly = options?.visibleOnly === true;
+  const seen = /* @__PURE__ */ new Set();
+  return page.interactiveElements.filter((element) => !visibleOnly || isVisible(element)).map((element) => ({
+    element,
+    score: resultScore(page, element, listingLike)
+  })).filter(({ score }) => score >= (listingLike ? 5 : 7)).sort(
+    (a, b) => b.score - a.score || (a.element.index ?? Number.MAX_SAFE_INTEGER) - (b.element.index ?? Number.MAX_SAFE_INTEGER)
+  ).map(({ element }) => element).filter((element) => {
+    const key = `${normalizeComparable(element.text)}|${normalizeUrlForMatch(element.href) || ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, max);
+}
+function looksLikeProductPage(page) {
+  const url = (page.url || "").toLowerCase();
+  return /\/(book|product|item|detail|dp|gp\/product)\//i.test(url) || /\b(add to cart|add to bag|add to basket|buy now)\b/i.test(
+    page.content.slice(0, 3e3)
+  );
+}
+function chooseCompactReadMode(page, fallbackMode) {
+  if (fallbackMode === "results_only") return fallbackMode;
+  if (looksLikeProductPage(page)) return fallbackMode;
+  const candidates = getCompactPrimaryResultLinks(page, { max: 6 });
+  if (candidates.length >= 4) return "results_only";
+  if (candidates.length >= 2 && looksLikeListingPage(page)) return "results_only";
+  return fallbackMode;
+}
+const MAX_RESULTS = 6;
+const MAX_CONTROLS = 8;
+const MAX_FIELDS = 8;
+const MAX_HEADINGS = 5;
+const MAX_TEXT_CHARS = 420;
+function compactText(value, max = MAX_TEXT_CHARS) {
+  const text = (value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+function isVisibleElement(element) {
+  return element.visible !== false && element.inViewport !== false && element.blockedByOverlay !== true && element.obscured !== true;
+}
+function elementLabel(element) {
+  return compactText(
+    element.text || element.label || element.placeholder || element.name || element.href || element.description,
+    96
+  ) || "Element";
+}
+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}`;
+}
+function uniqueElements(elements) {
+  const seen = /* @__PURE__ */ new Set();
+  return elements.filter((element) => {
+    const key = `${element.index ?? ""}|${element.type}|${elementLabel(element)}|${element.href ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function isPaginationLike(element) {
+  const text = `${element.text || ""} ${element.label || ""}`.toLowerCase();
+  return /\b(next|prev|previous|load more|more results)\b/.test(text);
+}
+function getPrimaryResultLinks(page) {
+  return uniqueElements(
+    getCompactPrimaryResultLinks(page, {
+      visibleOnly: true,
+      max: MAX_RESULTS
+    }).filter((element) => !isPaginationLike(element))
+  );
+}
+function isPurchaseControl(element) {
+  const text = `${element.text || ""} ${element.label || ""}`.toLowerCase();
+  return /\b(add to cart|add to bag|add to basket|buy now|checkout|view cart)\b/.test(
+    text
+  );
+}
+function isAddToCartControl(element) {
+  const text = `${element.text || ""} ${element.label || ""}`.toLowerCase();
+  return /\badd to cart|add to bag|add to basket\b/.test(text);
+}
+function looksLikeProductDetailPage(page) {
+  return /\/book\//i.test(page.url) || /\bbook\b/i.test(page.title);
+}
+function hasCartConfirmationState(page) {
+  const haystack = compactText(
+    [
+      page.url,
+      page.title,
+      page.excerpt,
+      page.content.slice(0, 1200),
+      page.overlays.map((overlay) => overlay.label || overlay.message || overlay.text || overlay.kind || "").join(" ")
+    ].filter(Boolean).join(" "),
+    1600
+  ).toLowerCase();
+  return /\/cart\b/.test(page.url.toLowerCase()) || /\b(cart confirmation|added to cart|added to bag|added to basket|continue shopping|shopping cart|view cart|checkout)\b/.test(
+    haystack
+  );
+}
+function getVisibleControls(page) {
+  return uniqueElements(page.interactiveElements.filter(isVisibleElement)).slice(
+    0,
+    MAX_CONTROLS
+  );
 }
-function buildGeneralPrompt(query) {
-  return {
-    system: "You are Vessel, an AI assistant embedded in a web browser. You can normally see the content of the page the user is viewing, but no page is currently active. Help the user with their browsing needs. Be concise and helpful.",
-    user: query
-  };
+function getVisiblePurchaseControls(page) {
+  return uniqueElements(
+    page.interactiveElements.filter(isVisibleElement).filter(isPurchaseControl).sort((a, b) => (a.index ?? Number.MAX_SAFE_INTEGER) - (b.index ?? Number.MAX_SAFE_INTEGER))
+  ).slice(0, 6);
+}
+function getOffscreenPurchaseControls(page) {
+  const visibleKeys = new Set(getVisiblePurchaseControls(page).map(controlKey));
+  return uniqueElements(
+    page.interactiveElements.filter((element) => isPurchaseControl(element)).filter((element) => element.blockedByOverlay !== true).filter((element) => element.visible !== false).filter((element) => !visibleKeys.has(controlKey(element))).sort((a, b) => (a.index ?? Number.MAX_SAFE_INTEGER) - (b.index ?? Number.MAX_SAFE_INTEGER))
+  ).slice(0, 4);
+}
+function controlKey(element) {
+  return `${element.index ?? ""}|${element.type}|${elementLabel(element)}|${element.href ?? ""}`;
+}
+function isLowValueListingControl(element) {
+  const label = elementLabel(element).toLowerCase();
+  return /\b(filter|sort|format|price|availability|signed edition|binding|language|refine|clear all|remove filter)\b/.test(
+    label
+  );
+}
+function getVisibleFormFields(page) {
+  return uniqueElements(
+    page.forms.flatMap((form) => form.fields).filter(isVisibleElement)
+  ).slice(0, MAX_FIELDS);
+}
+function pushSection(lines, title, items) {
+  if (items.length === 0) return;
+  lines.push("");
+  lines.push(title);
+  lines.push(...items.map((item) => `- ${item}`));
+}
+function buildTextSnapshot(page) {
+  const excerpt = compactText(page.excerpt);
+  if (excerpt) return [excerpt];
+  const content = compactText(page.content);
+  return content ? [content] : [];
+}
+function buildCompactScopedContext(page, mode, pageType = detectPageType(page)) {
+  const lines = [
+    `**URL:** ${page.url}`,
+    `**Title:** ${page.title}`,
+    `**Page Type:** ${pageType}`,
+    `**Mode:** ${mode}`
+  ];
+  if (page.byline) {
+    lines.push(`**Author:** ${compactText(page.byline, 120)}`);
+  }
+  const warnings = (page.pageIssues || []).slice(0, 3).map((issue) => compactText(issue.summary, 140));
+  pushSection(lines, "### Access Warnings", warnings);
+  const blockingOverlays = page.overlays.filter((overlay) => overlay.blocksInteraction).slice(0, 3).map(
+    (overlay) => compactText(
+      overlay.label || overlay.message || overlay.text || overlay.kind || overlay.type,
+      140
+    )
+  );
+  pushSection(lines, "### Immediate Blockers", blockingOverlays);
+  const visiblePurchaseControls = getVisiblePurchaseControls(page);
+  const offscreenPurchaseControls = getOffscreenPurchaseControls(page);
+  const purchaseControls = visiblePurchaseControls.map(formatElement);
+  const addToCartVisible = visiblePurchaseControls.some(isAddToCartControl);
+  const addToCartOffscreen = offscreenPurchaseControls.some(isAddToCartControl);
+  if (looksLikeProductDetailPage(page) && !hasCartConfirmationState(page)) {
+    if (addToCartVisible) {
+      pushSection(lines, "### Action Status", [
+        "Product detail page open. This item is not in the cart yet.",
+        "Click Add to Cart and wait for cart confirmation before moving on."
+      ]);
+    } else if (addToCartOffscreen) {
+      pushSection(lines, "### Action Status", [
+        "Product detail page open. This item is not in the cart yet.",
+        "Add to Cart is present but outside the current viewport.",
+        "Scroll once or use the offscreen purchase control below, then wait for cart confirmation."
+      ]);
+    }
+  }
+  pushSection(lines, "### Visible Purchase Controls", purchaseControls);
+  pushSection(
+    lines,
+    "### Offscreen Purchase Actions",
+    offscreenPurchaseControls.map(formatElement)
+  );
+  const primaryResultElements = getPrimaryResultLinks(page);
+  const primaryResults = primaryResultElements.map(formatElement);
+  if (primaryResults.length > 0) {
+    pushSection(
+      lines,
+      "### Primary Results",
+      primaryResults
+    );
+  }
+  if (pageType === "FORM" || pageType === "LOGIN" || mode === "forms_only") {
+    pushSection(
+      lines,
+      "### Form Fields",
+      getVisibleFormFields(page).map(formatElement)
+    );
+  }
+  if (mode === "visible_only" || mode === "interactives_only" || pageType === "SEARCH_READY" || pageType === "GENERAL") {
+    const primaryResultKeys = new Set(primaryResultElements.map(controlKey));
+    const visibleControls = getVisibleControls(page).filter((element) => !primaryResultKeys.has(controlKey(element))).filter(
+      (element) => primaryResultElements.length > 0 ? !isLowValueListingControl(element) : true
+    ).map(formatElement);
+    pushSection(
+      lines,
+      "### Visible Controls",
+      visibleControls
+    );
+  }
+  const headingItems = page.headings.slice(0, MAX_HEADINGS).map((heading) => `H${heading.level}: ${compactText(heading.text, 100)}`);
+  pushSection(lines, "### Top Headings", headingItems);
+  if (mode === "summary" || mode === "text_only" || lines.length <= 6) {
+    pushSection(lines, "### Text Snapshot", buildTextSnapshot(page));
+  }
+  lines.push("");
+  lines.push(
+    `Stats: ${page.interactiveElements.length} interactives, ${page.forms.length} forms, ${page.navigation.length} nav links, ${page.headings.length} headings`
+  );
+  return lines.join("\n");
 }
 const WRAPPING_QUOTES = /* @__PURE__ */ new Set(['"', "'", "`"]);
 function stripWrappingQuotes(value) {
@@ -7384,10 +8743,11 @@ const TOOL_DEFINITIONS = [
   {
     name: "click",
     title: "Click Element",
-    description: "Click an element on the page by its index number or CSS selector. Use this to check or uncheck checkboxes and to select radio buttons — do NOT use select_option for those.",
+    description: "Click an element on the page by its index number, CSS selector, or visible text/section name. If you know the label on the page but not the index yet, pass text instead of guessing a selector.",
     inputSchema: {
       index: zod.z.number().optional().describe("Element index from the page content listing"),
-      selector: zod.z.string().optional().describe("CSS selector as fallback")
+      selector: zod.z.string().optional().describe("CSS selector as fallback"),
+      text: zod.z.string().optional().describe("Visible label, link text, button text, or section name to match")
     },
     tier: 0
   },
@@ -7508,10 +8868,11 @@ const TOOL_DEFINITIONS = [
   {
     name: "inspect_element",
     title: "Inspect Element",
-    description: "Inspect one element and its nearest local UI region such as a product card, result row, form section, or modal. Use this instead of reading the whole page when you only need local context.",
+    description: "Inspect one element and its nearest local UI region such as a product card, result row, form section, or modal. You can target it by index, selector, or visible text/section name when you know what it says but not where it is.",
     inputSchema: {
       index: zod.z.number().optional().describe("Element index to inspect"),
       selector: zod.z.string().optional().describe("CSS selector to inspect"),
+      text: zod.z.string().optional().describe("Visible label or section text to locate before inspecting"),
       limit: zod.z.number().optional().describe("Maximum nearby controls to include (default 8)")
     },
     tier: 1,
@@ -7863,10 +9224,11 @@ const TOOL_DEFINITIONS = [
   {
     name: "scroll_to_element",
     title: "Scroll To Element",
-    description: "Scroll a specific element into view by index or selector. Useful for navigating to off-screen content.",
+    description: "Scroll a specific element into view by index, selector, or visible text/section name. Useful for navigating to off-screen content when you know the heading or label you want.",
     inputSchema: {
       index: zod.z.number().optional().describe("Element index to scroll to"),
       selector: zod.z.string().optional().describe("CSS selector to scroll to"),
+      text: zod.z.string().optional().describe("Visible label or section text to scroll into view"),
       position: zod.z.enum(["center", "top", "bottom"]).optional().describe(
         "Where to position the element in the viewport (default center)"
       )
@@ -7956,10 +9318,16 @@ const CONTEXT_HINTS = {
     scroll: "💡 Long content — scroll to continue — "
   }
 };
-function scoreForContext(toolName, pageType) {
+function scoreForContext(toolName, pageType, intents) {
   const def = defByName[toolName];
   if (!def) return 500;
   if (pageType === "SEARCH_READY") {
+    if (intents.has("navigate")) {
+      if (toolName === "navigate") return -30;
+      if (toolName === "search") return 2;
+      if (toolName === "type_text") return 5;
+      if (toolName === "press_key") return 6;
+    }
     if (toolName === "search") return -20;
     if (toolName === "type_text") return 5;
     if (toolName === "press_key") return 6;
@@ -7993,10 +9361,53 @@ const ALWAYS_FAST_TOOL_NAMES = /* @__PURE__ */ new Set([
   "screenshot",
   "inspect_element"
 ]);
+const COMPACT_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "navigate",
+  "go_back",
+  "click",
+  "type_text",
+  "press_key",
+  "scroll",
+  "dismiss_popup",
+  "clear_overlays",
+  "accept_cookies",
+  "read_page",
+  "wait_for",
+  "inspect_element",
+  "search"
+]);
+const COMPACT_CONTEXTUAL_TOOL_NAMES = {
+  LOGIN: ["fill_form", "submit_form", "login"],
+  FORM: ["fill_form", "select_option", "submit_form"],
+  SHOPPING: ["select_option", "fill_form", "submit_form"],
+  SEARCH_RESULTS: ["paginate", "scroll_to_element"],
+  PAGINATED_LIST: ["paginate", "scroll_to_element"]
+};
+const COMPACT_INTENT_TOOL_NAMES = {
+  tabs: ["current_tab", "list_tabs", "switch_tab", "create_tab"],
+  bookmarks: [
+    "list_bookmarks",
+    "search_bookmarks",
+    "create_bookmark_folder",
+    "save_bookmark",
+    "organize_bookmark",
+    "archive_bookmark",
+    "open_bookmark"
+  ],
+  sessions: ["login", "save_session", "load_session", "list_sessions", "delete_session"],
+  workflow: ["create_checkpoint", "restore_checkpoint", "flow_start", "flow_advance", "flow_status", "flow_end"],
+  metrics: ["metrics"],
+  highlight: ["highlight", "clear_highlights"],
+  table: ["extract_table"],
+  debug: ["current_tab", "reload", "set_ad_blocking", "suggest", "screenshot"]
+};
 function inferIntent(query) {
   const lowered = query.toLowerCase();
   const intents = /* @__PURE__ */ new Set();
   if (/\b(tab|tabs|window|windows)\b/.test(lowered)) intents.add("tabs");
+  if (/\b(go to|goto|open|visit|navigate to)\b/.test(lowered) || /\b[a-z0-9-]+\.(com|org|net|io|dev|app|ai|co|edu|gov)\b/.test(lowered) || /\bhttps?:\/\//.test(lowered)) {
+    intents.add("navigate");
+  }
   if (/\b(bookmark|bookmarks|save this|folder)\b/.test(lowered)) {
     intents.add("bookmarks");
   }
@@ -8019,7 +9430,18 @@ function inferIntent(query) {
   }
   return intents;
 }
-function shouldIncludeTool(toolName, pageType, intents) {
+function shouldIncludeTool(toolName, pageType, intents, profile) {
+  if (profile === "compact") {
+    if (COMPACT_CORE_TOOL_NAMES.has(toolName)) return true;
+    const contextualTools = COMPACT_CONTEXTUAL_TOOL_NAMES[pageType] ?? [];
+    if (contextualTools.includes(toolName)) return true;
+    for (const intent of intents) {
+      if ((COMPACT_INTENT_TOOL_NAMES[intent] ?? []).includes(toolName)) {
+        return true;
+      }
+    }
+    return false;
+  }
   if (ALWAYS_FAST_TOOL_NAMES.has(toolName)) return true;
   switch (toolName) {
     case "select_option":
@@ -8076,13 +9498,14 @@ function shouldIncludeTool(toolName, pageType, intents) {
       return !defByName[toolName]?.hiddenByDefault;
   }
 }
-function pruneToolsForContext(tools, pageType, query = "") {
+function pruneToolsForContext(tools, pageType, query = "", options = {}) {
   const ctx = pageType ?? "GENERAL";
   const hints = CONTEXT_HINTS[ctx] ?? {};
   const intents = inferIntent(query);
-  const scored = tools.filter((tool) => shouldIncludeTool(tool.name, ctx, intents)).map((tool) => ({
+  const profile = options.profile ?? "default";
+  const scored = tools.filter((tool) => shouldIncludeTool(tool.name, ctx, intents, profile)).map((tool) => ({
     tool,
-    score: scoreForContext(tool.name, ctx)
+    score: scoreForContext(tool.name, ctx, intents)
   }));
   scored.sort((a, b) => a.score - b.score);
   return scored.map(({ tool, score }) => {
@@ -8746,6 +10169,87 @@ async function captureScreenshot(wc) {
   }
   return { ok: false, error: "Page image was empty after 3 attempts" };
 }
+function normalizeForComparison(value) {
+  return value.toLowerCase().replace(/https?:\/\//g, "").replace(/www\./g, "").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function canonicalizeUrlForComparison(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.hostname = url.hostname.replace(/^www\./, "");
+    url.hash = "";
+    if (url.pathname.endsWith("/") && url.pathname !== "/") {
+      url.pathname = url.pathname.replace(/\/+$/, "");
+    }
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function isRedundantNavigateTarget(currentUrl, targetUrl) {
+  const current = canonicalizeUrlForComparison(currentUrl);
+  const target = canonicalizeUrlForComparison(targetUrl);
+  return current !== null && target !== null && current === target;
+}
+function looksLikeCurrentSiteNameQuery(query, currentUrl, currentTitle) {
+  const normalizedQuery = normalizeForComparison(query);
+  if (!normalizedQuery) return false;
+  let hostnameLabel = "";
+  try {
+    const url = new URL(currentUrl);
+    hostnameLabel = url.hostname.replace(/^www\./, "").split(".")[0] || "";
+  } catch {
+  }
+  const normalizedTitle = normalizeForComparison(currentTitle);
+  const normalizedHost = normalizeForComparison(hostnameLabel);
+  const normalizedTitlePrefix = normalizeForComparison(
+    currentTitle.split("|")[0]?.split("—")[0]?.split("-")[0] || currentTitle
+  );
+  if (normalizedTitle && normalizedQuery === normalizedTitle) return true;
+  if (normalizedTitlePrefix && normalizedQuery === normalizedTitlePrefix) {
+    return true;
+  }
+  if (normalizedHost && normalizedQuery === normalizedHost) return true;
+  const titleTokens = new Set(normalizedTitle.split(/\s+/).filter(Boolean));
+  const queryTokens = normalizedQuery.split(/\s+/).filter(Boolean);
+  if (normalizedHost && queryTokens.includes(normalizedHost) && queryTokens.every((token) => titleTokens.has(token) || token === normalizedHost)) {
+    return true;
+  }
+  return false;
+}
+function extractExplicitDomains(goal) {
+  const matches = goal.toLowerCase().match(/\b(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+\.(?:com|org|net|io|dev|app|ai|co|edu|gov))\b/g);
+  if (!matches) return [];
+  const normalized = matches.map(
+    (match) => match.replace(/^https?:\/\//, "").replace(/^www\./, "").toLowerCase()
+  );
+  return [...new Set(normalized)];
+}
+function apexDomain(hostname) {
+  const parts = hostname.replace(/^www\./, "").split(".").filter(Boolean);
+  if (parts.length <= 2) return parts.join(".");
+  return parts.slice(-2).join(".");
+}
+function shouldBlockOffGoalDomainNavigation(goal, targetUrl) {
+  const explicitDomains = extractExplicitDomains(goal);
+  if (explicitDomains.length !== 1) return null;
+  let targetHost = "";
+  try {
+    const url = new URL(targetUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    targetHost = url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return null;
+  }
+  const requestedDomain = explicitDomains[0];
+  if (targetHost === requestedDomain || targetHost.endsWith(`.${requestedDomain}`) || apexDomain(targetHost) === apexDomain(requestedDomain)) {
+    return null;
+  }
+  return {
+    requestedDomain,
+    targetDomain: targetHost
+  };
+}
 const SESSION_VERSION = 1;
 function getSessionsDir() {
   return path$1.join(electron.app.getPath("userData"), "named-sessions");
@@ -9024,6 +10528,340 @@ function deleteNamedSession(name) {
   fs$1.unlinkSync(filePath);
   return true;
 }
+function isInvalidTextTargetQuery(rawQuery) {
+  const trimmed = String(rawQuery || "").trim();
+  if (!trimmed) return true;
+  if (/<\/?[a-z][^>]*>/i.test(trimmed)) return true;
+  if (/^&lt;\/?[a-z][^&]*&gt;$/i.test(trimmed)) return true;
+  if (/^<\/?[a-z][a-z0-9:-]*>$/i.test(trimmed)) return true;
+  return false;
+}
+function resolveTextTargetInDocument(doc, rawQuery, mode) {
+  function normalize(value) {
+    return String(value || "").toLowerCase().replace(/\s+/g, " ").trim();
+  }
+  function text(value) {
+    return String(value || "").replace(/\s+/g, " ").trim();
+  }
+  function escapeSelectorValue(value) {
+    const cssObject = typeof CSS !== "undefined" ? CSS : void 0;
+    if (cssObject && typeof cssObject.escape === "function") {
+      return cssObject.escape(value);
+    }
+    return String(value).replace(/["\\]/g, "\\$&");
+  }
+  function uniqueSelector(candidate) {
+    if (!candidate) return null;
+    try {
+      return doc.querySelectorAll(candidate).length === 1 ? candidate : null;
+    } catch {
+      return null;
+    }
+  }
+  function uniqueAttributeSelector(el, attribute) {
+    const value = text(el.getAttribute(attribute));
+    if (!value) return null;
+    const candidate = `${el.tagName.toLowerCase()}[${attribute}="${escapeSelectorValue(value)}"]`;
+    return uniqueSelector(candidate);
+  }
+  function selectorFor(el) {
+    if (!el) return null;
+    const htmlEl = el;
+    if (htmlEl.id) return `#${escapeSelectorValue(htmlEl.id)}`;
+    for (const attribute of [
+      "data-testid",
+      "name",
+      "aria-label",
+      "title",
+      "href"
+    ]) {
+      const candidate2 = uniqueAttributeSelector(el, attribute);
+      if (candidate2) return candidate2;
+    }
+    const parts = [];
+    let current = el;
+    while (current) {
+      const currentEl = current;
+      if (currentEl.id) {
+        parts.unshift(`#${escapeSelectorValue(currentEl.id)}`);
+        break;
+      }
+      const parent = current.parentElement;
+      const tag = current.tagName.toLowerCase();
+      if (!parent) {
+        parts.unshift(tag);
+        break;
+      }
+      const siblings = Array.from(parent.children).filter(
+        (child) => child.tagName === current.tagName
+      );
+      const index = siblings.indexOf(current) + 1;
+      parts.unshift(
+        siblings.length > 1 ? `${tag}:nth-of-type(${index})` : tag
+      );
+      current = parent;
+    }
+    const candidate = parts.join(" > ");
+    return uniqueSelector(candidate) || candidate;
+  }
+  function isVisible2(el) {
+    if (!(el instanceof HTMLElement)) return false;
+    if (el.hidden || el.getAttribute("aria-hidden") === "true") return false;
+    const style = typeof getComputedStyle === "function" ? getComputedStyle(el) : null;
+    if (style && (style.display === "none" || style.visibility === "hidden" || style.opacity === "0")) {
+      return false;
+    }
+    return true;
+  }
+  function inViewport(el) {
+    if (!(el instanceof HTMLElement)) return false;
+    if (typeof el.getBoundingClientRect !== "function") return true;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) return true;
+    const vw = window.innerWidth || doc.documentElement?.clientWidth || 0;
+    const vh = window.innerHeight || doc.documentElement?.clientHeight || 0;
+    return rect.bottom > 0 && rect.right > 0 && rect.top < vh && rect.left < vw;
+  }
+  function labelFor(el) {
+    const htmlEl = el;
+    return text(
+      htmlEl.getAttribute("aria-label") || htmlEl.getAttribute("title") || htmlEl.getAttribute("name") || htmlEl.getAttribute("placeholder") || ("value" in htmlEl ? String(htmlEl.value || "") : "") || htmlEl.textContent
+    ) || el.tagName.toLowerCase();
+  }
+  function contentFor(el) {
+    const ariaLabel = text(el.getAttribute?.("aria-label"));
+    const title = text(el.getAttribute?.("title"));
+    const ownText = text(el.textContent).slice(0, 300);
+    return [ariaLabel, title, ownText].filter(Boolean).join(" ");
+  }
+  function scoreText(query2, candidate) {
+    const normalizedCandidate = normalize(candidate);
+    if (!normalizedCandidate) return -1;
+    if (normalizedCandidate === query2) return 180;
+    if (normalizedCandidate.startsWith(query2)) return 150;
+    if (normalizedCandidate.includes(query2)) {
+      return 130 - Math.min(30, normalizedCandidate.length - query2.length);
+    }
+    const words = query2.split(" ").filter((word) => word.length >= 3);
+    if (words.length === 0) return -1;
+    const overlap = words.filter((word) => normalizedCandidate.includes(word));
+    if (overlap.length === 0) return -1;
+    return overlap.length * 18;
+  }
+  function interactiveBonus(el) {
+    const htmlEl = el;
+    const tag = el.tagName.toLowerCase();
+    const label = normalize(labelFor(el));
+    let score = 0;
+    if (tag === "button") score += 40;
+    if (tag === "a") score += 35;
+    if (tag === "input") score += 20;
+    if (htmlEl.getAttribute("role") === "button") score += 25;
+    if (/\b(shop|view|see|explore|browse|open|details|collection|discover)\b/.test(label)) {
+      score += 30;
+    }
+    if (inViewport(el)) score += 25;
+    return score;
+  }
+  function regionBonus(el) {
+    const tag = el.tagName.toLowerCase();
+    let score = 0;
+    if (/^h[1-4]$/.test(tag)) score += 45;
+    if (tag === "section" || tag === "article" || tag === "main") score += 30;
+    if (el.getAttribute("role") === "heading") score += 35;
+    if (inViewport(el)) score += 20;
+    return score;
+  }
+  function consider(best, el, score, matchedText) {
+    if (!Number.isFinite(score) || score < 0) return best;
+    if (!best || score > best.score) return { el, score, matchedText };
+    return best;
+  }
+  if (isInvalidTextTargetQuery(rawQuery)) return null;
+  const query = normalize(rawQuery);
+  if (!query) return null;
+  let bestInteractive = null;
+  const interactiveSelector = "a[href], button, [role='button'], input[type='submit'], input[type='button'], input[type='radio'], input[type='checkbox'], select, textarea";
+  doc.querySelectorAll(interactiveSelector).forEach((el) => {
+    if (!isVisible2(el)) return;
+    const matchedText = labelFor(el);
+    const score = scoreText(query, matchedText) + scoreText(query, contentFor(el)) + interactiveBonus(el);
+    bestInteractive = consider(bestInteractive, el, score, matchedText);
+  });
+  if (mode === "interactive" && bestInteractive && bestInteractive.score >= 120) {
+    const selector2 = selectorFor(bestInteractive.el);
+    if (selector2) {
+      return {
+        selector: selector2,
+        label: labelFor(bestInteractive.el),
+        kind: bestInteractive.el.tagName.toLowerCase(),
+        matchedText: bestInteractive.matchedText
+      };
+    }
+  }
+  let bestRegion = null;
+  const regionSelector = "h1, h2, h3, h4, [role='heading'], section, article, main, aside, li, [data-testid], div";
+  let seenRegions = 0;
+  doc.querySelectorAll(regionSelector).forEach((el) => {
+    if (seenRegions >= 400 || !isVisible2(el)) return;
+    seenRegions += 1;
+    const matchedText = contentFor(el);
+    const score = scoreText(query, matchedText) + regionBonus(el);
+    bestRegion = consider(bestRegion, el, score, matchedText);
+  });
+  if (!bestRegion || bestRegion.score < 80) {
+    if (mode === "interactive" && bestInteractive) {
+      const selector2 = selectorFor(bestInteractive.el);
+      if (!selector2) return null;
+      return {
+        selector: selector2,
+        label: labelFor(bestInteractive.el),
+        kind: bestInteractive.el.tagName.toLowerCase(),
+        matchedText: bestInteractive.matchedText
+      };
+    }
+    return null;
+  }
+  if (mode === "context") {
+    const selector2 = selectorFor(bestRegion.el);
+    if (!selector2) return null;
+    return {
+      selector: selector2,
+      label: labelFor(bestRegion.el),
+      kind: bestRegion.el.tagName.toLowerCase(),
+      matchedText: bestRegion.matchedText
+    };
+  }
+  let regionAction = null;
+  bestRegion.el.querySelectorAll(interactiveSelector).forEach((el) => {
+    if (!isVisible2(el)) return;
+    const matchedText = labelFor(el);
+    const score = scoreText(query, matchedText) + interactiveBonus(el) + (bestRegion ? Math.floor(bestRegion.score / 4) : 0);
+    regionAction = consider(regionAction, el, score, matchedText);
+  });
+  const chosen = regionAction || bestInteractive;
+  if (!chosen) return null;
+  const selector = selectorFor(chosen.el);
+  if (!selector) return null;
+  return {
+    selector,
+    label: labelFor(chosen.el),
+    kind: chosen.el.tagName.toLowerCase(),
+    matchedText: chosen.matchedText
+  };
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\r/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function limitText(text, maxLines, maxChars) {
+  const normalized = normalizeWhitespace(text);
+  const lines = normalized.split("\n");
+  const trimmedLines = lines.slice(0, maxLines);
+  let limited = trimmedLines.join("\n");
+  if (limited.length > maxChars) {
+    limited = `${limited.slice(0, maxChars - 1)}…`;
+  } else if (lines.length > maxLines) {
+    limited += "\n…";
+  }
+  return limited;
+}
+function extractSection(text, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = text.match(
+    new RegExp(`${escaped}\\n([\\s\\S]*?)(?=\\n### |\\n## |$)`)
+  );
+  if (!match) return null;
+  return `${heading}
+${match[1].trim()}`;
+}
+function compactReadPageResult(text) {
+  const cleaned = normalizeWhitespace(
+    text.replace(
+      /\n+Need more detail\? Escalate with read_page\(mode="debug"\) only if the narrow modes are insufficient\.\s*$/s,
+      ""
+    )
+  );
+  const readHeader = cleaned.match(/^\[read_page mode=[^\]]+\]/m)?.[0];
+  const mandatoryHeadings = [
+    "### Action Status",
+    "### Visible Purchase Controls",
+    "### Offscreen Purchase Actions"
+  ];
+  const optionalHeadings = [
+    "### Access Warnings",
+    "### Immediate Blockers",
+    "### Likely Search Results",
+    "### Primary Results",
+    "### Form Fields",
+    "### Visible Controls",
+    "### Top Headings",
+    "### Text Snapshot"
+  ];
+  const mandatorySections = mandatoryHeadings.map((heading) => extractSection(cleaned, heading)).filter((value) => Boolean(value));
+  const optionalSections = optionalHeadings.map((heading) => extractSection(cleaned, heading)).filter((value) => Boolean(value));
+  const allSections = [...mandatorySections, ...optionalSections];
+  if (allSections.length === 0) {
+    return limitText(cleaned, 22, 1800);
+  }
+  const metaLines = cleaned.split("\n").filter((line) => /^\*\*(URL|Title|Page Type|Mode|Author):\*\*/.test(line)).slice(0, 5);
+  const maxOptional = Math.max(0, 5 - mandatorySections.length);
+  const keptSections = [
+    ...mandatorySections,
+    ...optionalSections.slice(0, maxOptional)
+  ];
+  return [
+    readHeader,
+    metaLines.join("\n"),
+    keptSections.join("\n\n")
+  ].filter(Boolean).join("\n\n");
+}
+function compactSearchLikeResult(text) {
+  const cleaned = normalizeWhitespace(text);
+  const marker = "\nSearch results snapshot:\n";
+  const markerIndex = cleaned.indexOf(marker);
+  if (markerIndex === -1) {
+    return limitText(cleaned, 16, 1400);
+  }
+  const summary = cleaned.slice(0, markerIndex).trim();
+  const snapshot = cleaned.slice(markerIndex + marker.length).trim();
+  return [summary, compactReadPageResult(snapshot)].filter(Boolean).join("\n\n");
+}
+function compactCurrentTabResult(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object") return limitText(text, 8, 500);
+    return [
+      `Current tab: ${parsed.title || "(untitled)"}`,
+      parsed.url ? `URL: ${parsed.url}` : "",
+      `State: loading=${parsed.isLoading ? "yes" : "no"}, back=${parsed.canGoBack ? "yes" : "no"}, forward=${parsed.canGoForward ? "yes" : "no"}`
+    ].filter(Boolean).join("\n");
+  } catch {
+    return limitText(text, 8, 500);
+  }
+}
+function looksLikeRichToolResult(text) {
+  return text.startsWith("{") && text.includes('"__richResult":true');
+}
+function formatCompactToolResult(name, result) {
+  if (!result || looksLikeRichToolResult(result)) return result;
+  switch (name) {
+    case "current_tab":
+      return compactCurrentTabResult(result);
+    case "read_page":
+      return compactReadPageResult(result);
+    case "search":
+    case "navigate":
+    case "go_back":
+    case "go_forward":
+    case "paginate":
+    case "wait_for_navigation":
+      return compactSearchLikeResult(result);
+    case "list_tabs":
+      return limitText(result, 10, 900);
+    default:
+      return limitText(result, 18, 1400);
+  }
+}
 const DEFAULT_PAGE_SCRIPT_TIMEOUT_MS = 1500;
 const QUIET_NAVIGATION_WINDOW_MS = 1200;
 const PAGE_SCRIPT_TIMEOUT = /* @__PURE__ */ Symbol("page-script-timeout");
@@ -9358,6 +11196,47 @@ WARNING: Blocking overlay detected (${overlaySignal}). Call clear_overlays or ac
   }
   return titleLine;
 }
+async function getPostSearchSummary(wc) {
+  await waitForLoad$1(wc, 2e3);
+  try {
+    const content = await Promise.race([
+      extractContent(wc),
+      new Promise((resolve) => setTimeout(() => resolve(null), 2500))
+    ]);
+    if (content && content.content.length > 0) {
+      const scoped = buildScopedContext(content, "results_only");
+      const truncated = scoped.length > 2600 ? `${scoped.slice(0, 2600)}
+[Search results snapshot truncated...]` : scoped;
+      return `
+Search results snapshot:
+${truncated}`;
+    }
+  } catch {
+  }
+  const fallback = await getPostNavSummary(wc);
+  return fallback ? `${fallback}
+Search results snapshot unavailable. Use read_page(mode="results_only") if needed.` : `
+Search results snapshot unavailable. Use read_page(mode="results_only") if needed.`;
+}
+async function getPostClickNavSummary(wc, toolProfile) {
+  try {
+    const content = await Promise.race([
+      extractContent(wc),
+      new Promise((resolve) => setTimeout(() => resolve(null), 3e3))
+    ]);
+    if (content && content.content.length > 0) {
+      const scoped = toolProfile === "compact" ? buildCompactScopedContext(content, "visible_only") : buildScopedContext(content, "visible_only");
+      const maxLen = toolProfile === "compact" ? 1800 : 3e3;
+      const truncated = scoped.length > maxLen ? `${scoped.slice(0, maxLen)}
+[Page snapshot truncated. Use read_page for full details.]` : scoped;
+      return `
+Page snapshot after navigation:
+${truncated}`;
+    }
+  } catch {
+  }
+  return "";
+}
 async function scrollPage$1(wc, deltaY) {
   const getScrollY = async () => {
     const scrollY = await executePageScript(
@@ -9550,9 +11429,17 @@ async function describeElementForClick$1(wc, selector) {
       if (!el) return { error: "Element not found" };
       const anchor = el instanceof HTMLAnchorElement ? el : el.closest("a[href]");
       const text = (el.textContent || el.tagName || "Element").trim().slice(0, 100);
+      const tag = el.tagName.toLowerCase();
+      const interactiveTags = new Set(["a","button","input","select","textarea","summary","details","option"]);
+      const hasRole = el.getAttribute("role") === "button" || el.getAttribute("role") === "link" || el.getAttribute("role") === "tab";
+      const hasClickListener = el.onclick != null || el.getAttribute("onclick") != null;
+      const isInteractive = interactiveTags.has(tag) || hasRole || hasClickListener || !!anchor;
       return {
         text: text || "Element",
         href: anchor instanceof HTMLAnchorElement ? anchor.href : undefined,
+        target: anchor instanceof HTMLAnchorElement ? (anchor.getAttribute("target") || "") : undefined,
+        tag,
+        isInteractive,
       };
     })()
   `,
@@ -9571,7 +11458,10 @@ async function describeElementForClick$1(wc, selector) {
   }
   return {
     text: "text" in result && typeof result.text === "string" ? result.text : "Element",
-    href: "href" in result && typeof result.href === "string" ? result.href : void 0
+    href: "href" in result && typeof result.href === "string" ? result.href : void 0,
+    target: "target" in result && typeof result.target === "string" ? result.target : void 0,
+    tag: "tag" in result && typeof result.tag === "string" ? result.tag : void 0,
+    isInteractive: "isInteractive" in result && typeof result.isInteractive === "boolean" ? result.isInteractive : void 0
   };
 }
 async function inspectElement(wc, selector, limit = 8) {
@@ -9655,6 +11545,18 @@ async function inspectElement(wc, selector, limit = 8) {
         ) || "element";
       }
 
+      function purchasePriority(label, href) {
+        const haystack = ((label || "") + " " + (href || ""))
+          .toLowerCase()
+          .replace(/s+/g, " ")
+          .trim();
+        if (!haystack) return null;
+        if (/\badd(?: item)? to (?:cart|bag|basket)\b/.test(haystack)) return 0;
+        if (/\b(?:buy now|preorder|pre-order|reserve now|shop now)\b/.test(haystack)) return 1;
+        if (/\b(?:checkout|view cart|view basket|go to cart|view bag)\b/.test(haystack)) return 2;
+        return null;
+      }
+
       function chooseRegion(target) {
         const preferred = target.closest(
           "[data-testid], article, [role='article'], [role='listitem'], li, tr, form, section, aside, dialog, [role='dialog']"
@@ -9680,19 +11582,69 @@ async function inspectElement(wc, selector, limit = 8) {
       const region = chooseRegion(target);
       const nearby = [];
       const seen = new Set();
+      const purchaseActions = [];
+      const purchaseSeen = new Set();
       region.querySelectorAll("a[href], button, input:not([type='hidden']), select, textarea").forEach((el) => {
         if (!(el instanceof HTMLElement) || !isVisible(el)) return;
         const candidateSelector = selectorFor(el);
         if (!candidateSelector || seen.has(candidateSelector)) return;
         seen.add(candidateSelector);
+        const candidateLabel = labelFor(el).slice(0, 100);
+        const candidateHref = el instanceof HTMLAnchorElement ? text(el.href) : undefined;
         nearby.push({
-          label: labelFor(el).slice(0, 100),
+          index: typeof window.__vessel?.getElementIndexBySelector === "function"
+            ? window.__vessel.getElementIndexBySelector(candidateSelector) ?? undefined
+            : undefined,
+          label: candidateLabel,
+          type: el.tagName.toLowerCase(),
+          selector: candidateSelector,
+          href: candidateHref,
+        });
+        const purchaseRank = purchasePriority(candidateLabel, candidateHref);
+        if (purchaseRank !== null && !purchaseSeen.has(candidateSelector)) {
+          purchaseSeen.add(candidateSelector);
+          purchaseActions.push({
+            index: typeof window.__vessel?.getElementIndexBySelector === "function"
+              ? window.__vessel.getElementIndexBySelector(candidateSelector) ?? undefined
+              : undefined,
+            label: candidateLabel,
+            type: el.tagName.toLowerCase(),
+            selector: candidateSelector,
+            href: candidateHref,
+            source: "nearby",
+            rank: purchaseRank,
+          });
+        }
+      });
+
+      document.querySelectorAll("button, a[href], input[type='submit'], input[type='button']").forEach((el) => {
+        if (!(el instanceof HTMLElement) || !isVisible(el)) return;
+        const candidateSelector = selectorFor(el);
+        if (!candidateSelector || purchaseSeen.has(candidateSelector)) return;
+        const candidateLabel = labelFor(el).slice(0, 100);
+        const candidateHref = el instanceof HTMLAnchorElement ? text(el.href) : undefined;
+        const purchaseRank = purchasePriority(candidateLabel, candidateHref);
+        if (purchaseRank === null) return;
+        purchaseSeen.add(candidateSelector);
+        purchaseActions.push({
+          index: typeof window.__vessel?.getElementIndexBySelector === "function"
+            ? window.__vessel.getElementIndexBySelector(candidateSelector) ?? undefined
+            : undefined,
+          label: candidateLabel,
           type: el.tagName.toLowerCase(),
           selector: candidateSelector,
-          href: el instanceof HTMLAnchorElement ? text(el.href) : undefined,
+          href: candidateHref,
+          source: "page",
+          rank: purchaseRank,
         });
       });
 
+      purchaseActions.sort((a, b) => {
+        if (a.rank !== b.rank) return a.rank - b.rank;
+        if (a.source !== b.source) return a.source === "nearby" ? -1 : 1;
+        return a.label.localeCompare(b.label);
+      });
+
       return {
         target: {
           label: labelFor(target).slice(0, 120),
@@ -9709,6 +11661,14 @@ async function inspectElement(wc, selector, limit = 8) {
           text: text(region.textContent)?.slice(0, 400),
         },
         nearby: nearby.slice(0, ${Math.max(1, Math.min(20, limit))}),
+        purchaseActions: purchaseActions.slice(0, 8).map((item) => ({
+          index: item.index,
+          label: item.label,
+          type: item.type,
+          selector: item.selector,
+          href: item.href,
+          source: item.source,
+        })),
       };
     })()
   `,
@@ -9741,10 +11701,25 @@ async function inspectElement(wc, selector, limit = 8) {
     lines.push("Nearby controls:");
     for (const item of result.nearby) {
       const hrefSuffix = item.href ? ` -> ${item.href}` : "";
+      const indexPrefix = typeof item.index === "number" ? `[#${item.index}] ` : "";
+      lines.push(
+        `- ${indexPrefix}${item.label} [${item.type}] selector=${item.selector}${hrefSuffix}`
+      );
+    }
+  }
+  if (Array.isArray(result.purchaseActions) && result.purchaseActions.length > 0) {
+    lines.push("Likely purchase actions:");
+    for (const item of result.purchaseActions) {
+      const hrefSuffix = item.href ? ` -> ${item.href}` : "";
+      const sourceSuffix = item.source === "nearby" ? " (same region)" : " (elsewhere on page)";
+      const indexPrefix = typeof item.index === "number" ? `[#${item.index}] ` : "";
       lines.push(
-        `- ${item.label} [${item.type}] selector=${item.selector}${hrefSuffix}`
+        `- ${indexPrefix}${item.label} [${item.type}] selector=${item.selector}${hrefSuffix}${sourceSuffix}`
       );
     }
+    lines.push(
+      "When an index is available, prefer click(index=N) over selector-based clicks because it is more stable."
+    );
   }
   return lines.join("\n");
 }
@@ -9833,6 +11808,11 @@ const ADD_TO_CART_PATTERNS = [
 ];
 const recentCartClicks = /* @__PURE__ */ new Map();
 const CART_CLICK_COOLDOWN_MS = 15e3;
+const CART_ADDED_TTL_MS = 30 * 6e4;
+const cartAddedProducts = /* @__PURE__ */ new Map();
+let clickStreakUrl = null;
+let clickStreakCount = 0;
+const CLICK_STREAK_THRESHOLD = 3;
 function isAddToCartText(text) {
   const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
   return ADD_TO_CART_PATTERNS.some((p) => normalized.includes(p));
@@ -9852,20 +11832,115 @@ function isDuplicateCartClick(url, text) {
     recentCartClicks.delete(url);
     return false;
   }
-  return isAddToCartText(text);
+  return isAddToCartText(text);
+}
+async function getProductPageTitle(wc) {
+  try {
+    const heading = await executePageScript(
+      wc,
+      `(function() {
+        var h1 = document.querySelector('h1');
+        if (h1 && h1.textContent.trim().length > 3 && h1.textContent.trim().length < 200) {
+          return h1.textContent.trim();
+        }
+        var meta = document.querySelector('meta[property="og:title"]');
+        if (meta && meta.content && meta.content.trim().length > 3) {
+          return meta.content.trim();
+        }
+        return '';
+      })()`,
+      { timeoutMs: 800, label: "get product title" }
+    );
+    if (heading && heading !== PAGE_SCRIPT_TIMEOUT && typeof heading === "string" && heading.length > 0) {
+      return heading;
+    }
+  } catch {
+  }
+  return wc.getTitle() || "";
+}
+function normalizeCartProductKey(url) {
+  try {
+    const parsed = new URL(url);
+    const pathname = parsed.pathname.replace(/\/+$/, "") || "/";
+    return `${parsed.origin}${pathname}`;
+  } catch {
+    return url;
+  }
+}
+function pruneCartAddedProducts(now = Date.now()) {
+  for (const [key, entry] of cartAddedProducts) {
+    if (now - entry.ts > CART_ADDED_TTL_MS) {
+      cartAddedProducts.delete(key);
+    }
+  }
+}
+function cartOrigin(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function recordProductAddedToCart(url, productName) {
+  pruneCartAddedProducts();
+  cartAddedProducts.set(normalizeCartProductKey(url), {
+    title: productName || url,
+    ts: Date.now()
+  });
+}
+function isProductAlreadyInCart(url) {
+  pruneCartAddedProducts();
+  return cartAddedProducts.has(normalizeCartProductKey(url));
+}
+function getCartAddedSummary(url) {
+  pruneCartAddedProducts();
+  const origin = cartOrigin(url);
+  const items = Array.from(cartAddedProducts.entries()).filter(([key]) => !origin || key.startsWith(`${origin}/`)).map(([_path, info]) => `- ${info.title}`).join("\n");
+  if (!items) return "";
+  const count = items.split("\n").length;
+  return `
+Already in cart (${count} items):
+${items}`;
+}
+async function buildCartSuccessSuffix(wc, productUrl, overlayHint) {
+  const productTitle = await getProductPageTitle(wc);
+  recordProductAddedToCart(productUrl, productTitle);
+  const cartSummary = getCartAddedSummary(productUrl);
+  const dismissResult = await tryAutoDismissCartDialog(wc);
+  if (dismissResult) {
+    return `
+Item added to cart. ${dismissResult}${cartSummary}
+Go back to search results to select the next product.`;
+  }
+  if (!overlayHint) {
+    return cartSummary;
+  }
+  const dialogActions = await getCartDialogActions$1(wc);
+  const actionsSuffix = dialogActions ? `
+${dialogActions}
+Click one of these dialog actions. Do NOT click any other element.` : "";
+  return `
+${overlayHint}${actionsSuffix}${cartSummary}`;
 }
 async function clickResolvedSelector$1(wc, selector) {
   if (selector.startsWith("__vessel_idx:")) {
     const idx = Number(selector.slice("__vessel_idx:".length));
     const beforeUrl2 = wc.getURL();
+    let idxCartMatch = false;
     const idxLabel = await executePageScript(
       wc,
       `window.__vessel?.getElementText?.(${idx}) || ""`,
       { label: "shadow element text" }
     );
-    if (typeof idxLabel === "string" && isAddToCartText(idxLabel) && isDuplicateCartClick(beforeUrl2, idxLabel)) {
+    if (typeof idxLabel === "string" && (idxCartMatch = isAddToCartText(idxLabel)) && isDuplicateCartClick(beforeUrl2, idxLabel)) {
       return `Blocked: "${idxLabel}" was already clicked on this page. The item is in your cart. Call read_page to see available actions (e.g. View Cart, Continue Shopping).`;
     }
+    if (idxCartMatch && isProductAlreadyInCart(beforeUrl2)) {
+      const summary = getCartAddedSummary(beforeUrl2);
+      return `Blocked: This product was already added to the cart.${summary}
+Go back and select a different product.`;
+    }
     const result = await executePageScript(
       wc,
       `window.__vessel?.interactByIndex?.(${idx}, "click") || "Error: interactByIndex not available"`,
@@ -9875,18 +11950,40 @@ async function clickResolvedSelector$1(wc, selector) {
     );
     if (result === PAGE_SCRIPT_TIMEOUT) return pageBusyError("click");
     if (typeof result === "string" && result.startsWith("Error")) return result;
-    if (typeof idxLabel === "string" && isAddToCartText(idxLabel)) {
+    if (idxCartMatch) {
       recordCartClick(beforeUrl2, idxLabel);
     }
     await waitForPotentialNavigation$1(wc, beforeUrl2);
     const afterUrl2 = wc.getURL();
     if (afterUrl2 !== beforeUrl2) return `${result} -> ${afterUrl2}`;
-    const idxOverlay = await detectPostClickOverlay$1(wc);
+    let idxOverlay = await detectPostClickOverlay$1(wc);
+    if (!idxOverlay && idxCartMatch) {
+      await sleep$1(1200);
+      idxOverlay = await detectPostClickOverlay$1(wc);
+    }
+    if (idxCartMatch) {
+      return `${result}${await buildCartSuccessSuffix(wc, beforeUrl2, idxOverlay)}`;
+    }
+    if (!idxOverlay) {
+      const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
+      if (hrefMatch) {
+        try {
+          assertSafeURL(hrefMatch[1]);
+          await wc.loadURL(hrefMatch[1]);
+          await waitForLoad$1(wc, 8e3);
+          const hrefUrl = wc.getURL();
+          if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
+        } catch {
+        }
+      }
+    }
     return idxOverlay ? `${result}
-${idxOverlay}` : result;
+${idxOverlay}` : `${result}
+Note: Page did not change after click.`;
   }
   if (selector.includes(" >>> ")) {
     const beforeUrl2 = wc.getURL();
+    let shadowCartMatch = false;
     const shadowLabel = await executePageScript(
       wc,
       `(function() {
@@ -9895,17 +11992,24 @@ ${idxOverlay}` : result;
       })()`,
       { label: "shadow element text" }
     );
-    if (typeof shadowLabel === "string" && isAddToCartText(shadowLabel) && isDuplicateCartClick(beforeUrl2, shadowLabel)) {
+    if (typeof shadowLabel === "string" && (shadowCartMatch = isAddToCartText(shadowLabel)) && isDuplicateCartClick(beforeUrl2, shadowLabel)) {
       return `Blocked: "${shadowLabel}" was already clicked on this page. The item is in your cart. Call read_page to see available actions (e.g. View Cart, Continue Shopping).`;
     }
+    if (shadowCartMatch && isProductAlreadyInCart(beforeUrl2)) {
+      const summary = getCartAddedSummary(beforeUrl2);
+      return `Blocked: This product was already added to the cart.${summary}
+Go back and select a different product.`;
+    }
     const result = await executePageScript(
       wc,
       `
       (function() {
         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 || !document.contains(el)) return "Error[stale-index]: Shadow DOM element not found — call read_page to refresh.";
         if (el instanceof HTMLElement) { el.focus(); el.click(); }
-        return "Clicked: " + (el.getAttribute("aria-label") || el.textContent?.trim().slice(0, 60) || el.tagName.toLowerCase());
+        var anchor = el instanceof HTMLAnchorElement ? el : el.closest('a[href]');
+        var href = anchor instanceof HTMLAnchorElement ? anchor.href : null;
+        return "Clicked: " + (el.getAttribute("aria-label") || el.textContent?.trim().slice(0, 60) || el.tagName.toLowerCase()) + (href ? "\\nhref: " + href : "");
       })()
     `,
       {
@@ -9914,15 +12018,36 @@ ${idxOverlay}` : result;
     );
     if (result === PAGE_SCRIPT_TIMEOUT) return pageBusyError("click");
     if (typeof result === "string" && result.startsWith("Error")) return result;
-    if (typeof shadowLabel === "string" && isAddToCartText(shadowLabel)) {
+    if (shadowCartMatch) {
       recordCartClick(beforeUrl2, shadowLabel);
     }
     await waitForPotentialNavigation$1(wc, beforeUrl2);
     const afterUrl2 = wc.getURL();
     if (afterUrl2 !== beforeUrl2) return `${result} -> ${afterUrl2}`;
-    const shadowOverlay = await detectPostClickOverlay$1(wc);
+    let shadowOverlay = await detectPostClickOverlay$1(wc);
+    if (!shadowOverlay && shadowCartMatch) {
+      await sleep$1(1200);
+      shadowOverlay = await detectPostClickOverlay$1(wc);
+    }
+    if (shadowCartMatch) {
+      return `${result}${await buildCartSuccessSuffix(wc, beforeUrl2, shadowOverlay)}`;
+    }
+    if (!shadowOverlay) {
+      const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
+      if (hrefMatch) {
+        try {
+          assertSafeURL(hrefMatch[1]);
+          await wc.loadURL(hrefMatch[1]);
+          await waitForLoad$1(wc, 8e3);
+          const hrefUrl = wc.getURL();
+          if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
+        } catch {
+        }
+      }
+    }
     return shadowOverlay ? `${result}
-${shadowOverlay}` : result;
+${shadowOverlay}` : `${result}
+Note: Page did not change after click.`;
   }
   const beforeUrl = wc.getURL();
   const elInfo = await describeElementForClick$1(wc, selector);
@@ -9945,10 +12070,16 @@ Click one of these dialog actions instead.`;
       return formatDeadLinkMessage(elInfo.text, validation);
     }
   }
+  if (cartMatch && isProductAlreadyInCart(beforeUrl)) {
+    const summary = getCartAddedSummary(beforeUrl);
+    return `Blocked: This product was already added to the cart.${summary}
+Go back and select a different product.`;
+  }
   if (cartMatch) {
     recordCartClick(beforeUrl, elInfo.text);
   }
-  const clickText = `Clicked: ${elInfo.text}`;
+  const tagLabel = elInfo.tag && elInfo.tag !== "a" && elInfo.tag !== "button" ? ` <${elInfo.tag}>` : "";
+  const clickText = `Clicked: ${elInfo.text}${tagLabel}`;
   const clickResult = await clickElement$1(wc, selector);
   if (clickResult.startsWith("Error:")) return clickResult;
   await waitForPotentialNavigation$1(wc, beforeUrl);
@@ -9958,15 +12089,30 @@ Click one of these dialog actions instead.`;
   }
   const overlayHint = await detectPostClickOverlay$1(wc);
   if (overlayHint) {
-    const dialogActions = cartMatch ? await getCartDialogActions$1(wc) : null;
-    const actionsSuffix = dialogActions ? `
-${dialogActions}
-Click one of these dialog actions. Do NOT click any other element.` : "";
+    if (cartMatch) {
+      return `${clickText} (${clickResult})${await buildCartSuccessSuffix(
+        wc,
+        beforeUrl,
+        overlayHint
+      )}`;
+    }
     return `${clickText} (${clickResult})
-${overlayHint}${actionsSuffix}`;
+${overlayHint}`;
   }
   if (cartMatch) {
-    return `${clickText} (${clickResult})`;
+    await sleep$1(1200);
+    const delayedOverlayHint = await detectPostClickOverlay$1(wc);
+    if (delayedOverlayHint) {
+      return `${clickText} (${clickResult})${await buildCartSuccessSuffix(
+        wc,
+        beforeUrl,
+        delayedOverlayHint
+      )}`;
+    }
+    return `${clickText} (${clickResult})${await buildCartSuccessSuffix(
+      wc,
+      beforeUrl
+    )}`;
   }
   const activationResult = await activateElement$1(wc, selector);
   if (!activationResult.startsWith("Error:")) {
@@ -9981,7 +12127,65 @@ ${overlayHint}${actionsSuffix}`;
     return `${clickText} (${clickResult})
 ${postActivationOverlayHint}`;
   }
-  return `${clickText} (${clickResult})`;
+  const sameTabLinkTarget = typeof elInfo.href === "string" && elInfo.href.trim().length > 0 && (!elInfo.target || !/^_blank$/i.test(elInfo.target.trim()));
+  if (sameTabLinkTarget) {
+    const validation = await validateLinkDestination(elInfo.href);
+    if (validation.status !== "dead") {
+      try {
+        assertSafeURL(elInfo.href);
+        await wc.loadURL(elInfo.href);
+        await waitForLoad$1(wc, 8e3);
+        const hrefFallbackUrl = wc.getURL();
+        if (hrefFallbackUrl !== beforeUrl) {
+          return `${clickText} -> ${hrefFallbackUrl} (recovered via href fallback)`;
+        }
+      } catch {
+      }
+    }
+  }
+  const nonInteractiveWarning = elInfo.isInteractive === false && !elInfo.href ? `
+Note: The clicked element (<${elInfo.tag || "unknown"}>) is not a link or button. Nothing happened. Try clicking the actual link element nearby or use read_page to find the correct interactive element.` : `
+Note: Page did not change after click. The element may need a different interaction method. Consider read_page or inspect_element.`;
+  return `${clickText} (${clickResult})${nonInteractiveWarning}`;
+}
+async function tryAutoDismissCartDialog(wc) {
+  try {
+    const result = await executePageScript(
+      wc,
+      `
+      (function() {
+        var dialog = document.querySelector('[role="dialog"], dialog[open], [role="alertdialog"], [aria-modal="true"]');
+        if (!dialog) return null;
+        var cs = getComputedStyle(dialog);
+        if (cs.display === 'none' || cs.visibility === 'hidden') return null;
+        var buttons = dialog.querySelectorAll('button, a[href], [role="button"]');
+        var continueBtn = null;
+        var closeBtn = null;
+        for (var i = 0; i < buttons.length; i++) {
+          var label = (buttons[i].getAttribute('aria-label') || buttons[i].textContent || '').trim().toLowerCase();
+          if (/continue shopping|keep shopping|back to shopping/.test(label)) { continueBtn = buttons[i]; break; }
+          if (/close|dismiss|×/.test(label) && !closeBtn) { closeBtn = buttons[i]; }
+        }
+        var target = continueBtn || closeBtn;
+        if (!target) return null;
+        var actionLabel = (target.getAttribute('aria-label') || target.textContent || '').trim();
+        if (target.tagName === 'A' && target.href) {
+          window.location.href = target.href;
+          return "Navigated via: " + actionLabel;
+        }
+        target.click();
+        return "Dismissed dialog via: " + actionLabel;
+      })()
+      `,
+      { timeoutMs: 1500, label: "auto dismiss cart dialog" }
+    );
+    if (result && result !== PAGE_SCRIPT_TIMEOUT && typeof result === "string") {
+      await sleep$1(500);
+      return result;
+    }
+  } catch {
+  }
+  return null;
 }
 async function getCartDialogActions$1(wc) {
   const result = await executePageScript(
@@ -10787,6 +12991,24 @@ async function resolveSelector$1(wc, index, selector) {
   if (extractedSelector) return extractedSelector;
   return null;
 }
+async function resolveTargetByText(wc, query, mode) {
+  const trimmed = query.trim();
+  if (!trimmed) return null;
+  if (isInvalidTextTargetQuery(trimmed)) return null;
+  const result = await executePageScript(
+    wc,
+    `(${resolveTextTargetInDocument.toString()})(document, ${JSON.stringify(trimmed)}, ${JSON.stringify(mode)})`,
+    {
+      timeoutMs: 2200,
+      label: `resolve ${mode} target by text`
+    }
+  );
+  if (result === PAGE_SCRIPT_TIMEOUT) return PAGE_SCRIPT_TIMEOUT;
+  if (!result || typeof result.selector !== "string" || !result.selector) {
+    return null;
+  }
+  return result.selector;
+}
 function normalizeFieldToken(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -12094,6 +14316,9 @@ async function searchPage(wc, args) {
   if (buttonLikePatterns.some((p) => queryLower.includes(p))) {
     return `Error: "${query}" looks like a button label, not a search query. Use the click tool to interact with this element instead.`;
   }
+  if (looksLikeCurrentSiteNameQuery(query, wc.getURL(), wc.getTitle() || "")) {
+    return `Error: "${query}" looks like the current site's name, not a product query. You are already on ${wc.getURL()}. Open a section like staff picks/new releases or search for actual book titles, authors, or genres instead.`;
+  }
   if (typeof args.selector !== "string") {
     const shortcut = buildSearchShortcut(wc.getURL(), query);
     if (shortcut) {
@@ -12104,7 +14329,7 @@ async function searchPage(wc, args) {
       const afterUrl2 = wc.getURL();
       const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
       const destination = shortcut.section ? ` ${shortcut.section}` : "";
-      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}`;
+      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}${await getPostSearchSummary(wc)}`;
     }
   }
   const searchInfo = await locateSearchTarget(
@@ -12133,7 +14358,7 @@ async function searchPage(wc, args) {
   await waitForPotentialNavigation$1(wc, beforeUrl, 3e3);
   let afterUrl = wc.getURL();
   if (afterUrl !== beforeUrl) {
-    return `Searched "${query}" → ${afterUrl}`;
+    return `Searched "${query}" → ${afterUrl}${await getPostSearchSummary(wc)}`;
   }
   if (searchInfo.submitSelector) {
     const clickResult = await clickElementBySelector(wc, searchInfo.submitSelector);
@@ -12141,11 +14366,11 @@ async function searchPage(wc, args) {
       await waitForPotentialNavigation$1(wc, beforeUrl, 3e3);
       afterUrl = wc.getURL();
       if (afterUrl !== beforeUrl) {
-        return `Searched "${query}" (via search button) → ${afterUrl}`;
+        return `Searched "${query}" (via search button) → ${afterUrl}${await getPostSearchSummary(wc)}`;
       }
     }
   }
-  return `Searched "${query}" (same page — results may have loaded dynamically; inspect with read_page(mode="results_only") or read_page(mode="visible_only") before navigating directly elsewhere)`;
+  return `Searched "${query}" (same page — results may have loaded dynamically)${await getPostSearchSummary(wc)}`;
 }
 async function pressKey$1(wc, args) {
   const key = typeof args.key === "string" ? args.key.trim() : "";
@@ -12234,8 +14459,49 @@ async function getPostActionState$1(ctx, name) {
     if (wc.isLoading()) {
       await waitForLoad$1(wc);
     }
+    const currentUrl = wc.getURL();
+    let warnings = "";
+    if (isProductAlreadyInCart(currentUrl)) {
+      warnings += `
+WARNING: This product is already in your cart.${getCartAddedSummary(currentUrl)}
+Go back and select a different product.`;
+    }
+    const taskGoal = ctx.runtime.getState().taskTracker?.goal;
+    if (taskGoal && name === "click") {
+      const drift = shouldBlockOffGoalDomainNavigation(taskGoal, currentUrl);
+      if (drift) {
+        warnings += `
+WARNING: You drifted to ${drift.targetDomain} but the task requires staying on ${drift.requestedDomain}. Call go_back immediately to return to the previous page.`;
+      }
+    }
+    if (name === "go_back" || name === "search") {
+      const cartSummary = getCartAddedSummary(currentUrl);
+      if (cartSummary) {
+        warnings += `${cartSummary}
+Select a DIFFERENT product that is not in the cart. Call read_page if needed to see available results.`;
+      }
+    }
     return `
-[state: url=${wc.getURL()}, title=${JSON.stringify(wc.getTitle() || "")}, canGoBack=${tab.canGoBack()}, canGoForward=${tab.canGoForward()}, loading=${wc.isLoading()}]`;
+[state: url=${currentUrl}, title=${JSON.stringify(wc.getTitle() || "")}, canGoBack=${tab.canGoBack()}, canGoForward=${tab.canGoForward()}, loading=${wc.isLoading()}]${warnings}`;
+  }
+  if (name === "click" && !wc.isLoading()) {
+    try {
+      const emptyPage = await executePageScript(
+        wc,
+        `(function() {
+          var body = (document.body.textContent || '').toLowerCase();
+          return /\b(no results|no items found|nothing matched|0 results|zero results|no products|your search.*did not match|no books found)\b/.test(body)
+            && body.length < 8000;
+        })()`,
+        { timeoutMs: 1e3, label: "empty page check" }
+      );
+      if (emptyPage && emptyPage !== PAGE_SCRIPT_TIMEOUT) {
+        return `
+[state: url=${wc.getURL()}, title=${JSON.stringify(wc.getTitle() || "")}, canGoBack=${tab.canGoBack()}, canGoForward=${tab.canGoForward()}, loading=false]
+WARNING: This page shows no results. You likely clicked a filter or category link instead of a product. Call go_back to return to the search results.`;
+      }
+    } catch {
+    }
   }
   if (interactActions.includes(name)) {
     return `
@@ -12307,6 +14573,7 @@ const KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "wait_for_navigation"
 ]);
 async function executeAction(name, args, ctx) {
+  name = normalizeToolAlias(name);
   if (!KNOWN_TOOLS.has(name)) {
     for (const known of KNOWN_TOOLS) {
       if (name.startsWith(known) && name.length > known.length) {
@@ -12423,6 +14690,19 @@ async function executeAction(name, args, ctx) {
         }
         case "navigate": {
           if (!wc || !tabId) return "Error: No active tab";
+          const taskGoal = ctx.runtime.getState().taskTracker?.goal;
+          if (taskGoal && typeof args.url === "string") {
+            const domainDrift = shouldBlockOffGoalDomainNavigation(
+              taskGoal,
+              args.url
+            );
+            if (domainDrift) {
+              return `Navigation blocked: ${args.url} drifts away from the requested site ${domainDrift.requestedDomain}. Stay on the requested domain and continue the original task there.`;
+            }
+          }
+          if (typeof args.url === "string" && !args.postBody && isRedundantNavigateTarget(wc.getURL(), args.url)) {
+            return `Already on ${wc.getURL()}. Do not navigate to the same URL again. Use click, inspect_element, read_page, or search for actual book terms instead.`;
+          }
           const navValidation = await validateLinkDestination(args.url);
           if (navValidation.status === "dead") {
             return `Navigation blocked: ${args.url} returned ${navValidation.detail || "dead link"}. Try a different URL or go back and choose another link.`;
@@ -12462,14 +14742,48 @@ async function executeAction(name, args, ctx) {
         }
         case "click": {
           if (!wc) return "Error: No active tab";
-          const selector = typeof args.selector === "string" && args.selector.trim() ? await resolveSelector$1(wc, void 0, args.selector) : typeof args.index === "number" ? `__vessel_idx:${args.index}` : await resolveSelector$1(wc, args.index, args.selector);
-          if (!selector) return "Error: No element index or selector provided";
+          let selector = null;
+          const textTarget = typeof args.text === "string" && args.text.trim() ? args.text.trim() : "";
+          if (typeof args.selector === "string" && args.selector.trim()) {
+            selector = await resolveSelector$1(wc, void 0, args.selector);
+          } else if (textTarget) {
+            if (isInvalidTextTargetQuery(textTarget)) {
+              return `Error: "${textTarget}" looks like HTML or markup, not a visible page label. Use a book title, button text, or element index instead.`;
+            }
+            selector = await resolveTargetByText(wc, textTarget, "interactive");
+            if (!selector && typeof args.index === "number") {
+              selector = `__vessel_idx:${args.index}`;
+            }
+          } else if (typeof args.index === "number") {
+            selector = await resolveSelector$1(wc, args.index);
+            if (!selector) selector = `__vessel_idx:${args.index}`;
+          } else {
+            selector = await resolveSelector$1(wc, args.index, args.selector);
+          }
+          if (selector === PAGE_SCRIPT_TIMEOUT) return pageBusyError("click");
+          if (!selector) {
+            return "Error: No element index, selector, or visible text provided";
+          }
           return clickResolvedSelector$1(wc, selector);
         }
         case "inspect_element": {
           if (!wc) return "Error: No active tab";
-          const selector = await resolveSelector$1(wc, args.index, args.selector);
-          if (!selector) return "Error: No element index or selector provided";
+          let selector = null;
+          const textTarget = typeof args.text === "string" && args.text.trim() ? args.text.trim() : "";
+          if (textTarget) {
+            if (isInvalidTextTargetQuery(textTarget)) {
+              return `Error: "${textTarget}" looks like HTML or markup, not visible page text. Use a section title, book title, or element index instead.`;
+            }
+            selector = await resolveTargetByText(wc, textTarget, "context");
+          } else {
+            selector = await resolveSelector$1(wc, args.index, args.selector);
+          }
+          if (selector === PAGE_SCRIPT_TIMEOUT) {
+            return pageBusyError("inspect_element");
+          }
+          if (!selector) {
+            return "Error: No element index, selector, or visible text provided";
+          }
           return inspectElement(
             wc,
             selector,
@@ -12618,7 +14932,8 @@ async function executeAction(name, args, ctx) {
             const livePrefix = liveSelectionSection ? `${liveSelectionSection}
 
 ` : "";
-            const requestedMode = normalizeReadPageMode(args.mode, content);
+            const baseMode = normalizeReadPageMode(args.mode, content);
+            const requestedMode = ctx.toolProfile === "compact" && (args.mode == null || typeof args.mode === "string" && !args.mode.trim()) ? chooseCompactReadMode(content, baseMode) : baseMode;
             if (requestedMode === "debug" || requestedMode === "full") {
               const structured = buildStructuredContext(content);
               const truncated = content.content.length > 2e4 ? content.content.slice(0, 2e4) + "\n[Content truncated...]" : content.content;
@@ -12630,7 +14945,7 @@ ${structured}
 
 ${truncated}`;
             }
-            const scoped = buildScopedContext(content, requestedMode);
+            const scoped = ctx.toolProfile === "compact" ? buildCompactScopedContext(content, requestedMode) : buildScopedContext(content, requestedMode);
             return [
               livePrefix ? livePrefix.trimEnd() : "",
               `[read_page mode=${requestedMode}]`,
@@ -13307,9 +15622,20 @@ ${JSON.stringify(tableJson, null, 2)}`;
         }
         case "scroll_to_element": {
           if (!wc) return "Error: No active tab";
-          const sel = await resolveSelector$1(wc, args.index, args.selector);
-          if (!sel)
-            return "Error: Provide an index or selector for the element to scroll to.";
+          let sel = null;
+          const textTarget = typeof args.text === "string" && args.text.trim() ? args.text.trim() : "";
+          if (textTarget) {
+            if (isInvalidTextTargetQuery(textTarget)) {
+              return `Error: "${textTarget}" looks like HTML or markup, not visible page text. Use a section title or element index instead.`;
+            }
+            sel = await resolveTargetByText(wc, textTarget, "context");
+          } else {
+            sel = await resolveSelector$1(wc, args.index, args.selector);
+          }
+          if (sel === PAGE_SCRIPT_TIMEOUT) return pageBusyError("scroll_to_element");
+          if (!sel) {
+            return "Error: Provide an index, selector, or visible text for the element to scroll to.";
+          }
           const block = args.position === "top" ? "start" : args.position === "bottom" ? "end" : "center";
           if (sel.startsWith("__vessel_idx:")) {
             const idx = Number(sel.slice("__vessel_idx:".length));
@@ -13347,8 +15673,36 @@ ${JSON.stringify(tableJson, null, 2)}`;
       }
     }
   });
+  const formattedResult = ctx.toolProfile === "compact" ? formatCompactToolResult(name, result) : result;
   const flowCtx = ctx.runtime.getFlowContext();
-  return result + await getPostActionState$1(ctx, name) + flowCtx;
+  let clickNavSummary = "";
+  if (name === "click" && !result.startsWith("Error") && !result.startsWith("Blocked") && result.includes(" -> ")) {
+    const summaryWc = ctx.tabManager.getActiveTab()?.view.webContents;
+    if (summaryWc) {
+      clickNavSummary = await getPostClickNavSummary(
+        summaryWc,
+        ctx.toolProfile
+      );
+    }
+  }
+  let streakWarning = "";
+  if (name === "click" && !result.startsWith("Error") && !result.startsWith("Blocked")) {
+    const currentUrl = ctx.tabManager.getActiveTab()?.view.webContents.getURL() ?? "";
+    if (currentUrl === clickStreakUrl) {
+      clickStreakCount++;
+    } else {
+      clickStreakUrl = currentUrl;
+      clickStreakCount = 1;
+    }
+    if (clickStreakCount >= CLICK_STREAK_THRESHOLD) {
+      streakWarning = `
+WARNING: You have clicked ${clickStreakCount} elements on this page without verifying the result. Call read_page or inspect_element to check the current page state before clicking again. If clicks are having no effect, the elements may not be interactive — try different element indices or read the page to find clickable links.`;
+    }
+  } else if (["read_page", "inspect_element", "screenshot", "wait_for"].includes(name)) {
+    clickStreakCount = 0;
+    clickStreakUrl = null;
+  }
+  return formattedResult + await getPostActionState$1(ctx, name) + clickNavSummary + streakWarning + flowCtx;
 }
 async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd, tabManager, runtime2, history) {
   const lowerQuery = query.toLowerCase().trim();
@@ -13358,81 +15712,49 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
       const pageContent = await extractContent(activeWebContents);
       const pageType = detectPageType(pageContent);
       const defaultReadMode = chooseAgentReadMode(pageContent);
-      const structuredContext = buildScopedContext(
+      if (provider.agentToolProfile === "compact") {
+        runtime2.ensureTaskTracker(query, pageContent.url || activeWebContents.getURL());
+      } else {
+        runtime2.clearTaskTracker();
+      }
+      const structuredContext = provider.agentToolProfile === "compact" ? buildCompactScopedContext(
         pageContent,
-        defaultReadMode
-      );
+        defaultReadMode,
+        pageType
+      ) : buildScopedContext(pageContent, defaultReadMode);
       const runtimeState = runtime2.getState();
       const recentCheckpoints = runtimeState.checkpoints.slice(-3).map((item) => `- ${item.name} (${item.id})`).join("\n");
+      const taskTrackerContext = runtime2.getTaskTrackerContext();
       const activeTabTitle = pageContent.title || "(untitled)";
       const activeTabUrl = pageContent.url || activeWebContents.getURL();
       const allTabs = tabManager.getAllStates();
       const activeTabId = tabManager.getActiveTabId();
       const tabSummary = allTabs.length > 1 ? `
 All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.title || "New Tab"} (${t.url})`).join(" | ")}` : "";
-      const systemPrompt = `You are Vessel, an AI agent embedded in a web browser. You can see the current page and interact with it using tools.
-
-THE USER IS CURRENTLY LOOKING AT:
-  Title: ${activeTabTitle}
-  URL: ${activeTabUrl}${tabSummary}
-
-When the user says "this page", "this article", "this site", or asks about what they're viewing, they mean the page above. The context below is from that page — answer directly without needing to call read_page or current_tab first.
-
-Current page context:
-This brief is intentionally minimal and filtered for speed. It omits most page text and low-value chrome unless you explicitly ask for more.
-Default brief mode: ${defaultReadMode}
-Detected page type: ${pageType}
-
-${structuredContext}
-
-Supervisor state:
-- paused: ${runtimeState.supervisor.paused ? "yes" : "no"}
-- approval mode: ${runtimeState.supervisor.approvalMode}
-- pending approvals: ${runtimeState.supervisor.pendingApprovals.length}
-
-Recent checkpoints:
-${recentCheckpoints || "- none"}
-
-Instructions:
-- You can see the page the user is viewing. The content above is from the page.
-- The structured page context always refers to the tab currently visible to the human unless a later tool call changes tabs.
-- Use tools to interact with the page when asked to do something (navigate, click, type, select options, submit forms, press keys, scroll).
-- Only say you completed an action after the corresponding tool succeeds. If no tool supports the request, say so plainly.
-- Use current_tab when you only need to know what the human is currently looking at. Use list_tabs before switching context across multiple tabs.
-- Create a checkpoint before risky multi-step flows or before leaving an important state.
-- Use save_session after completing a login flow you may need again later, and load_session to resume that authenticated state in future runs.
-- 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. Instead, act on what you already know: use the search tool to search the site, type_text to enter queries in search bars, or click on known navigation patterns. You know what major sites look like — use that knowledge. Only call read_page if you're genuinely stuck and need to discover unfamiliar page structure.
-- On retail and marketplace sites (like Newegg, Amazon, Walmart, Etsy, eBay), prefer the site's visible search box, filters, and result pages over direct product URLs. Only navigate directly to a product page if the user gave you that URL or the site's own search UI is clearly unavailable after a reasonable attempt.
-- The page brief you start with is intentionally sparse. It is optimized for navigation speed, not completeness.
-- When you only need detail on one product/result/card/form section, use inspect_element instead of reading the page.
-- Escalate page reads progressively: read_page(mode="glance") for a fast viewport snapshot on heavy/slow pages, then read_page(mode="visible_only"), read_page(mode="results_only"), read_page(mode="forms_only"), read_page(mode="summary"), or read_page(mode="text_only") depending on what you need.
-- Use read_page(mode="glance") when a page is slow to load or extraction times out — it shows what's on screen (headings, links, buttons, inputs) without waiting for heavy JS. It's what a human would see by just looking at the page.
-- Use read_page(mode="debug") only as a last resort when the narrower modes are insufficient.
-- If read_page returns empty or times out, do NOT retry with the same mode. Switch to read_page(mode="glance") or use screenshot to see the page visually.
-- Use screenshot when you need to see exactly what the user sees — visual layout, rendered content, images, or when text extraction is failing. The screenshot returns the actual rendered page image for visual analysis. It works even when the JS thread is completely blocked.
-- VIEWPORT SYNC: Treat scrolling as a real, user-visible browser action. If you say you are going to scroll, call scroll or scroll_to_element so the human sees the page move too.
-- read_page inspects the page without moving the human-visible viewport. Do not describe read_page as scrolling. If you want more context without changing the user's view, say you're reading the page; if you want the user to follow along lower on the page, actually scroll first.
-- After clicking or submitting a form, prefer wait_for on a specific result signal or a narrow read_page mode. Do not jump straight to read_page(mode="debug").
-- If the user says they highlighted or selected text, use read_page before falling back to screenshots because it includes active selection and visible unsaved highlights.
-- If a page behaves abnormally or key UI fails to load, consider disabling ad blocking for that tab and reloading before retrying.
-- For broad discovery tasks, prefer direct sources, official sites, venue directories, and site-specific search over generic search engines, which often rate-limit automated browser traffic.
-- If the page context reports a rate limit, human verification, or access warning, stop using that page and switch to a different source.
-- Reference interactive elements by their index number (shown as [#N] in the listings above).
-- Be concise. Explain what you're doing as you go.
-- For simple questions about the page, just answer directly without using tools.
-- VISUAL AWARENESS: The human is watching the browser alongside this chat. Highlights are your pointing finger — they show the user exactly what you're looking at on the page. Use them proactively: highlight key findings, important elements, errors, or anything you're referencing. Don't wait to be asked. If you mention something specific on the page, highlight it. Colors: yellow (default/attention), red (errors/warnings), green (success/good), blue (info/neutral), purple (important/notable), orange (caution). Clear highlights when moving to a new topic or page.
-- After completing a task or answering a question, offer 1-2 brief, natural follow-up suggestions that make sense in context (e.g. "Want me to highlight any of these?" or "I can save these to a bookmark folder if you'd like"). Keep suggestions short and conversational — don't list every possible action.
-- Call one tool at a time unless you are certain your provider supports parallel tool calls. Sequential calls are more reliable.
-- MINIMIZE TOOL CALLS: Every tool call takes time and costs a round trip. Be efficient. Don't use flow_start/flow_advance for simple multi-step tasks — just do the work. Don't call read_page after navigating — use search or type_text directly. Don't retry failed tools with slight variations — if search fails, go straight to type_text + press_key Enter, don't try read_page in between. The fastest path is usually: navigate → search → wait_for or read_page(mode="results_only") → click.
-- ACT, DON'T HEDGE: You have a full browser — you can navigate to any website, see live content, search, click, add to cart, fill forms, and interact with real pages in real time. Never claim you "don't have access" to a website's inventory, pricing, or content. If the user asks you to go somewhere and do something, start doing it immediately. Don't ask for permission to do what the user just asked you to do — that's redundant and frustrating. Jump straight into action.
-- USE YOUR KNOWLEDGE: You have broad, practical knowledge about technology, products, cooking, travel, finance, and countless other domains. When the user asks for recommendations, GIVE them — don't deflect to Reddit, YouTubers, or other sources. You know enough to recommend PC parts, suggest restaurants, pick a good laptop, or advise on most consumer decisions. Make a clear recommendation, explain your reasoning briefly, and then execute. If there's genuine ambiguity (e.g. AMD vs Intel is preference-dependent), state your pick and why, then ask only the questions that would actually change your recommendation. Never refuse a recommendation by claiming you're "not an expert" — the user chose to ask you, so help them.
-- NEVER USE EMOJIS unless the user uses them first.`;
-      const actionCtx = { tabManager, runtime: runtime2 };
+      const systemPrompt = buildAgentSystemPrompt({
+        profile: provider.agentToolProfile,
+        activeTabTitle,
+        activeTabUrl,
+        tabSummary,
+        defaultReadMode,
+        pageType,
+        structuredContext,
+        supervisorPaused: runtimeState.supervisor.paused,
+        approvalMode: runtimeState.supervisor.approvalMode,
+        pendingApprovals: runtimeState.supervisor.pendingApprovals.length,
+        recentCheckpoints: recentCheckpoints || "- none",
+        taskTrackerContext: taskTrackerContext || "- none"
+      });
+      const actionCtx = {
+        tabManager,
+        runtime: runtime2,
+        toolProfile: provider.agentToolProfile
+      };
       const contextualTools = pruneToolsForContext(
         AGENT_TOOLS,
         pageType,
-        query
+        query,
+        { profile: provider.agentToolProfile }
       );
       const trace = createTraceSession(query, activeTabUrl, activeTabTitle);
       let accumulatedResponse = "";
@@ -13450,6 +15772,14 @@ Instructions:
         let isError = false;
         try {
           output = await executeAction(name, args, actionCtx);
+          if (provider.agentToolProfile === "compact") {
+            runtime2.updateTaskTracker(name, output);
+            const trackerCtx = runtime2.getTaskTrackerContext();
+            if (trackerCtx) {
+              output = `${output}
+${trackerCtx}`;
+            }
+          }
         } catch (err) {
           isError = true;
           output = err instanceof Error ? err.message : String(err);
@@ -14719,8 +17049,24 @@ async function clickResolvedSelector(wc, selector) {
     await waitForPotentialNavigation(wc, beforeUrl2);
     const afterUrl2 = wc.getURL();
     if (afterUrl2 !== beforeUrl2) return `${result} -> ${afterUrl2}`;
-    const overlayHint2 = await detectPostClickOverlay(wc);
-    if (!overlayHint2) return result;
+    let overlayHint2 = await detectPostClickOverlay(wc);
+    if (!overlayHint2 && typeof idxLabel === "string" && isAddToCartText(idxLabel)) {
+      await sleep(1200);
+      overlayHint2 = await detectPostClickOverlay(wc);
+    }
+    if (!overlayHint2) {
+      const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
+      if (hrefMatch) {
+        try {
+          await wc.loadURL(hrefMatch[1]);
+          await waitForLoad(wc, 8e3);
+          const hrefUrl = wc.getURL();
+          if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
+        } catch {
+        }
+      }
+      return result;
+    }
     const dialogActions = typeof idxLabel === "string" && isAddToCartText(idxLabel) ? await getCartDialogActions(wc) : null;
     const actionsSuffix = dialogActions ? `
 ${dialogActions}
@@ -14742,9 +17088,11 @@ ${overlayHint2}${actionsSuffix}`;
     const result = await wc.executeJavaScript(`
       (function() {
         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 || !document.contains(el)) return "Error[stale-index]: Shadow DOM element not found — call read_page to refresh.";
         if (el instanceof HTMLElement) { el.focus(); el.click(); }
-        return "Clicked: " + (el.getAttribute("aria-label") || el.textContent?.trim().slice(0, 60) || el.tagName.toLowerCase());
+        var anchor = el instanceof HTMLAnchorElement ? el : el.closest('a[href]');
+        var href = anchor instanceof HTMLAnchorElement ? anchor.href : null;
+        return "Clicked: " + (el.getAttribute("aria-label") || el.textContent?.trim().slice(0, 60) || el.tagName.toLowerCase()) + (href ? "\\nhref: " + href : "");
       })()
     `);
     if (typeof result === "string" && result.startsWith("Error")) return result;
@@ -14754,14 +17102,30 @@ ${overlayHint2}${actionsSuffix}`;
     await waitForPotentialNavigation(wc, beforeUrl2);
     const afterUrl2 = wc.getURL();
     if (afterUrl2 !== beforeUrl2) return `${result} -> ${afterUrl2}`;
-    const overlayHint2 = await detectPostClickOverlay(wc);
-    if (!overlayHint2) return result;
-    const dialogActions = typeof shadowLabel === "string" && isAddToCartText(shadowLabel) ? await getCartDialogActions(wc) : null;
-    const actionsSuffix = dialogActions ? `
-${dialogActions}
+    let overlayHint2 = await detectPostClickOverlay(wc);
+    if (!overlayHint2 && typeof shadowLabel === "string" && isAddToCartText(shadowLabel)) {
+      await sleep(1200);
+      overlayHint2 = await detectPostClickOverlay(wc);
+    }
+    if (!overlayHint2) {
+      const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
+      if (hrefMatch) {
+        try {
+          await wc.loadURL(hrefMatch[1]);
+          await waitForLoad(wc, 8e3);
+          const hrefUrl = wc.getURL();
+          if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
+        } catch {
+        }
+      }
+      return result;
+    }
+    const dialogActions2 = typeof shadowLabel === "string" && isAddToCartText(shadowLabel) ? await getCartDialogActions(wc) : null;
+    const actionsSuffix2 = dialogActions2 ? `
+${dialogActions2}
 Click one of these dialog actions. Do NOT click any other element.` : "";
     return `${result}
-${overlayHint2}${actionsSuffix}`;
+${overlayHint2}${actionsSuffix2}`;
   }
   const beforeUrl = wc.getURL();
   const elInfo = await describeElementForClick(wc, selector);
@@ -14805,6 +17169,16 @@ Click one of these dialog actions. Do NOT click any other element.` : "";
 ${overlayHint}${actionsSuffix}`;
   }
   if (cartMatch) {
+    await sleep(1200);
+    const delayedOverlayHint = await detectPostClickOverlay(wc);
+    if (delayedOverlayHint) {
+      const dialogActions = await getCartDialogActions(wc);
+      const actionsSuffix = dialogActions ? `
+${dialogActions}
+Click one of these dialog actions. Do NOT click any other element.` : "";
+      return `${clickText} (${clickResult})
+${delayedOverlayHint}${actionsSuffix}`;
+    }
     return `${clickText} (${clickResult})`;
   }
   const activationResult = await activateElement(wc, selector);
@@ -19730,8 +22104,9 @@ function registerIpcHandlers(windowState, runtime2) {
       if (!config || typeof config !== "object" || !("id" in config)) {
         return { ok: false, models: [], error: "Invalid provider configuration" };
       }
-      const models = await fetchProviderModels(config);
-      return { ok: true, models };
+      return await fetchProviderModels(
+        config
+      );
     } catch (err) {
       return { ok: false, models: [], error: err instanceof Error ? err.message : "Unknown error" };
     }
@@ -20140,6 +22515,353 @@ function registerIpcHandlers(windowState, runtime2) {
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
 }
+function makeStep(label, status = "pending") {
+  return { label, status };
+}
+function extractRequestedCount(goal) {
+  const digitMatch = goal.match(/\b(\d+)\b/);
+  if (digitMatch) return Number(digitMatch[1]);
+  const wordMap = {
+    one: 1,
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10
+  };
+  for (const [word, count] of Object.entries(wordMap)) {
+    if (new RegExp(`\\b${word}\\b`, "i").test(goal)) return count;
+  }
+  return null;
+}
+function buildInitialSteps(goal) {
+  const lowered = goal.toLowerCase();
+  const requestedCount = extractRequestedCount(goal);
+  const itemLabel = /\b(book|books)\b/.test(lowered) ? "books" : "items";
+  const countLabel = requestedCount ? `${requestedCount} ${itemLabel}` : itemLabel;
+  const steps = [
+    makeStep("Navigate to the requested site", "active")
+  ];
+  if (/\b(find|browse|look|discover|select|recommend|interesting)\b/.test(lowered)) {
+    steps.push(makeStep(`Browse or search for relevant ${itemLabel}`));
+  }
+  steps.push(makeStep(`Pick the requested ${countLabel}`));
+  if (/\b(cart|checkout|bag)\b/.test(lowered)) {
+    steps.push(makeStep(`Add the chosen ${itemLabel} to the cart`));
+  }
+  if (/\b(explain|reason|why)\b/.test(lowered)) {
+    steps.push(makeStep("Explain the recommendations"));
+  }
+  return steps;
+}
+function setActiveStep(steps, currentStepIndex) {
+  return steps.map((step, index) => {
+    if (step.status === "done" || step.status === "failed") return step;
+    return {
+      ...step,
+      status: index === currentStepIndex ? "active" : "pending"
+    };
+  });
+}
+function completeStep(state2, detail) {
+  const steps = state2.steps.map((step) => ({ ...step }));
+  const current = steps[state2.currentStepIndex];
+  if (current) {
+    current.status = "done";
+    current.detail = detail || current.detail;
+  }
+  const nextIndex = Math.min(state2.currentStepIndex + 1, steps.length - 1);
+  const normalizedSteps = setActiveStep(
+    steps,
+    current ? nextIndex : state2.currentStepIndex
+  );
+  return {
+    ...state2,
+    steps: normalizedSteps,
+    currentStepIndex: current ? nextIndex : state2.currentStepIndex,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setNextHint(state2, nextHint) {
+  return {
+    ...state2,
+    nextHint,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeResult(result) {
+  return result.toLowerCase();
+}
+function looksLikeListingResult(result) {
+  const lowered = normalizeResult(result);
+  return lowered.includes("### primary results") || lowered.includes("### likely search results") || lowered.includes("[read_page mode=results_only]");
+}
+function countSurfacedResults(result) {
+  const matches = result.match(/^\s*-\s+\[#\d+\]/gm);
+  return matches?.length ?? 0;
+}
+function looksLikeSearchResultsPage(result) {
+  const lowered = normalizeResult(result);
+  return lowered.includes("/searchresults") || lowered.includes("/books/search") || lowered.includes("search results") || lowered.includes("bestsellers") || lowered.includes("best sellers");
+}
+function looksLikeProductDetailResult(result) {
+  const lowered = normalizeResult(result);
+  return lowered.includes("### visible purchase controls") || /\badd(?: item)? to (?:cart|bag|basket)\b/.test(lowered) || lowered.includes("buy now") || /https?:\/\/[^\s)]+\/book\//i.test(result);
+}
+function looksLikeCartConfirmation(result) {
+  return /(added to cart|cart confirmation|view cart|continue shopping|shopping cart|checkout)/.test(
+    normalizeResult(result)
+  );
+}
+function looksLikeCartPage(result) {
+  const lowered = normalizeResult(result);
+  return /\*\*url:\*\*\s*https?:\/\/[^\s]+\/cart\b/.test(lowered) || /\b(?:navigated to|went back to|went forward to)\s+https?:\/\/[^\s]+\/cart\b/.test(
+    lowered
+  ) || /\*\*title:\*\*.*\b(cart|checkout)\b/.test(lowered) || /\b(shopping cart|cart subtotal|cart total)\b/.test(lowered);
+}
+function looksLikeStaleElementError(result) {
+  const lowered = normalizeResult(result);
+  return lowered.includes("error[stale-index]") || lowered.includes("element not found — the page may have changed") || lowered.includes("shadow dom element not found") || lowered.includes("call read_page to refresh") || lowered.includes("cannot locate the elements to click") || lowered.includes("page structure is not being reliably captured");
+}
+function extractStructuredUrl(result) {
+  return result.match(/\*\*url:\*\*\s*([^\n]+)/i)?.[1]?.trim() ?? extractNavigatedUrl(result);
+}
+function isAddToCartSuccess(actionName, result) {
+  const lowered = normalizeResult(result);
+  if (actionName !== "click") return false;
+  if (lowered.startsWith("blocked:")) return false;
+  const clickedAddToCart = /clicked:.*add(?: item)? to (?:cart|bag|basket)/.test(lowered);
+  return clickedAddToCart && looksLikeCartConfirmation(result);
+}
+function extractNavigatedUrl(result) {
+  return result.match(
+    /\b(?:navigated to|went back to|went forward to|searched "[^"]+"(?: \(via search button\))? →)\s+([^\s\n]+)/i
+  )?.[1]?.trim() ?? null;
+}
+function stepIndexMatching(steps, pattern) {
+  return steps.findIndex((step) => pattern.test(step.label.toLowerCase()));
+}
+function finalizeShoppingTracker(state2, detail) {
+  const steps = state2.steps.map((step) => ({ ...step }));
+  const pickIndex = stepIndexMatching(steps, /^pick the requested/);
+  const cartIndex = stepIndexMatching(steps, /^add the chosen .* to the cart$/);
+  const explainIndex = stepIndexMatching(steps, /^explain the recommendations$/);
+  if (pickIndex >= 0) {
+    steps[pickIndex] = {
+      ...steps[pickIndex],
+      status: "done",
+      detail
+    };
+  }
+  if (cartIndex >= 0) {
+    steps[cartIndex] = {
+      ...steps[cartIndex],
+      status: "done",
+      detail
+    };
+  }
+  const activeIndex = explainIndex >= 0 ? explainIndex : state2.currentStepIndex;
+  return {
+    ...state2,
+    steps: setActiveStep(steps, activeIndex),
+    currentStepIndex: activeIndex,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createTaskTracker(goal, startUrl) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    goal,
+    startedAt: now,
+    updatedAt: now,
+    startUrl,
+    currentStepIndex: 0,
+    steps: buildInitialSteps(goal),
+    lastAction: void 0,
+    nextHint: "Use the site's search box or a strong curated section immediately. Avoid rereading the homepage unless search or navigation is hidden."
+  };
+}
+function updateTaskTracker(state2, actionName, result) {
+  const requestedCount = state2.requestedCount ?? extractRequestedCount(state2.goal) ?? null;
+  let cartCount = state2.cartCount ?? 0;
+  const cartVisible = state2.cartVisible || looksLikeCartPage(result);
+  let nextState = {
+    ...state2,
+    lastAction: actionName,
+    requestedCount,
+    cartCount,
+    cartVisible,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const currentLabel = nextState.steps[nextState.currentStepIndex]?.label.toLowerCase() ?? "";
+  if (actionName === "navigate") {
+    if (/navigate to the requested site/.test(currentLabel)) {
+      nextState = completeStep(nextState, "Reached the requested site.");
+      return setNextHint(
+        nextState,
+        "Use the site's search box or a curated section to expose product results you can click directly. Avoid a full-page read unless the path is unclear."
+      );
+    }
+    const navigatedUrl = extractNavigatedUrl(result) || "";
+    if (/pick the requested/.test(currentLabel)) {
+      if (/\/book\//i.test(navigatedUrl)) {
+        return setNextHint(
+          nextState,
+          "You opened a chosen product detail page. Do not restart search. Click Add to Cart here, then wait for cart confirmation before moving on."
+        );
+      }
+      if (looksLikeSearchResultsPage(result)) {
+        return setNextHint(
+          nextState,
+          "You are back on a results page while the chosen items are already decided. Do not restart search or browse new categories. Open one of the chosen result links and continue the add-to-cart flow."
+        );
+      }
+    }
+    if (/add the chosen .* to the cart/.test(currentLabel)) {
+      if (/\/book\//i.test(navigatedUrl)) {
+        return setNextHint(
+          nextState,
+          "Stay on this product detail page and add the current chosen item to the cart. Do not go back to search unless this specific cart step fails."
+        );
+      }
+      if (looksLikeSearchResultsPage(result)) {
+        return setNextHint(
+          nextState,
+          "The chosen items are already decided. Do not restart the search flow here. Open the next chosen result from the current page and add it to the cart."
+        );
+      }
+    }
+  }
+  const isDiscoveryAction = [
+    "read_page",
+    "search",
+    "click",
+    "inspect_element",
+    "scroll"
+  ].includes(actionName);
+  if (isDiscoveryAction && /browse or search/.test(currentLabel)) {
+    const surfacedResults = countSurfacedResults(result);
+    nextState = completeStep(nextState, "Found a starting point on the site.");
+    return setNextHint(
+      nextState,
+      looksLikeListingResult(result) ? surfacedResults === 1 ? "One likely result is visible. Inspect or click that result before deciding there is no match. Do not skip to a new search yet." : "Product results are already visible. Open exactly one unseen result now, add that item before choosing another, and do not click multiple results in a row from the same listing page." : looksLikeSearchResultsPage(result) ? 'You are on a results page. Call read_page(mode="results_only") now to surface product results. Do not use visible_only or generic inspect_element to hunt result links.' : "Expose product results you can click directly, then inspect individual items until you have the full set."
+    );
+  }
+  if (/pick the requested/.test(currentLabel) && isDiscoveryAction) {
+    if (isAddToCartSuccess(actionName, result)) {
+      cartCount += 1;
+      nextState = {
+        ...nextState,
+        cartCount
+      };
+      if (requestedCount && cartCount >= requestedCount) {
+        nextState = finalizeShoppingTracker(
+          nextState,
+          `Added ${cartCount} of ${requestedCount} requested items to the cart.`
+        );
+        return setNextHint(
+          nextState,
+          cartVisible ? "All requested items are now in the cart and the cart is visible. Explain your reasoning in chat now and stop using tools." : "All requested items are now in the cart. Open the cart so the user can see it, then explain your reasoning in chat and stop using tools."
+        );
+      }
+      return setNextHint(
+        nextState,
+        requestedCount ? `${cartCount} of ${requestedCount} requested items are now in the cart. If the cart confirmation dialog is open, click Continue Shopping there. Do not click View Cart or Go to Basket until all requested items are added. Only use go_back if no dialog action is available. Then open the next unseen result.` : "This item is now in the cart. If the cart confirmation dialog is open, click Continue Shopping there. Do not click View Cart or Go to Basket yet. Only use go_back if no dialog action is available. Then open the next unseen result."
+      );
+    }
+    if (looksLikeCartConfirmation(result)) {
+      return setNextHint(
+        nextState,
+        "This item is already in the cart. If the cart confirmation dialog is still open, click Continue Shopping there. Do not click View Cart or Go to Basket yet. Only use go_back if no dialog action is available. Then open the next unseen result."
+      );
+    }
+    const structuredUrl = extractStructuredUrl(result) || "";
+    if (actionName === "read_page" && cartCount > 0 && /\/book\//i.test(structuredUrl) && looksLikeProductDetailResult(result)) {
+      return setNextHint(
+        nextState,
+        "This detail page may already be for an item you just added. Do not click Add to Cart again on the same page. If the cart confirmation dialog is still open, click Continue Shopping there. Otherwise go back once and open the next chosen result. Do not click View Cart or Go to Basket yet."
+      );
+    }
+    if (looksLikeProductDetailResult(result)) {
+      return setNextHint(
+        nextState,
+        'You are on a product detail page. Opening this page did not add the item to the cart. Click Add to Cart now, then wait for cart confirmation before moving on. Use read_page(mode="visible_only") once only if you need the Add to Cart index.'
+      );
+    }
+    if (looksLikeSearchResultsPage(result) && !looksLikeListingResult(result)) {
+      return setNextHint(
+        nextState,
+        'This is still a results page. Call read_page(mode="results_only") now and click a surfaced result. Do not loop on visible_only or generic inspect_element here.'
+      );
+    }
+    if (looksLikeListingResult(result)) {
+      const surfacedResults = countSurfacedResults(result);
+      return setNextHint(
+        nextState,
+        surfacedResults === 1 ? "There is one likely result visible. Inspect or click that result before declaring no match or moving to a different query." : "A product listing is already visible. Open exactly one unseen result now, add that item to the cart from its detail page, then return for the next result. Do not click multiple remembered results in a row from the listing page."
+      );
+    }
+    if (actionName === "click" && looksLikeStaleElementError(result)) {
+      return setNextHint(
+        nextState,
+        "The last remembered click target is stale. Trust the latest page state, not older labels or indexes. Call read_page once on the current page. If you are on a detail page, add the current item now. If you are still on a listing page, open exactly one visible unseen result. Do not click multiple saved results in sequence."
+      );
+    }
+    return setNextHint(
+      nextState,
+      "Pick one promising unseen item at a time. As soon as a detail page opens, add that item to the cart before selecting another result."
+    );
+  }
+  if (/pick the requested/.test(currentLabel) && actionName === "go_back") {
+    return setNextHint(
+      nextState,
+      "You are back on the listing flow. Open exactly one next chosen or unseen result now instead of rereading the whole page, restarting search, or clicking multiple results in sequence."
+    );
+  }
+  if (/add the chosen .* to the cart/.test(currentLabel) && isAddToCartSuccess(actionName, result)) {
+    cartCount += 1;
+    nextState = {
+      ...nextState,
+      cartCount
+    };
+    const detail = requestedCount ? `Added ${cartCount} of ${requestedCount} requested items to the cart.` : "Cart interaction succeeded.";
+    nextState = completeStep(nextState, detail);
+    return setNextHint(
+      nextState,
+      requestedCount && cartCount >= requestedCount ? cartVisible ? "All requested books are now in the cart and the cart is visible. Explain your reasoning in chat now and stop using tools." : "All requested books are now in the cart. Open the cart so the user can see it, then explain your reasoning in chat and stop using tools." : requestedCount ? `${cartCount} of ${requestedCount} requested books are now in the cart. Continue adding the remaining selected books.` : "Summarize the chosen books and explain why they were recommended."
+    );
+  }
+  if (/explain the recommendations/.test(currentLabel)) {
+    return setNextHint(
+      nextState,
+      cartVisible ? "The cart is visible. Explain your reasoning in chat now, mention the chosen books, and stop using tools." : "Finish by naming the chosen books and giving concise reasons for each. If the cart is not visible yet, show it first."
+    );
+  }
+  return nextState;
+}
+function formatTaskTracker(state2) {
+  if (!state2) return "";
+  const completed = state2.steps.filter((step) => step.status === "done").map((step) => step.label);
+  const current = state2.steps[state2.currentStepIndex]?.label ?? "Task in progress";
+  const remaining = state2.steps.filter((step, index) => step.status !== "done" && index !== state2.currentStepIndex).map((step) => step.label);
+  const lines = [
+    "--- Task Tracker ---",
+    `Goal: ${state2.goal}`,
+    `Completed: ${completed.length > 0 ? completed.join("; ") : "none yet"}`,
+    `Current: ${current}`,
+    `Remaining: ${remaining.length > 0 ? remaining.join("; ") : "wrap up the response"}`
+  ];
+  if (state2.nextHint) {
+    lines.push(`Next: ${state2.nextHint}`);
+  }
+  return `
+${lines.join("\n")}
+---`;
+}
 const MAX_TRANSCRIPT_TEXT_LENGTH = 8e3;
 const PERSIST_DEBOUNCE_MS = 500;
 function clone(value) {
@@ -20175,7 +22897,8 @@ function sanitizePersistence(persisted) {
     checkpoints: Array.isArray(persisted?.checkpoints) ? persisted.checkpoints.slice(-20) : [],
     transcript: [],
     mcpStatus: "stopped",
-    flowState: null
+    flowState: null,
+    taskTracker: null
   };
 }
 class AgentRuntime {
@@ -20294,6 +23017,32 @@ class AgentRuntime {
     this.emit();
     return this.getState();
   }
+  ensureTaskTracker(goal, startUrl) {
+    const trimmedGoal = goal.trim();
+    if (this.state.taskTracker && this.state.taskTracker.goal.trim() === trimmedGoal) {
+      return clone(this.state.taskTracker);
+    }
+    this.state.taskTracker = createTaskTracker(trimmedGoal, startUrl);
+    this.emit();
+    return clone(this.state.taskTracker);
+  }
+  updateTaskTracker(actionName, result) {
+    if (!this.state.taskTracker) return null;
+    this.state.taskTracker = updateTaskTracker(
+      this.state.taskTracker,
+      actionName,
+      result
+    );
+    this.emit();
+    return clone(this.state.taskTracker);
+  }
+  clearTaskTracker() {
+    this.state.taskTracker = null;
+    this.emit();
+  }
+  getTaskTrackerContext() {
+    return formatTaskTracker(this.state.taskTracker);
+  }
   // --- Speedee Flow State ---
   startFlow(goal, steps, startUrl) {
     const flow = {