@quanta-intellect/vessel-browser 0.1.32 → 0.1.35

package/out/main/index.js

@@ -5127,6 +5127,7 @@ function makeImageResult(base64, description, mediaType = "image/png") {
   return JSON.stringify(result);
 }
 class AnthropicProvider {
+  agentToolProfile = "default";
   client;
   model;
   abortController = null;
@@ -5424,6 +5425,66 @@ const PROVIDERS = {
     apiKeyHint: "Optional — only if your endpoint requires authentication"
   }
 };
+const SAFE_TOOL_ALIASES = {
+  goto_url: "navigate",
+  go_to_url: "navigate",
+  browser_goto: "navigate",
+  browser_navigate: "navigate",
+  open_url: "navigate",
+  visit_url: "navigate",
+  navigate_to: "navigate",
+  open_page: "navigate",
+  google_search: "search",
+  site_search: "search",
+  search_site: "search",
+  page_search: "search",
+  scroll_down: "scroll",
+  scroll_up: "scroll",
+  read: "read_page",
+  read_current_page: "read_page",
+  scan_page: "read_page"
+};
+function normalizeToolAlias(name) {
+  const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+  return SAFE_TOOL_ALIASES[normalized] ?? name;
+}
+function parseModelSizeInBillions(model) {
+  const match = model.toLowerCase().match(/(?:^|[:/_\-\s])(\d+(?:\.\d+)?)b(?:$|[:/_\-\s])/i);
+  if (!match) return null;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isLoopbackBaseUrl(baseUrl) {
+  if (!baseUrl) return false;
+  try {
+    const url = new URL(baseUrl);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+function resolveAgentToolProfile(config) {
+  const providerId = config.id;
+  const isLocalProvider = providerId === "ollama" || providerId === "custom" && isLoopbackBaseUrl(config.baseUrl);
+  if (!isLocalProvider) return "default";
+  const sizeInBillions = parseModelSizeInBillions(config.model);
+  if (sizeInBillions === null) {
+    return "compact";
+  }
+  return sizeInBillions <= 14 ? "compact" : "default";
+}
+function shouldDebugAgentLoop() {
+  const value = process.env.VESSEL_DEBUG_AGENT_LOOP;
+  return value === "1" || value === "true";
+}
+function previewDebugValue(value, maxLength = 800) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength)}…`;
+}
+function previewToolDebugContent(content) {
+  return previewDebugValue(content, 500);
+}
 function toOpenAITools(tools) {
   return tools.map((t) => ({
     type: "function",
@@ -5434,7 +5495,328 @@ function toOpenAITools(tools) {
     }
   }));
 }
+function agentTemperatureForProfile(profile) {
+  return profile === "compact" ? 0.2 : void 0;
+}
+function followUpReminderForProfile(profile, userMessage, assistantText, latestToolResultPreview) {
+  if (profile !== "compact") return null;
+  const phaseReminder = buildPhaseReminder(userMessage, assistantText || "");
+  const stateReminder = buildLatestStateReminder(latestToolResultPreview || "");
+  return {
+    role: "system",
+    content: `Task reminder: Continue working on the user's original request until it is completed: ${userMessage}
+Do not ask the user what they want next unless the request is genuinely ambiguous or blocked. After navigation or page reads, keep executing the same task.` + (stateReminder ? `
+${stateReminder}` : "") + (phaseReminder ? `
+${phaseReminder}` : "")
+  };
+}
+function extractSingleGoalDomain(goal) {
+  const matches = goal.toLowerCase().match(/\b(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+\.(?:com|org|net|io|dev|app|ai|co|edu|gov))\b/g);
+  if (!matches || matches.length !== 1) return null;
+  return matches[0].replace(/^https?:\/\//, "").replace(/^www\./, "").toLowerCase();
+}
+function buildCompactRecoveryPrompt(userMessage, assistantText, latestToolResultPreview) {
+  const phaseReminder = buildPhaseReminder(userMessage, assistantText);
+  const stateReminder = buildLatestStateReminder(latestToolResultPreview || "");
+  const goalDomain = extractSingleGoalDomain(userMessage);
+  const latest = (latestToolResultPreview || "").toLowerCase();
+  const assistant = assistantText.toLowerCase();
+  const alreadyOnGoalSite = !!goalDomain && (latest.includes(goalDomain) || assistant.includes(`https://${goalDomain}`) || assistant.includes(`https://www.${goalDomain}`));
+  const lines = [
+    `The task is still in progress: ${userMessage}`,
+    `Do not ask the user for permission to continue. Choose the next tool now unless the request is fully complete.`
+  ];
+  if (alreadyOnGoalSite) {
+    lines.push(
+      `You are already on the requested site (${goalDomain}). Do not navigate to the homepage again and do not restart discovery from scratch.`
+    );
+  }
+  if (stateReminder) {
+    lines.push(stateReminder);
+  }
+  if (phaseReminder) {
+    lines.push(phaseReminder);
+  }
+  return lines.join("\n");
+}
+function buildPhaseReminder(userMessage, assistantText) {
+  const goal = userMessage.toLowerCase();
+  const text = assistantText.toLowerCase();
+  if (!goal || !text) return "";
+  const wantsCart = /\b(cart|bag|basket|checkout)\b/.test(goal);
+  const wantsExplanation = /\b(explain|reason|why)\b/.test(goal);
+  const hasFiveItemList = /(?:^|\n)\s*1\./.test(assistantText) && /(?:^|\n)\s*2\./.test(assistantText) && /(?:^|\n)\s*3\./.test(assistantText) && /(?:^|\n)\s*4\./.test(assistantText) && /(?:^|\n)\s*5\./.test(assistantText);
+  const selectedItems = hasFiveItemList || /i(?:'| a)?ve chosen/.test(text) || /i have chosen/.test(text) || /i selected/.test(text) || /here are the books/i.test(assistantText) || /here are the items/i.test(assistantText);
+  const intendsCart = /next[, ]+i will add/.test(text) || /i(?:'| a)?ll start with the first/.test(text) || /proceed systematically/.test(text) || /add (these|the chosen|the selected).*(cart|bag|basket)/.test(text);
+  const cartDone = /(added to cart|added them to the cart|cart confirmation|view cart|checkout)/.test(
+    text
+  );
+  const explanationDone = /here is why i chose/.test(text) || /here are my reasons/.test(text) || /reason:/.test(text) || /reasons:/.test(text) || /why i chose/.test(text);
+  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.`;
+  }
+  if (wantsCart && wantsExplanation && cartDone && !explanationDone) {
+    return `Progress reminder: The cart step appears complete. Do not resume browsing. Finish by explaining why the chosen items were recommended.`;
+  }
+  return "";
+}
+function buildLatestStateReminder(toolResultPreview) {
+  const text = toolResultPreview.trim();
+  if (!text) return "";
+  const stateMatch = text.match(
+    /\[state:\s+url=([^,\]\n]+),\s+title=(?:"([^"]*)"|([^,\]\n]+))/i
+  );
+  if (stateMatch) {
+    const url = stateMatch[1]?.trim();
+    const title = (stateMatch[2] ?? stateMatch[3] ?? "").trim();
+    if (url) {
+      return `Latest browser state: URL ${url}${title ? `, title "${title}"` : ""}. Trust the latest tool result over the initial page context.`;
+    }
+  }
+  const structuredUrl = text.match(/\*\*URL:\*\*\s*([^\n]+)/i)?.[1]?.trim();
+  const structuredTitle = text.match(/\*\*Title:\*\*\s*([^\n]+)/i)?.[1]?.trim();
+  if (structuredUrl) {
+    return `Latest browser state: URL ${structuredUrl}${structuredTitle ? `, title "${structuredTitle}"` : ""}. Trust the latest tool result over the initial page context.`;
+  }
+  const navigatedUrl = text.match(/\b(?:navigated to|went back to|went forward to|searched "[^"]+"(?: \(via search button\))? →)\s+([^\s\n]+)/i)?.[1]?.trim();
+  const pageTitle = text.match(/\bPage title:\s*([^\n]+)/i)?.[1]?.trim();
+  if (navigatedUrl) {
+    return `Latest browser state: URL ${navigatedUrl}${pageTitle ? `, title "${pageTitle}"` : ""}. Trust the latest tool result over the initial page context.`;
+  }
+  return "";
+}
+function shouldRecoverCompactStall(text, userMessage) {
+  const trimmed = text.trim().toLowerCase();
+  if (!trimmed) return true;
+  if (trimmed.length <= 160 && trimmed.includes("?")) return true;
+  if (userMessage && buildPhaseReminder(userMessage, text)) {
+    return true;
+  }
+  const completionSignals = [
+    "i found",
+    "i chose",
+    "i selected",
+    "i added",
+    "here are",
+    "these are",
+    "recommendations",
+    "reasoning",
+    "why i chose",
+    "added them to the cart"
+  ];
+  if (completionSignals.some((pattern) => trimmed.includes(pattern))) {
+    return false;
+  }
+  return [
+    "what are you hoping",
+    "what would you like",
+    "how can i help",
+    "let me know",
+    "are you looking for",
+    "just browsing",
+    "i need to",
+    "i will",
+    "i'll",
+    "since i cannot see",
+    "since i can't see",
+    "cannot see the current page",
+    "scroll down to",
+    "load more results",
+    "as placeholders",
+    "would you like me to proceed",
+    "action:",
+    "one moment",
+    "i will now navigate",
+    "navigating to ",
+    "this will take me",
+    "i will use the browser"
+  ].some((pattern) => trimmed.includes(pattern));
+}
+function shouldRetryCompactToolLoop(profile, text, hasToolHistory, userMessage) {
+  return profile === "compact" && hasToolHistory && shouldRecoverCompactStall(text, userMessage);
+}
+function stableToolSignature(name, args) {
+  const canonicalArgs = canonicalizeArgsForTool(name, args);
+  const sortedEntries = Object.entries(canonicalArgs).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  return JSON.stringify([name, sortedEntries]);
+}
+function hasRecentDuplicateToolCall(recentToolSignatures, signature) {
+  return recentToolSignatures.includes(signature);
+}
+function normalizeToolToken(value) {
+  return value.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+}
+function canonicalizeUrlLike(value) {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      url.hostname = url.hostname.replace(/^www\./, "");
+      url.hash = "";
+      if (url.pathname.endsWith("/") && url.pathname !== "/") {
+        url.pathname = url.pathname.replace(/\/+$/, "");
+      }
+      return url.toString();
+    }
+  } catch {
+  }
+  return value.trim();
+}
+function coerceToolArgsForExecution(name, args) {
+  const coerced = { ...args };
+  if (name === "search") {
+    if (typeof coerced.query !== "string" || !coerced.query.trim()) {
+      if (typeof coerced.text === "string" && coerced.text.trim()) {
+        coerced.query = coerced.text.trim();
+      } else if (typeof coerced.term === "string" && coerced.term.trim()) {
+        coerced.query = coerced.term.trim();
+      }
+    }
+  }
+  if (name === "navigate") {
+    if (typeof coerced.url !== "string" || !coerced.url.trim()) {
+      if (typeof coerced.href === "string" && coerced.href.trim()) {
+        coerced.url = coerced.href.trim();
+      } else if (typeof coerced.link === "string" && coerced.link.trim()) {
+        coerced.url = coerced.link.trim();
+      } else if (typeof coerced.text === "string" && /^https?:\/\//i.test(coerced.text.trim())) {
+        coerced.url = coerced.text.trim();
+      }
+    }
+  }
+  return coerced;
+}
+function canonicalizeArgsForTool(name, args) {
+  const canonical = coerceToolArgsForExecution(name, args);
+  if (typeof canonical.url === "string") {
+    canonical.url = canonicalizeUrlLike(canonical.url);
+  }
+  if (typeof canonical.query === "string") {
+    canonical.query = canonical.query.trim().replace(/\s+/g, " ").toLowerCase();
+    delete canonical.text;
+  }
+  if (typeof canonical.text === "string") {
+    canonical.text = canonical.text.trim().replace(/\s+/g, " ");
+  }
+  return canonical;
+}
+function resolveToolCallName(rawName, args, availableToolNames) {
+  const aliased = normalizeToolAlias(rawName);
+  if (availableToolNames.has(aliased)) return aliased;
+  const normalized = normalizeToolToken(rawName);
+  if (availableToolNames.has(normalized)) return normalized;
+  const hasUrl = typeof args.url === "string" && args.url.trim().length > 0;
+  if (availableToolNames.has("navigate") && (hasUrl || /goto|navigate|open|visit|browser|url|link/.test(normalized))) {
+    return "navigate";
+  }
+  if (availableToolNames.has("search") && (/search|find|lookup|query/.test(normalized) || normalized === "google" || normalized.startsWith("google_"))) {
+    return "search";
+  }
+  if (availableToolNames.has("scroll") && /scroll|page_?down|page_?up/.test(normalized)) {
+    return "scroll";
+  }
+  if (availableToolNames.has("read_page") && /read|scan|inspect|analy[sz]e|summari[sz]e/.test(normalized)) {
+    return "read_page";
+  }
+  return aliased;
+}
+function logAgentLoopDebug(payload) {
+  if (!shouldDebugAgentLoop()) return;
+  try {
+    console.log(`[Vessel agent-debug] ${JSON.stringify(payload)}`);
+  } catch (err) {
+    console.warn("[Vessel agent-debug] Failed to serialize debug payload:", err);
+  }
+}
+function recoverTextEncodedToolCalls(text, availableToolNames) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  const candidates = trimmed.match(
+    /([A-Za-z0-9._ -]+)\s*\[ARGS\]\s*(\{[\s\S]*?\})(?=\s*$|\n{2,}|[A-Za-z0-9._ -]+\s*\[ARGS\])/g
+  );
+  if (!candidates || candidates.length === 0) return [];
+  const recovered = [];
+  for (const candidate of candidates) {
+    const match = candidate.match(
+      /^\s*([A-Za-z0-9._ -]+)\s*\[ARGS\]\s*(\{[\s\S]*\})\s*$/
+    );
+    if (!match) continue;
+    const rawName = match[1] ?? "";
+    const argsJson = match[2] ?? "{}";
+    let parsedArgs = {};
+    try {
+      parsedArgs = JSON.parse(argsJson);
+    } catch {
+      continue;
+    }
+    const resolvedName = resolveToolCallName(
+      rawName,
+      parsedArgs,
+      availableToolNames
+    );
+    recovered.push({
+      id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      name: resolvedName,
+      argsJson
+    });
+  }
+  return recovered;
+}
+function recoverNarratedActionToolCalls(text, availableToolNames) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  const recovered = [];
+  const actionLines = trimmed.match(/^action:\s+.+$/gim) ?? [];
+  for (const rawLine of actionLines) {
+    const line = rawLine.replace(/^action:\s*/i, "").trim();
+    if (!line) continue;
+    const quotedValue = line.match(/"([^"]+)"/)?.[1]?.trim() ?? line.match(/'([^']+)'/)?.[1]?.trim() ?? "";
+    const navigateMatch = line.match(
+      /\b(?:navigate|open|go)\b(?:\s+(?:to|the url))?\s+(https?:\/\/[^\s)]+)\.?/i
+    );
+    if (navigateMatch?.[1]) {
+      const argsJson = JSON.stringify({ url: navigateMatch[1].replace(/\.$/, "") });
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: resolveToolCallName("navigate", { url: navigateMatch[1] }, availableToolNames),
+        argsJson
+      });
+      continue;
+    }
+    const isSearchAction = /\bsearch\b/i.test(line) || /\btype\b/i.test(line) && /\bsearch box\b/i.test(line);
+    if (isSearchAction && quotedValue && availableToolNames.has("search")) {
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: "search",
+        argsJson: JSON.stringify({ query: quotedValue })
+      });
+      continue;
+    }
+    if (/\b(?:read|scan)\b.*\bpage\b/i.test(line) && availableToolNames.has("read_page")) {
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: "read_page",
+        argsJson: JSON.stringify({ mode: "visible_only" })
+      });
+      continue;
+    }
+    const toolRefMatch = line.match(
+      /\b(?:use|call)\s+([a-z_][a-z0-9_]*)(?:\s+tool)?\b/i
+    );
+    if (toolRefMatch?.[1]) {
+      const toolName = resolveToolCallName(toolRefMatch[1], {}, availableToolNames);
+      recovered.push({
+        id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: toolName,
+        argsJson: "{}"
+      });
+    }
+  }
+  return recovered;
+}
 class OpenAICompatProvider {
+  agentToolProfile;
   client;
   model;
   abortController = null;
@@ -5446,6 +5828,7 @@ class OpenAICompatProvider {
       baseURL
     });
     this.model = config.model || meta?.defaultModel || "gpt-4o";
+    this.agentToolProfile = resolveAgentToolProfile(config);
   }
   async streamQuery(systemPrompt, userMessage, onChunk, onEnd, history) {
     this.abortController = new AbortController();
@@ -5483,6 +5866,7 @@ class OpenAICompatProvider {
   async streamAgentQuery(systemPrompt, userMessage, tools, onChunk, onToolCall, onEnd, history) {
     this.abortController = new AbortController();
     const openAITools = toOpenAITools(tools);
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
     const messages = [
       { role: "system", content: systemPrompt },
       ...(history ?? []).map((m) => ({ role: m.role, content: m.content })),
@@ -5491,18 +5875,28 @@ class OpenAICompatProvider {
     try {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
+      let compactRecoveryCount = 0;
+      let compactCorrectionCount = 0;
+      const recentCompactToolSignatures = [];
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         let textAccum = "";
         const toolCallAccums = {};
         let finishReason = null;
+        const hasToolHistory = messages.some((message) => message.role === "tool");
+        const priorToolMessages = messages.filter(
+          (message) => message.role === "tool"
+        );
+        const latestToolMessage = priorToolMessages.length > 0 ? priorToolMessages[priorToolMessages.length - 1] : null;
+        const debugRoundLabel = hasToolHistory ? "post_tool" : "initial";
         const stream = await this.client.chat.completions.create(
           {
             model: this.model,
             stream: true,
             messages,
             tools: openAITools,
-            tool_choice: "auto"
+            tool_choice: "auto",
+            temperature: agentTemperatureForProfile(this.agentToolProfile)
           },
           { signal: this.abortController.signal }
         );
@@ -5527,10 +5921,50 @@ class OpenAICompatProvider {
             }
           }
         }
-        const toolCalls = Object.values(toolCallAccums);
+        let toolCalls = Object.values(toolCallAccums);
         for (const tc of Object.values(toolCallAccums)) {
           if (!tc.id) tc.id = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          let parsedArgs = {};
+          try {
+            parsedArgs = JSON.parse(tc.argsJson || "{}");
+          } catch {
+            parsedArgs = {};
+          }
+          tc.name = resolveToolCallName(tc.name, parsedArgs, availableToolNames);
         }
+        if (toolCalls.length === 0) {
+          const recoveredToolCalls = recoverTextEncodedToolCalls(
+            textAccum,
+            availableToolNames
+          );
+          if (recoveredToolCalls.length > 0) {
+            toolCalls = recoveredToolCalls;
+          } else {
+            const narratedToolCalls = recoverNarratedActionToolCalls(
+              textAccum,
+              availableToolNames
+            );
+            if (narratedToolCalls.length > 0) {
+              toolCalls = narratedToolCalls;
+            }
+          }
+        }
+        logAgentLoopDebug({
+          model: this.model,
+          profile: this.agentToolProfile,
+          iteration: i + 1,
+          round: debugRoundLabel,
+          priorToolCount: priorToolMessages.length,
+          latestToolResultPreview: latestToolMessage ? previewToolDebugContent(String(latestToolMessage.content || "")) : null,
+          finishReason,
+          streamedText: previewDebugValue(textAccum),
+          recoveredFromText: Object.keys(toolCallAccums).length === 0 && toolCalls.length > 0,
+          toolCalls: toolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            argsJson: previewDebugValue(tc.argsJson || "{}", 300)
+          }))
+        });
         const malformedToolCalls = /* @__PURE__ */ new Set();
         for (const tc of toolCalls) {
           try {
@@ -5552,7 +5986,28 @@ class OpenAICompatProvider {
           }
         };
         messages.push(assistantMsg);
-        if (toolCalls.length === 0) break;
+        if (toolCalls.length === 0) {
+          if (compactRecoveryCount < 2 && shouldRetryCompactToolLoop(
+            this.agentToolProfile,
+            textAccum,
+            hasToolHistory,
+            userMessage
+          )) {
+            compactRecoveryCount += 1;
+            messages.push({
+              role: "system",
+              content: buildCompactRecoveryPrompt(
+                userMessage,
+                textAccum,
+                latestToolMessage ? String(latestToolMessage.content || "") : null
+              )
+            });
+            continue;
+          }
+          break;
+        }
+        compactRecoveryCount = 0;
+        const iterationToolResultPreviews = [];
         for (const tc of toolCalls) {
           if (malformedToolCalls.has(tc.id)) {
             onChunk(`
@@ -5579,7 +6034,48 @@ class OpenAICompatProvider {
             });
             continue;
           }
-          const argSummary = args.url || args.text || args.direction || "";
+          args = coerceToolArgsForExecution(tc.name, args);
+          if (!availableToolNames.has(tc.name)) {
+            onChunk(`
+<<tool:unsupported_tool:⚠ unsupported>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `Error: ${tc.name} is not a supported tool. Choose one of the available browser tools instead.`
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "system",
+                content: `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(
+            recentCompactToolSignatures,
+            toolSignature
+          )) {
+            onChunk(`
+<<tool:${tc.name}:↻ duplicate suppressed>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `Error: Repeated the same tool call (${tc.name}) with the same arguments twice in a row. Do not repeat it. Continue with the next logical step for the original task.`
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "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.`
+              });
+            }
+            continue;
+          }
+          const argSummary = args.url || args.query || args.text || args.direction || "";
           onChunk(`
 <<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
 `);
@@ -5598,12 +6094,29 @@ class OpenAICompatProvider {
             }
           } catch {
           }
+          if (this.agentToolProfile === "compact") {
+            recentCompactToolSignatures.push(toolSignature);
+            if (recentCompactToolSignatures.length > 4) {
+              recentCompactToolSignatures.shift();
+            }
+          }
+          compactCorrectionCount = 0;
+          iterationToolResultPreviews.push(toolContent);
           messages.push({
             role: "tool",
             tool_call_id: tc.id,
             content: toolContent
           });
         }
+        const followUpReminder = followUpReminderForProfile(
+          this.agentToolProfile,
+          userMessage,
+          textAccum,
+          iterationToolResultPreviews.length > 0 ? iterationToolResultPreviews[iterationToolResultPreviews.length - 1] : null
+        );
+        if (followUpReminder) {
+          messages.push(followUpReminder);
+        }
       }
       if (iterationsUsed >= maxIterations) {
         onChunk(`
@@ -7239,6 +7752,103 @@ function buildGeneralPrompt(query) {
     user: query
   };
 }
+const SHARED_CORE_INSTRUCTIONS = [
+  "You can see the page the user is viewing. The content above is from the page.",
+  "The structured page context always refers to the tab currently visible to the human unless a later tool call changes tabs.",
+  "Use tools to interact with the page when asked to do something (navigate, click, type, select options, submit forms, press keys, scroll).",
+  "Only say you completed an action after the corresponding tool succeeds. If no tool supports the request, say so plainly.",
+  "Call one tool at a time unless you are certain your provider supports parallel tool calls. Sequential calls are more reliable.",
+  "ACT, DON'T HEDGE: You have a full browser. If the user asks you to go somewhere and do something, start doing it immediately."
+];
+const SHARED_NAVIGATION_INSTRUCTIONS = [
+  "Use current_tab when you only need to know what the human is currently looking at. Use list_tabs before switching context across multiple tabs.",
+  "Prefer select_option for dropdowns and submit_form for forms instead of guessing with clicks.",
+  "After navigating to a new site, do not call read_page immediately unless you are genuinely stuck. Prefer the site's search box, known navigation patterns, or clicking a visible section first.",
+  "On retail and marketplace sites, prefer the site's visible search box, filters, and result pages over direct product URLs.",
+  "For broad discovery tasks, prefer direct sources and site-specific search over generic search engines."
+];
+const SHARED_READ_INSTRUCTIONS = [
+  "The page brief you start with is intentionally sparse. It is optimized for navigation speed, not completeness.",
+  "When you only need detail on one result, card, or form section, use inspect_element instead of reading the whole page.",
+  'Escalate page reads progressively: read_page(mode="glance"), then visible_only/results_only/forms_only/summary/text_only as needed. Use read_page(mode="debug") only as a last resort.',
+  'If read_page returns empty or times out, do not retry with the same mode. Switch to read_page(mode="glance") or use screenshot.',
+  "Use screenshot when you need the exact rendered page or text extraction is failing.",
+  "read_page inspects the page without moving the human-visible viewport. If you say you are going to scroll, call scroll or scroll_to_element so the user sees the page move too.",
+  "After clicking or submitting a form, prefer wait_for on a specific result signal or a narrow read_page mode."
+];
+const DEFAULT_EXTRA_INSTRUCTIONS = [
+  "Create a checkpoint before risky multi-step flows or before leaving an important state.",
+  "Use save_session after completing a login flow you may need again later, and load_session to resume that authenticated state in future runs.",
+  "If the user says they highlighted or selected text, use read_page before falling back to screenshots because it includes active selection and visible unsaved highlights.",
+  "If a page behaves abnormally or key UI fails to load, consider disabling ad blocking for that tab and reloading before retrying.",
+  "If the page context reports a rate limit, human verification, or access warning, stop using that page and switch to a different source.",
+  "Reference interactive elements by their index number (shown as [#N] in the listings above).",
+  "Be concise. Explain what you're doing as you go.",
+  "For simple questions about the page, just answer directly without using tools.",
+  "VISUAL AWARENESS: The human is watching the browser alongside this chat. Use highlights proactively when you reference specific on-page findings or errors.",
+  "After completing a task or answering a question, offer 1-2 brief, natural follow-up suggestions that make sense in context.",
+  'MINIMIZE TOOL CALLS: Every tool call takes time and costs a round trip. Be efficient. The fastest path is usually: navigate -> search -> wait_for or read_page(mode="results_only") -> click.',
+  "USE YOUR KNOWLEDGE: When the user asks for recommendations, make a clear recommendation, explain your reasoning briefly, and then execute.",
+  "NEVER USE EMOJIS unless the user uses them first."
+];
+const COMPACT_FOCUS_INSTRUCTIONS = [
+  "Trust the latest tool result over the initial page context. If a tool result shows a new URL/title/results page, that is the current truth.",
+  "Do not ask the user for permission to continue a task they already requested.",
+  "Stay on the current task until it is complete. Do not restart completed phases such as re-navigating to the same site or redoing discovery after you already have candidates.",
+  "If you are already on the requested site, do not navigate to its homepage again unless the current page is clearly unusable.",
+  "If search or read_page returns results on the target site, continue from those results. Do not assume the search failed unless the tool result says it failed.",
+  "Use current_tab only if you are genuinely unsure of the current page after reading the latest tool result.",
+  "On retail tasks, prefer this sequence: navigate -> site search or curated section -> inspect/read results -> click a product -> add to cart -> explain.",
+  "Keep your reasoning short. Prefer taking the next tool action over writing a long plan."
+];
+function buildInstructionBlock(instructions) {
+  return instructions.map((line) => `- ${line}`).join("\n");
+}
+function buildContextBlock(input) {
+  return `You are Vessel, an AI agent embedded in a web browser. You can see the current page and interact with it using tools.
+
+THE USER IS CURRENTLY LOOKING AT:
+  Title: ${input.activeTabTitle}
+  URL: ${input.activeTabUrl}${input.tabSummary || ""}
+
+When the user says "this page", "this article", "this site", or asks about what they're viewing, they mean the page above. The context below is from that page.
+
+Current page context:
+This brief is intentionally minimal and filtered for speed. It omits most page text and low-value chrome unless you explicitly ask for more.
+Default brief mode: ${input.defaultReadMode}
+Detected page type: ${input.pageType}
+
+${input.structuredContext}
+
+Supervisor state:
+- paused: ${input.supervisorPaused ? "yes" : "no"}
+- approval mode: ${input.approvalMode}
+- pending approvals: ${input.pendingApprovals}
+
+Recent checkpoints:
+${input.recentCheckpoints || "- none"}
+
+Task tracker:
+${input.taskTrackerContext || "- none"}`;
+}
+function buildAgentSystemPrompt(input) {
+  const instructionBlocks = input.profile === "compact" ? [
+    buildInstructionBlock(SHARED_CORE_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_NAVIGATION_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_READ_INSTRUCTIONS),
+    buildInstructionBlock(COMPACT_FOCUS_INSTRUCTIONS)
+  ] : [
+    buildInstructionBlock(SHARED_CORE_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_NAVIGATION_INSTRUCTIONS),
+    buildInstructionBlock(SHARED_READ_INSTRUCTIONS),
+    buildInstructionBlock(DEFAULT_EXTRA_INSTRUCTIONS)
+  ];
+  return [
+    buildContextBlock(input),
+    "Instructions:",
+    ...instructionBlocks
+  ].join("\n\n");
+}
 const WRAPPING_QUOTES = /* @__PURE__ */ new Set(['"', "'", "`"]);
 function stripWrappingQuotes(value) {
   const trimmed = value.trim();
@@ -7956,10 +8566,16 @@ const CONTEXT_HINTS = {
     scroll: "💡 Long content — scroll to continue — "
   }
 };
-function scoreForContext(toolName, pageType) {
+function scoreForContext(toolName, pageType, intents) {
   const def = defByName[toolName];
   if (!def) return 500;
   if (pageType === "SEARCH_READY") {
+    if (intents.has("navigate")) {
+      if (toolName === "navigate") return -30;
+      if (toolName === "search") return 2;
+      if (toolName === "type_text") return 5;
+      if (toolName === "press_key") return 6;
+    }
     if (toolName === "search") return -20;
     if (toolName === "type_text") return 5;
     if (toolName === "press_key") return 6;
@@ -7993,10 +8609,53 @@ const ALWAYS_FAST_TOOL_NAMES = /* @__PURE__ */ new Set([
   "screenshot",
   "inspect_element"
 ]);
+const COMPACT_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "navigate",
+  "go_back",
+  "click",
+  "type_text",
+  "press_key",
+  "scroll",
+  "dismiss_popup",
+  "clear_overlays",
+  "accept_cookies",
+  "read_page",
+  "wait_for",
+  "inspect_element",
+  "search"
+]);
+const COMPACT_CONTEXTUAL_TOOL_NAMES = {
+  LOGIN: ["fill_form", "submit_form", "login"],
+  FORM: ["fill_form", "select_option", "submit_form"],
+  SHOPPING: ["select_option", "fill_form", "submit_form"],
+  SEARCH_RESULTS: ["paginate", "scroll_to_element"],
+  PAGINATED_LIST: ["paginate", "scroll_to_element"]
+};
+const COMPACT_INTENT_TOOL_NAMES = {
+  tabs: ["current_tab", "list_tabs", "switch_tab", "create_tab"],
+  bookmarks: [
+    "list_bookmarks",
+    "search_bookmarks",
+    "create_bookmark_folder",
+    "save_bookmark",
+    "organize_bookmark",
+    "archive_bookmark",
+    "open_bookmark"
+  ],
+  sessions: ["login", "save_session", "load_session", "list_sessions", "delete_session"],
+  workflow: ["create_checkpoint", "restore_checkpoint", "flow_start", "flow_advance", "flow_status", "flow_end"],
+  metrics: ["metrics"],
+  highlight: ["highlight", "clear_highlights"],
+  table: ["extract_table"],
+  debug: ["current_tab", "reload", "set_ad_blocking", "suggest", "screenshot"]
+};
 function inferIntent(query) {
   const lowered = query.toLowerCase();
   const intents = /* @__PURE__ */ new Set();
   if (/\b(tab|tabs|window|windows)\b/.test(lowered)) intents.add("tabs");
+  if (/\b(go to|goto|open|visit|navigate to)\b/.test(lowered) || /\b[a-z0-9-]+\.(com|org|net|io|dev|app|ai|co|edu|gov)\b/.test(lowered) || /\bhttps?:\/\//.test(lowered)) {
+    intents.add("navigate");
+  }
   if (/\b(bookmark|bookmarks|save this|folder)\b/.test(lowered)) {
     intents.add("bookmarks");
   }
@@ -8019,7 +8678,18 @@ function inferIntent(query) {
   }
   return intents;
 }
-function shouldIncludeTool(toolName, pageType, intents) {
+function shouldIncludeTool(toolName, pageType, intents, profile) {
+  if (profile === "compact") {
+    if (COMPACT_CORE_TOOL_NAMES.has(toolName)) return true;
+    const contextualTools = COMPACT_CONTEXTUAL_TOOL_NAMES[pageType] ?? [];
+    if (contextualTools.includes(toolName)) return true;
+    for (const intent of intents) {
+      if ((COMPACT_INTENT_TOOL_NAMES[intent] ?? []).includes(toolName)) {
+        return true;
+      }
+    }
+    return false;
+  }
   if (ALWAYS_FAST_TOOL_NAMES.has(toolName)) return true;
   switch (toolName) {
     case "select_option":
@@ -8076,13 +8746,14 @@ function shouldIncludeTool(toolName, pageType, intents) {
       return !defByName[toolName]?.hiddenByDefault;
   }
 }
-function pruneToolsForContext(tools, pageType, query = "") {
+function pruneToolsForContext(tools, pageType, query = "", options = {}) {
   const ctx = pageType ?? "GENERAL";
   const hints = CONTEXT_HINTS[ctx] ?? {};
   const intents = inferIntent(query);
-  const scored = tools.filter((tool) => shouldIncludeTool(tool.name, ctx, intents)).map((tool) => ({
+  const profile = options.profile ?? "default";
+  const scored = tools.filter((tool) => shouldIncludeTool(tool.name, ctx, intents, profile)).map((tool) => ({
     tool,
-    score: scoreForContext(tool.name, ctx)
+    score: scoreForContext(tool.name, ctx, intents)
   }));
   scored.sort((a, b) => a.score - b.score);
   return scored.map(({ tool, score }) => {
@@ -8746,6 +9417,87 @@ async function captureScreenshot(wc) {
   }
   return { ok: false, error: "Page image was empty after 3 attempts" };
 }
+function normalizeForComparison(value) {
+  return value.toLowerCase().replace(/https?:\/\//g, "").replace(/www\./g, "").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function canonicalizeUrlForComparison(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.hostname = url.hostname.replace(/^www\./, "");
+    url.hash = "";
+    if (url.pathname.endsWith("/") && url.pathname !== "/") {
+      url.pathname = url.pathname.replace(/\/+$/, "");
+    }
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function isRedundantNavigateTarget(currentUrl, targetUrl) {
+  const current = canonicalizeUrlForComparison(currentUrl);
+  const target = canonicalizeUrlForComparison(targetUrl);
+  return current !== null && target !== null && current === target;
+}
+function looksLikeCurrentSiteNameQuery(query, currentUrl, currentTitle) {
+  const normalizedQuery = normalizeForComparison(query);
+  if (!normalizedQuery) return false;
+  let hostnameLabel = "";
+  try {
+    const url = new URL(currentUrl);
+    hostnameLabel = url.hostname.replace(/^www\./, "").split(".")[0] || "";
+  } catch {
+  }
+  const normalizedTitle = normalizeForComparison(currentTitle);
+  const normalizedHost = normalizeForComparison(hostnameLabel);
+  const normalizedTitlePrefix = normalizeForComparison(
+    currentTitle.split("|")[0]?.split("—")[0]?.split("-")[0] || currentTitle
+  );
+  if (normalizedTitle && normalizedQuery === normalizedTitle) return true;
+  if (normalizedTitlePrefix && normalizedQuery === normalizedTitlePrefix) {
+    return true;
+  }
+  if (normalizedHost && normalizedQuery === normalizedHost) return true;
+  const titleTokens = new Set(normalizedTitle.split(/\s+/).filter(Boolean));
+  const queryTokens = normalizedQuery.split(/\s+/).filter(Boolean);
+  if (normalizedHost && queryTokens.includes(normalizedHost) && queryTokens.every((token) => titleTokens.has(token) || token === normalizedHost)) {
+    return true;
+  }
+  return false;
+}
+function extractExplicitDomains(goal) {
+  const matches = goal.toLowerCase().match(/\b(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+\.(?:com|org|net|io|dev|app|ai|co|edu|gov))\b/g);
+  if (!matches) return [];
+  const normalized = matches.map(
+    (match) => match.replace(/^https?:\/\//, "").replace(/^www\./, "").toLowerCase()
+  );
+  return [...new Set(normalized)];
+}
+function apexDomain(hostname) {
+  const parts = hostname.replace(/^www\./, "").split(".").filter(Boolean);
+  if (parts.length <= 2) return parts.join(".");
+  return parts.slice(-2).join(".");
+}
+function shouldBlockOffGoalDomainNavigation(goal, targetUrl) {
+  const explicitDomains = extractExplicitDomains(goal);
+  if (explicitDomains.length !== 1) return null;
+  let targetHost = "";
+  try {
+    const url = new URL(targetUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    targetHost = url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return null;
+  }
+  const requestedDomain = explicitDomains[0];
+  if (targetHost === requestedDomain || targetHost.endsWith(`.${requestedDomain}`) || apexDomain(targetHost) === apexDomain(requestedDomain)) {
+    return null;
+  }
+  return {
+    requestedDomain,
+    targetDomain: targetHost
+  };
+}
 const SESSION_VERSION = 1;
 function getSessionsDir() {
   return path$1.join(electron.app.getPath("userData"), "named-sessions");
@@ -9358,6 +10110,28 @@ WARNING: Blocking overlay detected (${overlaySignal}). Call clear_overlays or ac
   }
   return titleLine;
 }
+async function getPostSearchSummary(wc) {
+  await waitForLoad$1(wc, 2e3);
+  try {
+    const content = await Promise.race([
+      extractContent(wc),
+      new Promise((resolve) => setTimeout(() => resolve(null), 2500))
+    ]);
+    if (content && content.content.length > 0) {
+      const scoped = buildScopedContext(content, "results_only");
+      const truncated = scoped.length > 2600 ? `${scoped.slice(0, 2600)}
+[Search results snapshot truncated...]` : scoped;
+      return `
+Search results snapshot:
+${truncated}`;
+    }
+  } catch {
+  }
+  const fallback = await getPostNavSummary(wc);
+  return fallback ? `${fallback}
+Search results snapshot unavailable. Use read_page(mode="results_only") if needed.` : `
+Search results snapshot unavailable. Use read_page(mode="results_only") if needed.`;
+}
 async function scrollPage$1(wc, deltaY) {
   const getScrollY = async () => {
     const scrollY = await executePageScript(
@@ -12094,6 +12868,9 @@ async function searchPage(wc, args) {
   if (buttonLikePatterns.some((p) => queryLower.includes(p))) {
     return `Error: "${query}" looks like a button label, not a search query. Use the click tool to interact with this element instead.`;
   }
+  if (looksLikeCurrentSiteNameQuery(query, wc.getURL(), wc.getTitle() || "")) {
+    return `Error: "${query}" looks like the current site's name, not a product query. You are already on ${wc.getURL()}. Open a section like staff picks/new releases or search for actual book titles, authors, or genres instead.`;
+  }
   if (typeof args.selector !== "string") {
     const shortcut = buildSearchShortcut(wc.getURL(), query);
     if (shortcut) {
@@ -12104,7 +12881,7 @@ async function searchPage(wc, args) {
       const afterUrl2 = wc.getURL();
       const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
       const destination = shortcut.section ? ` ${shortcut.section}` : "";
-      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}`;
+      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}${await getPostSearchSummary(wc)}`;
     }
   }
   const searchInfo = await locateSearchTarget(
@@ -12133,7 +12910,7 @@ async function searchPage(wc, args) {
   await waitForPotentialNavigation$1(wc, beforeUrl, 3e3);
   let afterUrl = wc.getURL();
   if (afterUrl !== beforeUrl) {
-    return `Searched "${query}" → ${afterUrl}`;
+    return `Searched "${query}" → ${afterUrl}${await getPostSearchSummary(wc)}`;
   }
   if (searchInfo.submitSelector) {
     const clickResult = await clickElementBySelector(wc, searchInfo.submitSelector);
@@ -12141,11 +12918,11 @@ async function searchPage(wc, args) {
       await waitForPotentialNavigation$1(wc, beforeUrl, 3e3);
       afterUrl = wc.getURL();
       if (afterUrl !== beforeUrl) {
-        return `Searched "${query}" (via search button) → ${afterUrl}`;
+        return `Searched "${query}" (via search button) → ${afterUrl}${await getPostSearchSummary(wc)}`;
       }
     }
   }
-  return `Searched "${query}" (same page — results may have loaded dynamically; inspect with read_page(mode="results_only") or read_page(mode="visible_only") before navigating directly elsewhere)`;
+  return `Searched "${query}" (same page — results may have loaded dynamically)${await getPostSearchSummary(wc)}`;
 }
 async function pressKey$1(wc, args) {
   const key = typeof args.key === "string" ? args.key.trim() : "";
@@ -12307,6 +13084,7 @@ const KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "wait_for_navigation"
 ]);
 async function executeAction(name, args, ctx) {
+  name = normalizeToolAlias(name);
   if (!KNOWN_TOOLS.has(name)) {
     for (const known of KNOWN_TOOLS) {
       if (name.startsWith(known) && name.length > known.length) {
@@ -12423,6 +13201,19 @@ async function executeAction(name, args, ctx) {
         }
         case "navigate": {
           if (!wc || !tabId) return "Error: No active tab";
+          const taskGoal = ctx.runtime.getState().taskTracker?.goal;
+          if (taskGoal && typeof args.url === "string") {
+            const domainDrift = shouldBlockOffGoalDomainNavigation(
+              taskGoal,
+              args.url
+            );
+            if (domainDrift) {
+              return `Navigation blocked: ${args.url} drifts away from the requested site ${domainDrift.requestedDomain}. Stay on the requested domain and continue the original task there.`;
+            }
+          }
+          if (typeof args.url === "string" && !args.postBody && isRedundantNavigateTarget(wc.getURL(), args.url)) {
+            return `Already on ${wc.getURL()}. Do not navigate to the same URL again. Use click, inspect_element, read_page, or search for actual book terms instead.`;
+          }
           const navValidation = await validateLinkDestination(args.url);
           if (navValidation.status === "dead") {
             return `Navigation blocked: ${args.url} returned ${navValidation.detail || "dead link"}. Try a different URL or go back and choose another link.`;
@@ -13358,81 +14149,44 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
       const pageContent = await extractContent(activeWebContents);
       const pageType = detectPageType(pageContent);
       const defaultReadMode = chooseAgentReadMode(pageContent);
+      if (provider.agentToolProfile === "compact") {
+        runtime2.ensureTaskTracker(query, pageContent.url || activeWebContents.getURL());
+      } else {
+        runtime2.clearTaskTracker();
+      }
       const structuredContext = buildScopedContext(
         pageContent,
         defaultReadMode
       );
       const runtimeState = runtime2.getState();
       const recentCheckpoints = runtimeState.checkpoints.slice(-3).map((item) => `- ${item.name} (${item.id})`).join("\n");
+      const taskTrackerContext = runtime2.getTaskTrackerContext();
       const activeTabTitle = pageContent.title || "(untitled)";
       const activeTabUrl = pageContent.url || activeWebContents.getURL();
       const allTabs = tabManager.getAllStates();
       const activeTabId = tabManager.getActiveTabId();
       const tabSummary = allTabs.length > 1 ? `
 All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.title || "New Tab"} (${t.url})`).join(" | ")}` : "";
-      const systemPrompt = `You are Vessel, an AI agent embedded in a web browser. You can see the current page and interact with it using tools.
-
-THE USER IS CURRENTLY LOOKING AT:
-  Title: ${activeTabTitle}
-  URL: ${activeTabUrl}${tabSummary}
-
-When the user says "this page", "this article", "this site", or asks about what they're viewing, they mean the page above. The context below is from that page — answer directly without needing to call read_page or current_tab first.
-
-Current page context:
-This brief is intentionally minimal and filtered for speed. It omits most page text and low-value chrome unless you explicitly ask for more.
-Default brief mode: ${defaultReadMode}
-Detected page type: ${pageType}
-
-${structuredContext}
-
-Supervisor state:
-- paused: ${runtimeState.supervisor.paused ? "yes" : "no"}
-- approval mode: ${runtimeState.supervisor.approvalMode}
-- pending approvals: ${runtimeState.supervisor.pendingApprovals.length}
-
-Recent checkpoints:
-${recentCheckpoints || "- none"}
-
-Instructions:
-- You can see the page the user is viewing. The content above is from the page.
-- The structured page context always refers to the tab currently visible to the human unless a later tool call changes tabs.
-- Use tools to interact with the page when asked to do something (navigate, click, type, select options, submit forms, press keys, scroll).
-- Only say you completed an action after the corresponding tool succeeds. If no tool supports the request, say so plainly.
-- Use current_tab when you only need to know what the human is currently looking at. Use list_tabs before switching context across multiple tabs.
-- Create a checkpoint before risky multi-step flows or before leaving an important state.
-- Use save_session after completing a login flow you may need again later, and load_session to resume that authenticated state in future runs.
-- Prefer select_option for dropdowns and submit_form for forms instead of guessing with clicks.
-- After navigating to a new site, DO NOT call read_page immediately. Instead, act on what you already know: use the search tool to search the site, type_text to enter queries in search bars, or click on known navigation patterns. You know what major sites look like — use that knowledge. Only call read_page if you're genuinely stuck and need to discover unfamiliar page structure.
-- On retail and marketplace sites (like Newegg, Amazon, Walmart, Etsy, eBay), prefer the site's visible search box, filters, and result pages over direct product URLs. Only navigate directly to a product page if the user gave you that URL or the site's own search UI is clearly unavailable after a reasonable attempt.
-- The page brief you start with is intentionally sparse. It is optimized for navigation speed, not completeness.
-- When you only need detail on one product/result/card/form section, use inspect_element instead of reading the page.
-- Escalate page reads progressively: read_page(mode="glance") for a fast viewport snapshot on heavy/slow pages, then read_page(mode="visible_only"), read_page(mode="results_only"), read_page(mode="forms_only"), read_page(mode="summary"), or read_page(mode="text_only") depending on what you need.
-- Use read_page(mode="glance") when a page is slow to load or extraction times out — it shows what's on screen (headings, links, buttons, inputs) without waiting for heavy JS. It's what a human would see by just looking at the page.
-- Use read_page(mode="debug") only as a last resort when the narrower modes are insufficient.
-- If read_page returns empty or times out, do NOT retry with the same mode. Switch to read_page(mode="glance") or use screenshot to see the page visually.
-- Use screenshot when you need to see exactly what the user sees — visual layout, rendered content, images, or when text extraction is failing. The screenshot returns the actual rendered page image for visual analysis. It works even when the JS thread is completely blocked.
-- VIEWPORT SYNC: Treat scrolling as a real, user-visible browser action. If you say you are going to scroll, call scroll or scroll_to_element so the human sees the page move too.
-- read_page inspects the page without moving the human-visible viewport. Do not describe read_page as scrolling. If you want more context without changing the user's view, say you're reading the page; if you want the user to follow along lower on the page, actually scroll first.
-- After clicking or submitting a form, prefer wait_for on a specific result signal or a narrow read_page mode. Do not jump straight to read_page(mode="debug").
-- If the user says they highlighted or selected text, use read_page before falling back to screenshots because it includes active selection and visible unsaved highlights.
-- If a page behaves abnormally or key UI fails to load, consider disabling ad blocking for that tab and reloading before retrying.
-- For broad discovery tasks, prefer direct sources, official sites, venue directories, and site-specific search over generic search engines, which often rate-limit automated browser traffic.
-- If the page context reports a rate limit, human verification, or access warning, stop using that page and switch to a different source.
-- Reference interactive elements by their index number (shown as [#N] in the listings above).
-- Be concise. Explain what you're doing as you go.
-- For simple questions about the page, just answer directly without using tools.
-- VISUAL AWARENESS: The human is watching the browser alongside this chat. Highlights are your pointing finger — they show the user exactly what you're looking at on the page. Use them proactively: highlight key findings, important elements, errors, or anything you're referencing. Don't wait to be asked. If you mention something specific on the page, highlight it. Colors: yellow (default/attention), red (errors/warnings), green (success/good), blue (info/neutral), purple (important/notable), orange (caution). Clear highlights when moving to a new topic or page.
-- After completing a task or answering a question, offer 1-2 brief, natural follow-up suggestions that make sense in context (e.g. "Want me to highlight any of these?" or "I can save these to a bookmark folder if you'd like"). Keep suggestions short and conversational — don't list every possible action.
-- Call one tool at a time unless you are certain your provider supports parallel tool calls. Sequential calls are more reliable.
-- MINIMIZE TOOL CALLS: Every tool call takes time and costs a round trip. Be efficient. Don't use flow_start/flow_advance for simple multi-step tasks — just do the work. Don't call read_page after navigating — use search or type_text directly. Don't retry failed tools with slight variations — if search fails, go straight to type_text + press_key Enter, don't try read_page in between. The fastest path is usually: navigate → search → wait_for or read_page(mode="results_only") → click.
-- ACT, DON'T HEDGE: You have a full browser — you can navigate to any website, see live content, search, click, add to cart, fill forms, and interact with real pages in real time. Never claim you "don't have access" to a website's inventory, pricing, or content. If the user asks you to go somewhere and do something, start doing it immediately. Don't ask for permission to do what the user just asked you to do — that's redundant and frustrating. Jump straight into action.
-- USE YOUR KNOWLEDGE: You have broad, practical knowledge about technology, products, cooking, travel, finance, and countless other domains. When the user asks for recommendations, GIVE them — don't deflect to Reddit, YouTubers, or other sources. You know enough to recommend PC parts, suggest restaurants, pick a good laptop, or advise on most consumer decisions. Make a clear recommendation, explain your reasoning briefly, and then execute. If there's genuine ambiguity (e.g. AMD vs Intel is preference-dependent), state your pick and why, then ask only the questions that would actually change your recommendation. Never refuse a recommendation by claiming you're "not an expert" — the user chose to ask you, so help them.
-- NEVER USE EMOJIS unless the user uses them first.`;
+      const systemPrompt = buildAgentSystemPrompt({
+        profile: provider.agentToolProfile,
+        activeTabTitle,
+        activeTabUrl,
+        tabSummary,
+        defaultReadMode,
+        pageType,
+        structuredContext,
+        supervisorPaused: runtimeState.supervisor.paused,
+        approvalMode: runtimeState.supervisor.approvalMode,
+        pendingApprovals: runtimeState.supervisor.pendingApprovals.length,
+        recentCheckpoints: recentCheckpoints || "- none",
+        taskTrackerContext: taskTrackerContext || "- none"
+      });
       const actionCtx = { tabManager, runtime: runtime2 };
       const contextualTools = pruneToolsForContext(
         AGENT_TOOLS,
         pageType,
-        query
+        query,
+        { profile: provider.agentToolProfile }
       );
       const trace = createTraceSession(query, activeTabUrl, activeTabTitle);
       let accumulatedResponse = "";
@@ -13450,6 +14204,14 @@ Instructions:
         let isError = false;
         try {
           output = await executeAction(name, args, actionCtx);
+          if (provider.agentToolProfile === "compact") {
+            runtime2.updateTaskTracker(name, output);
+            const trackerCtx = runtime2.getTaskTrackerContext();
+            if (trackerCtx) {
+              output = `${output}
+${trackerCtx}`;
+            }
+          }
         } catch (err) {
           isError = true;
           output = err instanceof Error ? err.message : String(err);
@@ -19087,11 +19849,21 @@ function stopMcpServer() {
     });
   });
 }
+const VALID_KIT_CATEGORIES = /* @__PURE__ */ new Set([
+  "research",
+  "shopping",
+  "productivity",
+  "forms"
+]);
 const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set([
   "research-collect",
   "price-scout",
   "form-filler"
 ]);
+const KIT_ID_UNSAFE_CHAR_PATTERN = /[\/\\\0]/;
+function isSafeAutomationKitId(id) {
+  return id.length > 0 && !KIT_ID_UNSAFE_CHAR_PATTERN.test(id);
+}
 function getUserKitsDir() {
   return path$1.join(electron.app.getPath("userData"), "kits");
 }
@@ -19101,10 +19873,16 @@ function ensureKitsDir() {
     fs$1.mkdirSync(dir, { recursive: true });
   }
 }
+function getKitFilePath(id) {
+  if (!isSafeAutomationKitId(id)) return null;
+  const kitsDir = path$1.resolve(getUserKitsDir());
+  const target = path$1.resolve(kitsDir, `${id}.kit.json`);
+  return target.startsWith(`${kitsDir}${path$1.sep}`) ? target : null;
+}
 function isValidKit(value) {
   if (!value || typeof value !== "object") return false;
   const k = value;
-  return typeof k.id === "string" && k.id.length > 0 && typeof k.name === "string" && k.name.length > 0 && typeof k.description === "string" && typeof k.icon === "string" && typeof k.promptTemplate === "string" && k.promptTemplate.length > 0 && Array.isArray(k.inputs);
+  return typeof k.id === "string" && isSafeAutomationKitId(k.id) && typeof k.name === "string" && k.name.length > 0 && typeof k.description === "string" && typeof k.category === "string" && VALID_KIT_CATEGORIES.has(k.category) && typeof k.icon === "string" && typeof k.promptTemplate === "string" && k.promptTemplate.length > 0 && Array.isArray(k.inputs);
 }
 function getInstalledKits() {
   ensureKitsDir();
@@ -19165,7 +19943,10 @@ async function installKitFromFile() {
     };
   }
   ensureKitsDir();
-  const dest = path$1.join(getUserKitsDir(), `${parsed.id}.kit.json`);
+  const dest = getKitFilePath(parsed.id);
+  if (!dest) {
+    return { ok: false, error: "Kit id contains unsupported characters." };
+  }
   try {
     fs$1.writeFileSync(dest, JSON.stringify(parsed, null, 2), "utf-8");
   } catch {
@@ -19173,12 +19954,21 @@ async function installKitFromFile() {
   }
   return { ok: true, kit: parsed };
 }
-function uninstallKit(id) {
+function uninstallKit(id, scheduledKitIds) {
   if (BUNDLED_KIT_IDS.has(id)) {
     return { ok: false, error: "Built-in kits cannot be removed." };
   }
+  if (scheduledKitIds?.has(id)) {
+    return {
+      ok: false,
+      error: "This kit has active scheduled jobs. Delete or reassign them first."
+    };
+  }
   ensureKitsDir();
-  const target = path$1.join(getUserKitsDir(), `${id}.kit.json`);
+  const target = getKitFilePath(id);
+  if (!target) {
+    return { ok: false, error: "Kit id contains unsupported characters." };
+  }
   if (!fs$1.existsSync(target)) {
     return { ok: false, error: "Kit not found." };
   }
@@ -19192,6 +19982,9 @@ function uninstallKit(id) {
 let jobs = [];
 let removeIdleListener = null;
 let broadcastFn = null;
+function getScheduledKitIds() {
+  return new Set(jobs.filter((j) => j.enabled).map((j) => j.kitId));
+}
 function getJobsPath() {
   return path$1.join(electron.app.getPath("userData"), "scheduled-jobs.json");
 }
@@ -19361,29 +20154,40 @@ async function fireJob(job, windowState, runtime2) {
 }
 function tick(windowState, runtime2) {
   if (isAIStreamActive()) return;
-  const now = /* @__PURE__ */ new Date();
-  let changed = false;
-  for (const job of jobs) {
-    if (!job.enabled) continue;
-    if (now < new Date(job.nextRunAt)) continue;
-    if (!tryBeginAIStream("scheduled")) break;
-    void fireJob(job, windowState, runtime2).finally(() => {
+  const dueIds = jobs.filter((job) => job.enabled && /* @__PURE__ */ new Date() >= new Date(job.nextRunAt)).map((job) => job.id);
+  if (dueIds.length === 0) return;
+  if (!tryBeginAIStream("scheduled")) return;
+  let idx = 0;
+  const fireNext = () => {
+    if (idx >= dueIds.length) {
       endAIStream("scheduled");
       queueMicrotask(() => tick(windowState, runtime2));
-    });
-    job.lastRunAt = now.toISOString();
+      return;
+    }
+    const jobId = dueIds[idx++];
+    const job = jobs.find((candidate) => candidate.id === jobId);
+    if (!job || !job.enabled) {
+      fireNext();
+      return;
+    }
+    const firedAt = /* @__PURE__ */ new Date();
+    if (firedAt < new Date(job.nextRunAt)) {
+      fireNext();
+      return;
+    }
+    job.lastRunAt = firedAt.toISOString();
     if (job.schedule.type === "once") {
       job.enabled = false;
     } else {
-      job.nextRunAt = computeNextRun(job.schedule, now).toISOString();
+      job.nextRunAt = computeNextRun(job.schedule, firedAt).toISOString();
     }
-    changed = true;
-    break;
-  }
-  if (changed) {
     saveJobs();
     broadcastFn?.(Channels.SCHEDULE_JOBS_UPDATE, jobs);
-  }
+    void fireJob(job, windowState, runtime2).catch((err) => {
+      console.warn("[scheduler] Unexpected error firing job:", err);
+    }).finally(fireNext);
+  };
+  fireNext();
 }
 function registerScheduleHandlers(windowState, runtime2, sendToAll) {
   broadcastFn = sendToAll;
@@ -19646,7 +20450,7 @@ function registerIpcHandlers(windowState, runtime2) {
         Channels.AI_STREAM_CHUNK,
         "Chat provider not configured. Open Settings (Ctrl+,) to choose a provider."
       );
-      sendToRendererViews(Channels.AI_STREAM_END);
+      sendToRendererViews(Channels.AI_STREAM_END, "failed");
       return { accepted: true };
     }
     if (!tryBeginAIStream("manual")) {
@@ -19663,7 +20467,7 @@ function registerIpcHandlers(windowState, runtime2) {
           activeChatProvider,
           activeTab?.view.webContents,
           (chunk) => sendToRendererViews(Channels.AI_STREAM_CHUNK, chunk),
-          () => sendToRendererViews(Channels.AI_STREAM_END),
+          () => sendToRendererViews(Channels.AI_STREAM_END, "completed"),
           tabManager,
           runtime2,
           history
@@ -19672,7 +20476,7 @@ function registerIpcHandlers(windowState, runtime2) {
         const msg = err instanceof Error ? err.message : "Unknown error";
         sendToRendererViews(Channels.AI_STREAM_CHUNK, `
 [Error: ${msg}]`);
-        sendToRendererViews(Channels.AI_STREAM_END);
+        sendToRendererViews(Channels.AI_STREAM_END, "failed");
       } finally {
         activeChatProvider = null;
         endAIStream("manual");
@@ -20094,10 +20898,175 @@ function registerIpcHandlers(windowState, runtime2) {
   });
   electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (_event, id) => {
     assertString(id, "id");
-    return uninstallKit(id);
+    return uninstallKit(id, getScheduledKitIds());
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
 }
+function makeStep(label, status = "pending") {
+  return { label, status };
+}
+function extractRequestedCount(goal) {
+  const digitMatch = goal.match(/\b(\d+)\b/);
+  if (digitMatch) return Number(digitMatch[1]);
+  const wordMap = {
+    one: 1,
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10
+  };
+  for (const [word, count] of Object.entries(wordMap)) {
+    if (new RegExp(`\\b${word}\\b`, "i").test(goal)) return count;
+  }
+  return null;
+}
+function buildInitialSteps(goal) {
+  const lowered = goal.toLowerCase();
+  const requestedCount = extractRequestedCount(goal);
+  const itemLabel = /\b(book|books)\b/.test(lowered) ? "books" : "items";
+  const countLabel = requestedCount ? `${requestedCount} ${itemLabel}` : itemLabel;
+  const steps = [
+    makeStep("Navigate to the requested site", "active")
+  ];
+  if (/\b(find|browse|look|discover|select|recommend|interesting)\b/.test(lowered)) {
+    steps.push(makeStep(`Browse or search for relevant ${itemLabel}`));
+  }
+  steps.push(makeStep(`Pick the requested ${countLabel}`));
+  if (/\b(cart|checkout|bag)\b/.test(lowered)) {
+    steps.push(makeStep(`Add the chosen ${itemLabel} to the cart`));
+  }
+  if (/\b(explain|reason|why)\b/.test(lowered)) {
+    steps.push(makeStep("Explain the recommendations"));
+  }
+  return steps;
+}
+function setActiveStep(steps, currentStepIndex) {
+  return steps.map((step, index) => {
+    if (step.status === "done" || step.status === "failed") return step;
+    return {
+      ...step,
+      status: index === currentStepIndex ? "active" : "pending"
+    };
+  });
+}
+function completeStep(state2, detail) {
+  const steps = state2.steps.map((step) => ({ ...step }));
+  const current = steps[state2.currentStepIndex];
+  if (current) {
+    current.status = "done";
+    current.detail = detail || current.detail;
+  }
+  const nextIndex = Math.min(state2.currentStepIndex + 1, steps.length - 1);
+  const normalizedSteps = setActiveStep(
+    steps,
+    current ? nextIndex : state2.currentStepIndex
+  );
+  return {
+    ...state2,
+    steps: normalizedSteps,
+    currentStepIndex: current ? nextIndex : state2.currentStepIndex,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setNextHint(state2, nextHint) {
+  return {
+    ...state2,
+    nextHint,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeResult(result) {
+  return result.toLowerCase();
+}
+function createTaskTracker(goal, startUrl) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    goal,
+    startedAt: now,
+    updatedAt: now,
+    startUrl,
+    currentStepIndex: 0,
+    steps: buildInitialSteps(goal),
+    lastAction: void 0,
+    nextHint: "Open a relevant section or search path and keep working the same request."
+  };
+}
+function updateTaskTracker(state2, actionName, result) {
+  const loweredResult = normalizeResult(result);
+  let nextState = {
+    ...state2,
+    lastAction: actionName,
+    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."
+    );
+  }
+  const isDiscoveryAction = [
+    "read_page",
+    "search",
+    "click",
+    "inspect_element",
+    "scroll"
+  ].includes(actionName);
+  if (isDiscoveryAction && /browse or search/.test(currentLabel)) {
+    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."
+    );
+  }
+  if (/pick the requested/.test(currentLabel) && isDiscoveryAction) {
+    return setNextHint(
+      nextState,
+      "Keep selecting candidate books. After you have the requested set, add each one to the cart."
+    );
+  }
+  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.");
+    return setNextHint(
+      nextState,
+      "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."
+    );
+  }
+  return nextState;
+}
+function formatTaskTracker(state2) {
+  if (!state2) return "";
+  const completed = state2.steps.filter((step) => step.status === "done").map((step) => step.label);
+  const current = state2.steps[state2.currentStepIndex]?.label ?? "Task in progress";
+  const remaining = state2.steps.filter((step, index) => step.status !== "done" && index !== state2.currentStepIndex).map((step) => step.label);
+  const lines = [
+    "--- Task Tracker ---",
+    `Goal: ${state2.goal}`,
+    `Completed: ${completed.length > 0 ? completed.join("; ") : "none yet"}`,
+    `Current: ${current}`,
+    `Remaining: ${remaining.length > 0 ? remaining.join("; ") : "wrap up the response"}`
+  ];
+  if (state2.nextHint) {
+    lines.push(`Next: ${state2.nextHint}`);
+  }
+  return `
+${lines.join("\n")}
+---`;
+}
 const MAX_TRANSCRIPT_TEXT_LENGTH = 8e3;
 const PERSIST_DEBOUNCE_MS = 500;
 function clone(value) {
@@ -20133,7 +21102,8 @@ function sanitizePersistence(persisted) {
     checkpoints: Array.isArray(persisted?.checkpoints) ? persisted.checkpoints.slice(-20) : [],
     transcript: [],
     mcpStatus: "stopped",
-    flowState: null
+    flowState: null,
+    taskTracker: null
   };
 }
 class AgentRuntime {
@@ -20252,6 +21222,32 @@ class AgentRuntime {
     this.emit();
     return this.getState();
   }
+  ensureTaskTracker(goal, startUrl) {
+    const trimmedGoal = goal.trim();
+    if (this.state.taskTracker && this.state.taskTracker.goal.trim() === trimmedGoal) {
+      return clone(this.state.taskTracker);
+    }
+    this.state.taskTracker = createTaskTracker(trimmedGoal, startUrl);
+    this.emit();
+    return clone(this.state.taskTracker);
+  }
+  updateTaskTracker(actionName, result) {
+    if (!this.state.taskTracker) return null;
+    this.state.taskTracker = updateTaskTracker(
+      this.state.taskTracker,
+      actionName,
+      result
+    );
+    this.emit();
+    return clone(this.state.taskTracker);
+  }
+  clearTaskTracker() {
+    this.state.taskTracker = null;
+    this.emit();
+  }
+  getTaskTrackerContext() {
+    return formatTaskTracker(this.state.taskTracker);
+  }
   // --- Speedee Flow State ---
   startFlow(goal, steps, startUrl) {
     const flow = {