@quanta-intellect/vessel-browser 0.1.35 → 0.1.45

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,215 +5126,6 @@ function makeImageResult(base64, description, mediaType = "image/png") {
   };
   return JSON.stringify(result);
 }
-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;
-      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",
@@ -5384,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",
@@ -5465,7 +5266,7 @@ function isLoopbackBaseUrl(baseUrl) {
 }
 function resolveAgentToolProfile(config) {
   const providerId = config.id;
-  const isLocalProvider = providerId === "ollama" || providerId === "custom" && isLoopbackBaseUrl(config.baseUrl);
+  const isLocalProvider = providerId === "ollama" || providerId === "llama_cpp" || providerId === "custom" && isLoopbackBaseUrl(config.baseUrl);
   if (!isLocalProvider) return "default";
   const sizeInBillions = parseModelSizeInBillions(config.model);
   if (sizeInBillions === null) {
@@ -5473,6 +5274,8 @@ function resolveAgentToolProfile(config) {
   }
   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";
@@ -5503,8 +5306,8 @@ function followUpReminderForProfile(profile, userMessage, assistantText, latestT
   const phaseReminder = buildPhaseReminder(userMessage, assistantText || "");
   const stateReminder = buildLatestStateReminder(latestToolResultPreview || "");
   return {
-    role: "system",
-    content: `Task reminder: Continue working on the user's original request until it is completed: ${userMessage}
+    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}` : "")
@@ -5545,6 +5348,9 @@ function buildPhaseReminder(userMessage, assistantText) {
   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);
@@ -5552,8 +5358,59 @@ function buildPhaseReminder(userMessage, assistantText) {
     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|no visible area|not visible/.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.`;
+    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.`;
@@ -5592,6 +5449,30 @@ function shouldRecoverCompactStall(text, userMessage) {
   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",
@@ -5645,6 +5526,17 @@ function stableToolSignature(name, args) {
 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, "_");
 }
@@ -5663,11 +5555,91 @@ function canonicalizeUrlLike(value) {
   }
   return value.trim();
 }
-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()) {
+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();
@@ -5813,12 +5785,49 @@ function recoverNarratedActionToolCalls(text, availableToolNames) {
       });
     }
   }
+  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];
@@ -5827,6 +5836,7 @@ class OpenAICompatProvider {
       apiKey: config.apiKey || "ollama",
       baseURL
     });
+    this.providerId = config.id;
     this.model = config.model || meta?.defaultModel || "gpt-4o";
     this.agentToolProfile = resolveAgentToolProfile(config);
   }
@@ -5841,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;
@@ -5878,6 +5897,8 @@ class OpenAICompatProvider {
       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 = "";
@@ -5892,6 +5913,7 @@ class OpenAICompatProvider {
         const stream = await this.client.chat.completions.create(
           {
             model: this.model,
+            max_tokens: 4096,
             stream: true,
             messages,
             tools: openAITools,
@@ -5905,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);
@@ -5925,10 +5951,12 @@ class OpenAICompatProvider {
         for (const tc of Object.values(toolCallAccums)) {
           if (!tc.id) tc.id = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           let parsedArgs = {};
-          try {
-            parsedArgs = JSON.parse(tc.argsJson || "{}");
-          } catch {
-            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);
         }
@@ -5967,11 +5995,14 @@ class OpenAICompatProvider {
         });
         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 = {
@@ -5995,12 +6026,12 @@ class OpenAICompatProvider {
           )) {
             compactRecoveryCount += 1;
             messages.push({
-              role: "system",
-              content: buildCompactRecoveryPrompt(
+              role: "user",
+              content: `[System] ${buildCompactRecoveryPrompt(
                 userMessage,
                 textAccum,
                 latestToolMessage ? String(latestToolMessage.content || "") : null
-              )
+              )}`
             });
             continue;
           }
@@ -6021,9 +6052,8 @@ class OpenAICompatProvider {
             continue;
           }
           let args = {};
-          try {
-            args = JSON.parse(tc.argsJson || "{}");
-          } catch {
+          const repairedArgs = parseToolArgsWithRepair(tc.name, tc.argsJson || "{}");
+          if (!repairedArgs) {
             onChunk(`
 <<tool:${tc.name}:⚠ invalid args>>
 `);
@@ -6034,6 +6064,7 @@ class OpenAICompatProvider {
             });
             continue;
           }
+          args = repairedArgs.args;
           args = coerceToolArgsForExecution(tc.name, args);
           if (!availableToolNames.has(tc.name)) {
             onChunk(`
@@ -6047,14 +6078,23 @@ class OpenAICompatProvider {
             compactCorrectionCount += 1;
             if (compactCorrectionCount >= 2) {
               messages.push({
-                role: "system",
-                content: `You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
+                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);
-          if (this.agentToolProfile === "compact" && hasRecentDuplicateToolCall(
+          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
           )) {
@@ -6069,8 +6109,8 @@ class OpenAICompatProvider {
             compactCorrectionCount += 1;
             if (compactCorrectionCount >= 2) {
               messages.push({
-                role: "system",
-                content: `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.`
+                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;
@@ -6100,6 +6140,15 @@ class OpenAICompatProvider {
               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({
@@ -6121,6 +6170,228 @@ class OpenAICompatProvider {
       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:${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
+            });
+          }
+          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: "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.`
+          });
+        }
+      }
+      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) {
@@ -6155,16 +6426,65 @@ function validateProviderConnection(config, options = { requireModel: true }) {
   if (!meta) {
     return "Selected AI provider is not supported.";
   }
-  if (meta.requiresApiKey && !normalized.apiKey) {
-    return `${meta.name} requires an API key. Open settings (Ctrl+,) to add one.`;
+  if (meta.requiresApiKey && !normalized.apiKey) {
+    return `${meta.name} requires an API key. Open settings (Ctrl+,) to add one.`;
+  }
+  if (options.requireModel && !normalized.model) {
+    return normalized.id === "custom" ? "Custom provider requires a model name." : `Select a ${meta.name} model in settings.`;
+  }
+  if (normalized.id === "custom" && !normalized.baseUrl) {
+    return "Custom provider requires a base URL.";
+  }
+  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 (options.requireModel && !normalized.model) {
-    return normalized.id === "custom" ? "Custom provider requires a model name." : `Select a ${meta.name} model in settings.`;
+  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.`;
   }
-  if (normalized.id === "custom" && !normalized.baseUrl) {
-    return "Custom provider requires a base URL.";
+  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);
   }
-  return null;
 }
 async function fetchProviderModels(config) {
   const normalized = sanitizeProviderConfig(config);
@@ -6175,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";
@@ -6184,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);
@@ -6241,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) {
@@ -6257,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) {
@@ -6557,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;
@@ -6626,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"
@@ -6679,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")
@@ -7038,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);
@@ -7051,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);
@@ -7060,7 +7451,7 @@ function getUrlPathSegments(value) {
   }
 }
 function isSearchOrListingPage(page) {
-  const haystack = normalizeComparable(
+  const haystack = normalizeComparable$1(
     [
       page.url,
       page.title,
@@ -7100,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;
@@ -7137,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")) {
@@ -7170,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;
@@ -7406,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);
@@ -7461,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})`
@@ -7774,7 +8182,7 @@ const SHARED_READ_INSTRUCTIONS = [
   '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."
+  "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.",
@@ -7789,7 +8197,8 @@ const DEFAULT_EXTRA_INSTRUCTIONS = [
   "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."
+  "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.",
@@ -7799,6 +8208,12 @@ const COMPACT_FOCUS_INSTRUCTIONS = [
   "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.",
+  'On search results pages, always call read_page(mode="results_only") first. Click products by their [#N] index from the Results section. Never click filter or sort links (e.g. Used, New, Format, Price).',
+  "After go_back, always call read_page before clicking. The page may have changed.",
   "Keep your reasoning short. Prefer taking the next tool action over writing a long plan."
 ];
 function buildInstructionBlock(instructions) {
@@ -7849,6 +8264,342 @@ function buildAgentSystemPrompt(input) {
     ...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 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) {
+    lines.push("");
+    lines.push("### Results — click one of these to open a product");
+    lines.push(...primaryResults.map((item) => `- ${item}`));
+    lines.push("");
+    lines.push("IMPORTANT: Use click(index=N) on a result above. Do NOT click filter or sort links.");
+  }
+  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,
+      "### Page Controls (filters, sorts — avoid when selecting products)",
+      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) {
   const trimmed = value.trim();
@@ -7994,10 +8745,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
   },
@@ -8118,10 +8870,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,
@@ -8473,10 +9226,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)"
       )
@@ -9776,6 +10530,351 @@ 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;
+    if (tag === "a") {
+      const href = htmlEl.href || "";
+      const filterParams = /\b(condition|binding|format|availability|sort|filter|price|category_id)\b=[^&]/i;
+      const filterPath = /\/(condition|binding|format|availability|sort|filter|price|category)\/[^/?#]+/i;
+      if (filterParams.test(href) || filterPath.test(href)) {
+        score -= 40;
+      }
+      if (/\b(used|new|paperback|hardcover|hardback|ebook|kindle|refine|clear all|remove filter)\b/.test(label)) {
+        score -= 30;
+      }
+    }
+    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");
@@ -9994,9 +11093,9 @@ function waitForLoad$1(wc, timeout = 5e3) {
       finish();
       return;
     }
-    wc.on("did-finish-load", onLoadEvent);
-    wc.on("did-stop-loading", onLoadEvent);
-    wc.on("did-fail-load", onLoadEvent);
+    wc.once("did-finish-load", onLoadEvent);
+    wc.once("did-stop-loading", onLoadEvent);
+    wc.once("did-fail-load", onLoadEvent);
   });
 }
 function waitForPotentialNavigation$1(wc, beforeUrl, timeout = 2500) {
@@ -10049,8 +11148,8 @@ function waitForPotentialNavigation$1(wc, beforeUrl, timeout = 2500) {
     wc.once("did-start-loading", onStart);
     wc.once("did-navigate", onNavigate);
     wc.once("did-navigate-in-page", onNavigateInPage);
-    wc.on("did-stop-loading", onNativeChange);
-    wc.on("page-title-updated", onNativeChange);
+    wc.once("did-stop-loading", onNativeChange);
+    wc.once("page-title-updated", onNativeChange);
   });
 }
 async function getPostNavSummary(wc) {
@@ -10132,6 +11231,25 @@ ${truncated}`;
 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(
@@ -10231,7 +11349,7 @@ async function clickElement$1(wc, selector) {
 
       const rect = el.getBoundingClientRect();
       if (rect.width <= 0 || rect.height <= 0) {
-        return { error: "Error[hidden]: Element has no visible area" };
+        return { error: "Error[hidden]: Element has no visible area. It may be inside a collapsed, lazy-loaded, or virtual-scroll section. Scroll toward it (scroll or scroll_to_element) then call read_page to refresh visible elements before clicking again." };
       }
 
       const points = samplePoints(rect);
@@ -10324,9 +11442,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,
       };
     })()
   `,
@@ -10345,7 +11471,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) {
@@ -10429,6 +11558,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']"
@@ -10454,19 +11595,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),
@@ -10483,6 +11674,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,
+        })),
       };
     })()
   `,
@@ -10515,10 +11714,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");
 }
@@ -10607,6 +11821,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));
@@ -10628,18 +11847,119 @@ function isDuplicateCartClick(url, 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}`;
+}
+function clearCartState() {
+  cartAddedProducts.clear();
+  recentCartClicks.clear();
+  clickStreakUrl = null;
+  clickStreakCount = 0;
+}
+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"`,
@@ -10649,18 +11969,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() {
@@ -10669,17 +12011,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 : "");
       })()
     `,
       {
@@ -10688,15 +12037,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);
@@ -10719,10 +12089,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);
@@ -10732,15 +12108,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:")) {
@@ -10755,7 +12146,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(
@@ -11561,6 +13010,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() : "";
 }
@@ -13011,8 +14478,61 @@ 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.`;
+      }
+      if (ctx.toolProfile === "compact" && name === "go_back") {
+        warnings += `
+Call read_page(mode="results_only") to see available products before clicking.`;
+      }
+    }
+    if (name === "click" && ctx.toolProfile === "compact") {
+      const filterParams = /\b(condition|binding|format|availability|sort|filter|price|category_id|view)\b=[^&]/i;
+      const filterPath = /\/(condition|binding|format|availability|sort|filter|price|category)\/[^/?#]+/i;
+      if (filterParams.test(currentUrl) || filterPath.test(currentUrl)) {
+        warnings += `
+WARNING: The clicked link appears to be a filter or sort control, not a product. If you intended to click a product, call go_back and use click(index=N) on a result from read_page(mode="results_only").`;
+      }
+    }
     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 `
@@ -13253,14 +14773,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,
@@ -13409,7 +14963,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;
@@ -13421,7 +14976,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}]`,
@@ -14098,9 +15653,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));
@@ -14138,8 +15704,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();
@@ -14150,14 +15744,20 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
       const pageType = detectPageType(pageContent);
       const defaultReadMode = chooseAgentReadMode(pageContent);
       if (provider.agentToolProfile === "compact") {
+        const prevGoal = runtime2.getState().taskTracker?.goal?.trim();
         runtime2.ensureTaskTracker(query, pageContent.url || activeWebContents.getURL());
+        if (prevGoal !== query.trim()) {
+          clearCartState();
+        }
       } else {
         runtime2.clearTaskTracker();
+        clearCartState();
       }
-      const structuredContext = buildScopedContext(
+      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();
@@ -14181,7 +15781,11 @@ All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.ti
         recentCheckpoints: recentCheckpoints || "- none",
         taskTrackerContext: taskTrackerContext || "- none"
       });
-      const actionCtx = { tabManager, runtime: runtime2 };
+      const actionCtx = {
+        tabManager,
+        runtime: runtime2,
+        toolProfile: provider.agentToolProfile
+      };
       const contextualTools = pruneToolsForContext(
         AGENT_TOOLS,
         pageType,
@@ -15370,7 +16974,7 @@ async function clickElement(wc, selector) {
 
       const rect = el.getBoundingClientRect();
       if (rect.width <= 0 || rect.height <= 0) {
-        return { error: "Element is not visible" };
+        return { error: "Element is not visible. It may be inside a collapsed, lazy-loaded, or virtual-scroll section. Scroll toward it (scroll or scroll_to_element) then call read_page to refresh visible elements before clicking again." };
       }
 
       const points = samplePoints(rect);
@@ -15481,8 +17085,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}
@@ -15504,9 +17124,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;
@@ -15516,14 +17138,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);
@@ -15567,6 +17205,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);
@@ -16229,7 +17877,7 @@ async function hoverElement(wc, selector) {
         el.scrollIntoView({ behavior: 'instant', block: 'center', inline: 'center' });
       }
       const rect = el.getBoundingClientRect();
-      if (rect.width <= 0 || rect.height <= 0) return { error: 'Error[hidden]: Element has no visible area' };
+      if (rect.width <= 0 || rect.height <= 0) return { error: 'Error[hidden]: Element has no visible area. It may be inside a collapsed, lazy-loaded, or virtual-scroll section. Scroll toward it then call read_page to refresh visible elements.' };
       el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true }));
       el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: false }));
       const label = (el.textContent || el.tagName || 'Element').trim().slice(0, 80);
@@ -20492,8 +22140,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" };
     }
@@ -20983,6 +22632,82 @@ function setNextHint(state2, nextHint) {
 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 {
@@ -20993,23 +22718,59 @@ function createTaskTracker(goal, startUrl) {
     currentStepIndex: 0,
     steps: buildInitialSteps(goal),
     lastAction: void 0,
-    nextHint: "Open a relevant section or search path and keep working the same request."
+    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 loweredResult = normalizeResult(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") {
-    nextState = completeStep(nextState, "Reached the requested site.");
-    return setNextHint(
-      nextState,
-      "Open a curated section or use the site's book search to find promising titles."
-    );
+    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",
@@ -21019,31 +22780,101 @@ function updateTaskTracker(state2, actionName, result) {
     "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,
-      "Inspect individual books and keep track of the best candidates until you have the full set."
+      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,
-      "Keep selecting candidate books. After you have the requested set, add each one to the cart."
+      "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 (/add the chosen .* to the cart/.test(currentLabel) && /(added to cart|cart confirmation|shopping cart|view cart|checkout)/.test(
-    loweredResult
-  )) {
-    nextState = completeStep(nextState, "Cart interaction succeeded.");
+  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,
-      "Summarize the chosen books and explain why they were recommended."
+      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,
-      "Finish by naming the chosen books and giving concise reasons for each."
+      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;