@quanta-intellect/vessel-browser 0.1.144 → 0.1.146

package/out/main/index.js

@@ -682,15 +682,6 @@ function loadTrustedAppURL(wc, url) {
   }
   return wc.loadURL(parsed.toString());
 }
-const urlSafety = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  assertPermittedNavigationURL,
-  assertSafeURL,
-  isSafeNavigationURL,
-  loadInternalDataURL,
-  loadPermittedNavigationURL,
-  loadTrustedAppURL
-}, Symbol.toStringTag, { value: "Module" }));
 const MAX_CUSTOM_HISTORY = 50;
 const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 const logger$B = createLogger("Tab");
@@ -1467,7 +1458,12 @@ function loadJsonFile({
     const decoded = decodeStoredData(raw, secure);
     return parse(JSON.parse(decoded));
   } catch (err) {
-    logger$A.warn(`Failed to load ${filePath2}, using fallback:`, err);
+    const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (isMissingFile) {
+      logger$A.info(`Persistence file not found; using fallback defaults: ${filePath2}`);
+    } else {
+      logger$A.warn(`Failed to load ${filePath2}, using fallback:`, err);
+    }
     return fallback;
   }
 }
@@ -3867,7 +3863,14 @@ const AIChannels = {
   AGENT_CHECKPOINT_UPDATE_NOTE: "agent:checkpoint-update-note",
   AGENT_UNDO_LAST_ACTION: "agent:undo-last-action",
   AGENT_SESSION_CAPTURE: "agent:session-capture",
-  AGENT_SESSION_RESTORE: "agent:session-restore"
+  AGENT_SESSION_RESTORE: "agent:session-restore",
+  AGENT_TASK_START: "agent:task-start",
+  AGENT_TASK_UPDATE: "agent:task-update",
+  AGENT_TASK_NOTE: "agent:task-note",
+  AGENT_TASK_BLOCKER: "agent:task-blocker",
+  AGENT_TASK_RESOLVE: "agent:task-resolve",
+  AGENT_TASK_ABANDON: "agent:task-abandon",
+  AGENT_TASK_CLEAR: "agent:task-clear"
 };
 const AutofillChannels = {
   AUTOFILL_LIST: "autofill:list",
@@ -7794,6 +7797,96 @@ function isClickReadLoop(names) {
   }
   return clickReadPairs >= 2;
 }
+const CLICK_READ_LOOP_SUPPRESS_THRESHOLD = 3;
+function classifyClickFailure(output) {
+  if (/Error\[hidden\]/i.test(output)) return "hidden";
+  if (/Error\[stale-index\]/i.test(output)) return "stale";
+  if (/^\s*Error:/i.test(output)) return "other";
+  return null;
+}
+function buildClickReadLoopIntervention(strikes, lastClickFailureKind) {
+  if (strikes <= 0) return null;
+  if (strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+    const lines = [
+      `Error: Suppressed repeated click — you have alternated click and read_page ${strikes} times without making progress and the clicks are not landing.`,
+      `Stop calling click. Instead do one of: scroll (scroll or scroll_to_element) to load more of the page then read_page to refresh, inspect_element on a specific indexed result, or answer from the results already visible in the conversation.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The last click target was hidden / not laid out — scrolling toward it first usually reveals it.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The last click target was stale — refresh page state with read_page and choose a currently listed target before clicking again.`
+      );
+    }
+    return { kind: "suppress", message: lines.join("\n") };
+  }
+  if (strikes >= 2) {
+    const lines = [
+      `[System] You are alternating between click and read_page without advancing the task, and the last click did not complete.`,
+      `The click result already includes a page snapshot, so do not read_page after every click.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The click failed on a hidden element — call scroll (scroll or scroll_to_element) to reveal it, then read_page to refresh visible elements, before clicking again.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The click failed on a stale element index — call read_page to refresh current indexes before clicking again.`
+      );
+    } else {
+      lines.push(
+        `If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+      );
+    }
+    return { kind: "nudge", message: lines.join("\n") };
+  }
+  return {
+    kind: "nudge",
+    message: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+  };
+}
+class ClickReadLoopGuard {
+  recentToolNames = [];
+  strikes = 0;
+  lastClickFailureKind = null;
+  beforeTool(toolName) {
+    if (toolName === "click" && this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD && isClickReadLoop(this.recentToolNames)) {
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+  afterToolResult(toolName, output, succeeded) {
+    if (toolName === "click") {
+      this.lastClickFailureKind = succeeded ? null : classifyClickFailure(output);
+    }
+    this.recentToolNames.push(toolName);
+    if (this.recentToolNames.length > 8) this.recentToolNames.shift();
+    if (toolName === "click" && succeeded) {
+      this.strikes = 0;
+      return null;
+    }
+    if (toolName !== "click" && toolName !== "read_page") {
+      this.strikes = 0;
+      return null;
+    }
+    if (isClickReadLoop(this.recentToolNames) && this.lastClickFailureKind) {
+      this.strikes += 1;
+      if (this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+        return null;
+      }
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+}
 const TERMINAL_TOOL_RESULT = "__VESSEL_TERMINAL_TOOL_RESULT__";
 const logger$w = createLogger("PromptCache");
 function shortHash(value) {
@@ -7954,8 +8047,7 @@ class AnthropicProvider {
     try {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
-      const recentToolNames = [];
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         const stream = this.client.messages.stream(
@@ -8062,6 +8154,7 @@ class AnthropicProvider {
           break;
         }
         const toolResults = [];
+        const loopNudges = [];
         for (const tb of toolUseBlocks) {
           if (tb._malformedArgs !== void 0) {
             onChunk(`
@@ -8075,6 +8168,19 @@ class AnthropicProvider {
             });
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tb.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: clickLoopPreflight.message,
+              is_error: true
+            });
+            continue;
+          }
           const argSummary = [tb.input.url, tb.input.query, tb.input.text, tb.input.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tb.name}${argSummary ? ":" + argSummary : ""}>>
@@ -8089,6 +8195,7 @@ class AnthropicProvider {
           if (result === TERMINAL_TOOL_RESULT) {
             return;
           }
+          const toolSucceeded = !/^Error:/i.test(result.trim());
           let parsedRich = null;
           try {
             const parsed = JSON.parse(result);
@@ -8120,16 +8227,18 @@ class AnthropicProvider {
               content: result
             });
           }
-          recentToolNames.push(tb.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tb.name,
+            result,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
+            loopNudges.push(clickLoopIntervention.message);
+          }
         }
         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.`
-          });
+        for (const nudge of loopNudges) {
+          messages.push({ role: "user", content: nudge });
         }
       }
       if (iterationsUsed >= maxIterations) {
@@ -8683,6 +8792,106 @@ function recoverTextEncodedToolCalls(text, availableToolNames) {
   }
   return recovered;
 }
+function findInlineToolMarkerBodies(text) {
+  const bodies = [];
+  const lowerText = text.toLowerCase();
+  let searchIndex = 0;
+  while (searchIndex < text.length) {
+    const start = lowerText.indexOf("<<tool", searchIndex);
+    if (start === -1) break;
+    let quote = null;
+    let escaped = false;
+    let end = -1;
+    for (let index = start + 2; index < text.length - 1; index += 1) {
+      const char = text[index];
+      if (quote) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === quote) {
+          quote = null;
+        }
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        continue;
+      }
+      if (char === ">" && text[index + 1] === ">") {
+        end = index;
+        break;
+      }
+    }
+    if (end === -1) {
+      searchIndex = start + 2;
+      continue;
+    }
+    bodies.push(text.slice(start + 2, end));
+    searchIndex = end + 2;
+  }
+  return bodies;
+}
+function recoverInlineToolMarkerToolCalls(text, availableToolNames) {
+  const recovered = [];
+  for (const markerBody of findInlineToolMarkerBodies(text)) {
+    const match = markerBody.trim().match(/^tool[:=]([a-z_][a-z0-9_]*)(?:[:=]([\s\S]*))?$/i);
+    if (!match) continue;
+    const rawName = match[1] ?? "";
+    const rawArgs = (match[2] ?? "").trim();
+    const resolvedName = resolveToolCallName(
+      rawName,
+      {},
+      availableToolNames
+    );
+    if (!availableToolNames.has(resolvedName)) continue;
+    let parsedArgs = null;
+    if (rawArgs.startsWith("{")) {
+      const repaired = parseToolArgsWithRepair(resolvedName, rawArgs);
+      if (repaired) {
+        parsedArgs = repaired.args;
+      }
+    }
+    if (!parsedArgs) {
+      const kvArgs = {};
+      const kvPattern = /([a-z_][a-z0-9_]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^,\s]*))/gi;
+      let kvMatch;
+      while ((kvMatch = kvPattern.exec(rawArgs)) !== null) {
+        const key2 = kvMatch[1];
+        const value = kvMatch[2] ?? kvMatch[3] ?? kvMatch[4] ?? "";
+        kvArgs[key2] = value;
+      }
+      if (Object.keys(kvArgs).length > 0) {
+        parsedArgs = kvArgs;
+      }
+    }
+    if (!parsedArgs && rawArgs) {
+      const repaired = parseToolArgsWithRepair(resolvedName, rawArgs);
+      if (repaired) {
+        parsedArgs = repaired.args;
+      }
+    }
+    if (!parsedArgs) {
+      parsedArgs = {};
+    }
+    recovered.push({
+      id: `recovered_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      name: resolvedName,
+      argsJson: JSON.stringify(parsedArgs)
+    });
+  }
+  return recovered;
+}
+function recoverAssistantTextToolCalls(text, availableToolNames) {
+  const textEncodedCalls = recoverTextEncodedToolCalls(text, availableToolNames);
+  if (textEncodedCalls.length > 0) return textEncodedCalls;
+  const inlineMarkerCalls = recoverInlineToolMarkerToolCalls(
+    text,
+    availableToolNames
+  );
+  if (inlineMarkerCalls.length > 0) return inlineMarkerCalls;
+  return recoverNarratedActionToolCalls(text, availableToolNames);
+}
 function recoverNarratedActionToolCalls(text, availableToolNames) {
   const trimmed = text.trim();
   if (!trimmed) return [];
@@ -9320,10 +9529,9 @@ class OpenAICompatProvider {
       let highlightCompletionRecoveryCount = 0;
       let compactCorrectionCount = 0;
       const recentCompactToolSignatures = [];
-      const recentToolNames = [];
       const successfulToolNames = [];
       const searchLoopGuard = new SearchLoopGuard(isSearchContextResettingTool);
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         let textAccum = "";
@@ -9398,22 +9606,13 @@ class OpenAICompatProvider {
           tc.name = resolveToolCallName(tc.name, parsedArgs, availableToolNames);
         }
         if (toolCalls.length === 0) {
-          const recoveredToolCalls = recoverTextEncodedToolCalls(
+          const recoveredToolCalls = recoverAssistantTextToolCalls(
             textAccum,
             availableToolNames
           );
           if (recoveredToolCalls.length > 0) {
             toolCalls = recoveredToolCalls;
             if (textAccum.trim()) onChunk("<<erase_prev>>");
-          } else {
-            const narratedToolCalls = recoverNarratedActionToolCalls(
-              textAccum,
-              availableToolNames
-            );
-            if (narratedToolCalls.length > 0) {
-              toolCalls = narratedToolCalls;
-              if (textAccum.trim()) onChunk("<<erase_prev>>");
-            }
           }
         }
         logAgentLoopDebug({
@@ -9622,6 +9821,19 @@ class OpenAICompatProvider {
             }
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tc.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: clickLoopPreflight.message
+            });
+            compactCorrectionCount += 1;
+            continue;
+          }
           const argSummary = [args.url, args.query, args.text, args.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
@@ -9659,15 +9871,11 @@ class OpenAICompatProvider {
             searchToolQuery,
             toolSucceeded
           );
-          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.`
-            });
-          }
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tc.name,
+            toolContent,
+            toolSucceeded
+          );
           compactCorrectionCount = 0;
           iterationToolResultPreviews.push(toolContent);
           messages.push({
@@ -9675,6 +9883,9 @@ class OpenAICompatProvider {
             tool_call_id: tc.id,
             content: toolContent
           });
+          if (clickLoopIntervention?.kind === "nudge") {
+            messages.push({ role: "user", content: clickLoopIntervention.message });
+          }
         }
         const followUpReminder = followUpReminderForProfile(
           this.agentToolProfile,
@@ -10346,12 +10557,25 @@ function buildCodexFlightPriceEvidenceRecoveryInput(userMessage, assistantText,
     ]
   };
 }
-function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1) {
+function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1, errorOutput = "") {
   const stateReminder = buildLatestStateReminder(latestToolResultPreview);
+  const clickFailureKind = classifyClickFailure(errorOutput);
   const lines = [
-    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`,
-    `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`
   ];
+  if (clickFailureKind === "hidden") {
+    lines.push(
+      `The click target was hidden / not laid out (collapsed, lazy-loaded, or virtual-scroll). Call scroll or scroll_to_element toward it to reveal it, then read_page to refresh visible elements, before clicking again — or inspect_element on the intended index, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else if (clickFailureKind === "stale") {
+    lines.push(
+      `The click target was stale — the page changed since the last snapshot. Call read_page to refresh current indexes, then choose a currently listed target, inspect_element on the intended element, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else {
+    lines.push(
+      `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    );
+  }
   if (failedClickCount >= 2) {
     lines.push(
       `You have already had multiple failed clicks without making page progress. Do not keep clicking similar search result titles. Use the latest read_page/search result text to answer, or inspect a specific indexed result/control only if essential.`
@@ -10562,8 +10786,7 @@ class CodexProvider {
     let flightPriceEvidenceRecoveryCount = 0;
     let correctionCount = 0;
     const recentToolSignatures = [];
-    const recentToolNames = [];
-    let clickReadLoopNudged = false;
+    const clickReadLoopGuard = new ClickReadLoopGuard();
     let latestToolResultPreview = null;
     let failedClickCountSinceProgress = 0;
     const searchLoopGuard = new SearchLoopGuard(isRealProgressTool);
@@ -10587,11 +10810,10 @@ class CodexProvider {
           (item) => item.type === "function_call"
         );
         if (functionCalls.length === 0) {
-          const recoveredTextCalls = recoverTextEncodedToolCalls(
+          const recoveredCalls = recoverAssistantTextToolCalls(
             result.text,
             availableToolNames
           );
-          const recoveredCalls = recoveredTextCalls.length > 0 ? recoveredTextCalls : recoverNarratedActionToolCalls(result.text, availableToolNames);
           if (recoveredCalls.length > 0) {
             if (result.text.trim()) onChunk("<<erase_prev>>");
             functionCalls = recoveredCalls.map((toolCall) => ({
@@ -10720,6 +10942,22 @@ ${latestToolResultPreview || ""}`
             correctionCount += 1;
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(
+            prepared.prepared.name
+          );
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            const suppressed = createCodexToolOutput(
+              prepared.prepared.callId,
+              clickLoopPreflight.message
+            );
+            currentInput.push(suppressed);
+            latestToolResultPreview = previewToolResult(suppressed.output);
+            correctionCount += 1;
+            continue;
+          }
           const output = await executePreparedCodexFunctionCall(
             prepared.prepared,
             onChunk,
@@ -10747,7 +10985,8 @@ ${latestToolResultPreview || ""}`
               buildCodexFailedClickRecoveryInput(
                 summarizeToolArg(prepared.prepared.args),
                 latestToolResultPreview,
-                failedClickCountSinceProgress
+                failedClickCountSinceProgress,
+                outputText
               )
             );
           }
@@ -10755,17 +10994,16 @@ ${latestToolResultPreview || ""}`
           if (recentToolSignatures.length > 4) {
             recentToolSignatures.shift();
           }
-          recentToolNames.push(prepared.prepared.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
-          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-            clickReadLoopNudged = true;
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            prepared.prepared.name,
+            outputText,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
             currentInput.push({
               type: "message",
               role: "user",
-              content: [{
-                type: "input_text",
-                text: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
-              }]
+              content: [{ type: "input_text", text: clickLoopIntervention.message }]
             });
           }
           correctionCount = 0;
@@ -11989,8 +12227,7 @@ function pageBusyError(action) {
   return `Error: Page is still busy; ${action} timed out waiting for page scripts. Retry in a moment.`;
 }
 async function loadPermittedUrl(wc, url) {
-  const { assertPermittedNavigationURL: assertPermittedNavigationURL2 } = await Promise.resolve().then(() => urlSafety);
-  assertPermittedNavigationURL2(url);
+  assertPermittedNavigationURL(url);
   await wc.loadURL(url);
 }
 async function executePageScript(wc, script, options) {
@@ -16330,6 +16567,60 @@ async function clickElement(wc, selector) {
         }));
       }
 
+      // Sum offsetTop up the offsetParent chain until reaching "container",
+      // giving the element's vertical position within that scroll container.
+      function offsetTopWithin(el, container) {
+        let top = 0;
+        let node = el;
+        while (node && node !== container) {
+          top += node.offsetTop || 0;
+          node = node.offsetParent;
+        }
+        return top;
+      }
+
+      function nearestScrollableAncestor(el) {
+        let node = el.parentElement;
+        while (node) {
+          if (node instanceof HTMLElement) {
+            const style = window.getComputedStyle(node);
+            if (
+              (style.overflowY === "auto" || style.overflowY === "scroll") &&
+              node.scrollHeight > node.clientHeight
+            ) {
+              return node;
+            }
+          }
+          node = node.parentElement;
+        }
+        return null;
+      }
+
+      // Wait for the element to gain a non-zero layout box, polling for up to
+      // maxFrames animation frames. Lazy / virtual-scroll renderers
+      // (content-visibility, intersection-triggered list items) often lay out
+      // a frame or two after the scroller moves. Falls back to setTimeout when
+      // the window is hidden (requestAnimationFrame does not fire then).
+      function waitForBox(el, maxFrames) {
+        return new Promise((resolve) => {
+          let frames = 0;
+          const rafAvailable =
+            typeof requestAnimationFrame === "function" &&
+            document.visibilityState === "visible";
+          const schedule = rafAvailable
+            ? (cb) => requestAnimationFrame(cb)
+            : (cb) => setTimeout(cb, 16);
+          const check = () => {
+            const r = el.getBoundingClientRect();
+            if (r.width > 0 && r.height > 0) return resolve(true);
+            if (frames >= maxFrames) return resolve(false);
+            frames += 1;
+            schedule(check);
+          };
+          check();
+        });
+      }
+
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return { error: "Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh." };
 
@@ -16337,21 +16628,26 @@ async function clickElement(wc, selector) {
         el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
       }
 
-      await new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-          if (settled) return;
-          settled = true;
-          resolve(undefined);
-        };
-        if (
-          typeof requestAnimationFrame === "function" &&
-          document.visibilityState === "visible"
-        ) {
-          requestAnimationFrame(() => finish());
+      // Give the renderer a brief grace to lay the element out after the
+      // initial scroll. Already-visible elements resolve on the first check.
+      let revealed = await waitForBox(el, 4);
+
+      // scrollIntoView is a no-op on zero-rect elements (collapsed, lazy, or
+      // virtual-scroll content). Force the nearest scrollable ancestor to bring
+      // the element's offset position into view, then wait longer for the
+      // renderer to produce a layout box. This recovers many hidden targets
+      // without the model having to scroll manually.
+      if (!revealed) {
+        const scroller = nearestScrollableAncestor(el);
+        if (scroller) {
+          const targetTop = offsetTopWithin(el, scroller) - scroller.clientHeight / 2;
+          scroller.scrollTop = Math.max(0, targetTop);
         }
-        setTimeout(finish, 32);
-      });
+        if (el instanceof HTMLElement) {
+          el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+        }
+        revealed = await waitForBox(el, 24);
+      }
 
       const rect = el.getBoundingClientRect();
       if (rect.width <= 0 || rect.height <= 0) {
@@ -17914,9 +18210,13 @@ Go back and select a different product.`;
   const clickText = `Clicked: ${elInfo.text}${tagLabel}`;
   const clickResult = await clickElement(wc, selector);
   if (clickResult.startsWith("Error:")) return clickResult;
-  await waitForPotentialNavigation$1(wc, beforeUrl);
+  const initialNavigationWaitMs = /DOM activation/i.test(clickResult) && !elInfo.href ? 800 : void 0;
+  await waitForPotentialNavigation$1(wc, beforeUrl, initialNavigationWaitMs);
   const afterUrl = wc.getURL();
   if (afterUrl !== beforeUrl) {
+    if (/DOM activation/i.test(clickResult)) {
+      return `${clickText} -> ${afterUrl} (recovered via DOM activation)`;
+    }
     return `${clickText} -> ${afterUrl}`;
   }
   const overlayHint = await detectPostClickOverlay(wc);
@@ -17943,6 +18243,9 @@ ${overlayHint}`;
     }
     return `${clickText} (${clickResult})${await buildCartSuccessSuffix(wc, beforeUrl)}`;
   }
+  if (/DOM activation/i.test(clickResult) && (!elInfo.href || elInfo.target === "_blank")) {
+    return `${clickText} (${clickResult})`;
+  }
   const activationResult = await activateElement(wc, selector);
   if (!activationResult.startsWith("Error:")) {
     await waitForPotentialNavigation$1(wc, beforeUrl);
@@ -23312,7 +23615,10 @@ Recent checkpoints:
 ${input.recentCheckpoints || "- none"}
 
 Task tracker:
-${input.taskTrackerContext || "- none"}`;
+${input.taskTrackerContext || "- none"}
+
+Task memory:
+${input.taskMemoryContext || "- none"}`;
 }
 function buildAgentSystemPrompt(input) {
   const instructionBlocks = input.profile === "compact" ? [
@@ -23693,6 +23999,7 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
       const runtimeState = runtime2.getState();
       const recentCheckpoints = runtimeState.checkpoints.slice(-3).map((item) => `- ${item.name} (${item.id})`).join("\n");
       const taskTrackerContext = runtime2.getTaskTrackerContext();
+      const taskMemoryContext = runtime2.getTaskMemoryContext();
       const activeTabTitle = pageContent.title || "(untitled)";
       const activeTabUrl = pageContent.url || activeWebContents.getURL();
       const allTabs = tabManager.getAllStates();
@@ -23711,7 +24018,8 @@ All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.ti
         approvalMode: runtimeState.supervisor.approvalMode,
         pendingApprovals: runtimeState.supervisor.pendingApprovals.length,
         recentCheckpoints: recentCheckpoints || "- none",
-        taskTrackerContext: taskTrackerContext || "- none"
+        taskTrackerContext: taskTrackerContext || "- none",
+        taskMemoryContext: taskMemoryContext || "- none"
       });
       const actionCtx = {
         tabManager,
@@ -23740,6 +24048,9 @@ All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.ti
         let isError = false;
         try {
           output = await executeAction(name, args, actionCtx);
+          if (/^\s*Error:/i.test(output)) {
+            isError = true;
+          }
           if (provider.agentToolProfile === "compact") {
             runtime2.updateTaskTracker(name, output);
             const trackerCtx = runtime2.getTaskTrackerContext();
@@ -24311,6 +24622,17 @@ function setMcpHealth(update) {
 }
 const ApprovalModeSchema = zod.z.enum(["auto", "confirm-dangerous", "manual"]);
 const CheckpointIdSchema = zod.z.string().min(1);
+const TaskTextSchema = zod.z.string().trim().min(1).max(2e4);
+const OptionalTaskTextSchema = zod.z.string().trim().max(2e4).optional();
+const OptionalNullableTaskTextSchema = zod.z.string().trim().max(2e4).nullable().optional();
+const TaskFactsSchema = zod.z.record(
+  zod.z.string().trim().min(1).max(200),
+  zod.z.string().max(2e4)
+);
+const TaskMemoryPatchSchema = zod.z.object({
+  nextStep: OptionalNullableTaskTextSchema,
+  facts: TaskFactsSchema.optional()
+});
 function registerAgentRuntimeHandlers(runtime2, chromeView, sidebarView, sendToRendererViews) {
   let runtimeUpdateTimer = null;
   let pendingRuntimeState = null;
@@ -24403,6 +24725,45 @@ function registerAgentRuntimeHandlers(runtime2, chromeView, sidebarView, sendToR
       return runtime2.restoreSession(snapshot2);
     }
   );
+  electron.ipcMain.handle(Channels.AGENT_TASK_START, (event, goal) => {
+    assertTrustedIpcSender(event);
+    return runtime2.startTaskMemory(parseIpc(TaskTextSchema, goal, "goal"));
+  });
+  electron.ipcMain.handle(
+    Channels.AGENT_TASK_UPDATE,
+    (event, patch) => {
+      assertTrustedIpcSender(event);
+      return runtime2.updateTaskMemory(
+        parseIpc(TaskMemoryPatchSchema, patch ?? {}, "patch")
+      );
+    }
+  );
+  electron.ipcMain.handle(Channels.AGENT_TASK_NOTE, (event, text) => {
+    assertTrustedIpcSender(event);
+    return runtime2.addTaskNote(parseIpc(TaskTextSchema, text, "text"));
+  });
+  electron.ipcMain.handle(Channels.AGENT_TASK_BLOCKER, (event, blocker) => {
+    assertTrustedIpcSender(event);
+    const validated = blocker == null ? null : parseIpc(OptionalNullableTaskTextSchema, blocker, "blocker");
+    return runtime2.setTaskBlocker(validated ?? null);
+  });
+  electron.ipcMain.handle(Channels.AGENT_TASK_RESOLVE, (event, summary) => {
+    assertTrustedIpcSender(event);
+    return runtime2.resolveTaskMemory(
+      summary == null ? void 0 : parseIpc(OptionalTaskTextSchema, summary, "summary")
+    );
+  });
+  electron.ipcMain.handle(Channels.AGENT_TASK_ABANDON, (event, reason) => {
+    assertTrustedIpcSender(event);
+    return runtime2.abandonTaskMemory(
+      reason == null ? void 0 : parseIpc(OptionalTaskTextSchema, reason, "reason")
+    );
+  });
+  electron.ipcMain.handle(Channels.AGENT_TASK_CLEAR, (event) => {
+    assertTrustedIpcSender(event);
+    runtime2.clearTaskMemory();
+    return null;
+  });
 }
 function asTextResponse$1(text) {
   return { content: [{ type: "text", text }] };
@@ -28129,6 +28490,137 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
     }
   );
 }
+function registerTaskMemoryTools(server, _tabManager, runtime2) {
+  server.registerTool(
+    "task_start",
+    {
+      title: "Start Task",
+      description: "Start tracking a task. Creates a task memory record with a goal that persists across actions and browser navigation. Use this at the beginning of a multi-step task so the human supervisor can see what you are working on.",
+      inputSchema: {
+        goal: zod.z.string().describe("What this task aims to accomplish"),
+        nextStep: zod.z.string().optional().describe("The first step you plan to take"),
+        facts: zod.z.record(zod.z.string()).optional().describe("Key-value facts relevant to this task (e.g. { username: alice })")
+      }
+    },
+    async ({ goal, nextStep, facts }) => {
+      const task = runtime2.startTaskMemory(goal, {
+        nextStep: nextStep ?? null,
+        facts: facts ?? {}
+      });
+      return asTextResponse(
+        `Task started: ${task.goal}
+Status: ${task.status}${task.nextStep ? `
+Next step: ${task.nextStep}` : ""}`
+      );
+    }
+  );
+  server.registerTool(
+    "task_update",
+    {
+      title: "Update Task",
+      description: "Update the current task's next step or facts. Facts are merged with existing facts. Use this to record progress and keep the human supervisor informed.",
+      inputSchema: {
+        nextStep: zod.z.string().optional().describe("The next step you plan to take"),
+        facts: zod.z.record(zod.z.string()).optional().describe("Key-value facts to merge into the task (existing keys are overwritten)")
+      }
+    },
+    async ({ nextStep, facts }) => {
+      const updated = runtime2.updateTaskMemory({
+        nextStep,
+        facts
+      });
+      if (!updated) return asTextResponse("No active task to update. Start one with task_start first.");
+      return asTextResponse(
+        `Task updated: ${updated.goal}
+Status: ${updated.status}${updated.nextStep ? `
+Next step: ${updated.nextStep}` : ""}${Object.keys(updated.facts).length > 0 ? `
+Facts: ${Object.entries(updated.facts).map(([k, v]) => `${k}=${v}`).join(", ")}` : ""}`
+      );
+    }
+  );
+  server.registerTool(
+    "task_note",
+    {
+      title: "Add Task Note",
+      description: "Add a note to the current task. Use this to record observations, intermediate results, or context for the human supervisor.",
+      inputSchema: {
+        text: zod.z.string().describe("The note text to add")
+      }
+    },
+    async ({ text }) => {
+      const updated = runtime2.addTaskNote(text);
+      if (!updated) return asTextResponse("No active task to add a note to. Start one with task_start first.");
+      return asTextResponse(`Note added to task: ${updated.goal}`);
+    }
+  );
+  server.registerTool(
+    "task_blocker",
+    {
+      title: "Set or Clear Task Blocker",
+      description: "Mark the task as blocked with a reason, or clear a blocker to resume. Use this when you are stuck and need human input to continue.",
+      inputSchema: {
+        blocker: zod.z.string().optional().describe("Description of what is blocking progress. Omit or empty string to clear a blocker.")
+      }
+    },
+    async ({ blocker }) => {
+      const updated = runtime2.setTaskBlocker(blocker?.trim() || null);
+      if (!updated) return asTextResponse("No active task. Start one with task_start first.");
+      if (updated.blocker) {
+        return asTextResponse(`Task blocked: ${updated.blocker}
+Status: ${updated.status}`);
+      }
+      return asTextResponse(`Blocker cleared. Task: ${updated.goal}
+Status: ${updated.status}`);
+    }
+  );
+  server.registerTool(
+    "task_resolve",
+    {
+      title: "Resolve Task",
+      description: "Mark the current task as completed. Optionally add a summary note. Use this when the task goal has been achieved.",
+      inputSchema: {
+        summary: zod.z.string().optional().describe("Brief summary of the completed task")
+      }
+    },
+    async ({ summary }) => {
+      const resolved = runtime2.resolveTaskMemory(summary);
+      if (!resolved) return asTextResponse("No active task to resolve. Start one with task_start first.");
+      return asTextResponse(
+        `Task completed: ${resolved.goal}${resolved.notes.length > 0 ? `
+Notes: ${resolved.notes.length} note(s)` : ""}`
+      );
+    }
+  );
+  server.registerTool(
+    "task_abandon",
+    {
+      title: "Abandon Task",
+      description: "Mark the current task as abandoned. Use this when the task cannot be completed or is no longer relevant.",
+      inputSchema: {
+        reason: zod.z.string().optional().describe("Reason for abandoning the task")
+      }
+    },
+    async ({ reason }) => {
+      const abandoned = runtime2.abandonTaskMemory(reason);
+      if (!abandoned) return asTextResponse("No active task to abandon. Start one with task_start first.");
+      return asTextResponse(
+        `Task abandoned: ${abandoned.goal}${reason ? ` (${reason})` : ""}`
+      );
+    }
+  );
+  server.registerTool(
+    "task_status",
+    {
+      title: "Task Status",
+      description: "Check the current task memory status including goal, progress, notes, and blocker."
+    },
+    async () => {
+      const ctx = runtime2.getTaskMemoryContext();
+      if (!ctx) return asTextResponse("No active task. Start one with task_start.");
+      return asTextResponse(ctx);
+    }
+  );
+}
 function registerMacroTools(server, tabManager, runtime2) {
   server.registerTool(
     "fill_form",
@@ -29429,6 +29921,7 @@ function registerTools(server, tabManager, runtime2) {
   registerSessionTools(server, tabManager, runtime2);
   registerMemoryTools(server, tabManager, runtime2);
   registerFlowTools(server, tabManager, runtime2);
+  registerTaskMemoryTools(server, tabManager, runtime2);
   registerMacroTools(server, tabManager, runtime2);
   registerVaultTools(server, tabManager);
   registerMetricsTools(server, tabManager, runtime2);
@@ -32672,6 +33165,121 @@ function formatTaskTracker(state2) {
 ${lines.join("\n")}
 ---`;
 }
+function createTaskMemory(goal, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: crypto$1.randomUUID(),
+    goal: goal.trim(),
+    status: "active",
+    blocker: null,
+    notes: [],
+    nextStep: options.nextStep?.trim() || null,
+    facts: { ...options.facts ?? {} },
+    startedAt: now,
+    updatedAt: now,
+    completedAt: null
+  };
+}
+function updateTaskMemory(task, patch) {
+  const updated = {
+    ...task,
+    nextStep: patch.nextStep !== void 0 ? patch.nextStep : task.nextStep,
+    facts: {
+      ...task.facts,
+      ...patch.facts ?? {}
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return updated;
+}
+function addTaskNote(task, text) {
+  const note = {
+    id: crypto$1.randomUUID(),
+    text: text.trim(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const notes = [...task.notes, note].slice(-50);
+  return {
+    ...task,
+    notes,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setTaskBlocker(task, blocker) {
+  const status = blocker ? "blocked" : task.status === "blocked" ? "active" : task.status;
+  return {
+    ...task,
+    status,
+    blocker,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function resolveTaskMemory(task, summary) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let notes = task.notes;
+  if (summary?.trim()) {
+    const note = {
+      id: crypto$1.randomUUID(),
+      text: summary.trim(),
+      createdAt: now
+    };
+    notes = [...task.notes, note].slice(-50);
+  }
+  return {
+    ...task,
+    status: "completed",
+    blocker: null,
+    notes,
+    completedAt: now,
+    updatedAt: now
+  };
+}
+function abandonTaskMemory(task, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let notes = task.notes;
+  if (reason?.trim()) {
+    const note = {
+      id: crypto$1.randomUUID(),
+      text: `Abandoned: ${reason.trim()}`,
+      createdAt: now
+    };
+    notes = [...task.notes, note].slice(-50);
+  }
+  return {
+    ...task,
+    status: "abandoned",
+    blocker: null,
+    notes,
+    completedAt: now,
+    updatedAt: now
+  };
+}
+function formatTaskMemory(task) {
+  if (!task) return "";
+  const lines = [
+    "--- Task Memory ---",
+    `Goal: ${task.goal}`,
+    `Status: ${task.status}${task.blocker ? ` (blocked: ${task.blocker})` : ""}`
+  ];
+  if (task.nextStep) {
+    lines.push(`Next step: ${task.nextStep}`);
+  }
+  if (Object.keys(task.facts).length > 0) {
+    lines.push("Facts:");
+    for (const [key2, value] of Object.entries(task.facts)) {
+      lines.push(`  ${key2}: ${value}`);
+    }
+  }
+  if (task.notes.length > 0) {
+    lines.push("Notes:");
+    for (const note of task.notes.slice(-10)) {
+      const time = note.createdAt.slice(11, 16);
+      lines.push(`  [${time}] ${note.text}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
 const MAX_TRANSCRIPT_TEXT_LENGTH = 8e3;
 const PERSIST_DEBOUNCE_MS = 500;
 const INTERRUPTED_ACTION_STATUSES = /* @__PURE__ */ new Set([
@@ -32701,6 +33309,7 @@ function getRuntimeStatePath() {
 }
 function sanitizePersistence(persisted) {
   const recoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const persistedTaskMemory = persisted?.taskMemory?.completedAt ? null : persisted?.taskMemory ?? null;
   const actions = Array.isArray(persisted?.actions) ? persisted.actions.slice(-120).map(
     (action) => INTERRUPTED_ACTION_STATUSES.has(action.status) ? {
       ...action,
@@ -32722,7 +33331,8 @@ function sanitizePersistence(persisted) {
     transcript: [],
     mcpStatus: "stopped",
     flowState: null,
-    taskTracker: null
+    taskTracker: null,
+    taskMemory: persistedTaskMemory
   };
 }
 class AgentRuntime {
@@ -32809,7 +33419,8 @@ class AgentRuntime {
       name: name?.trim() || `Checkpoint ${this.state.checkpoints.length + 1}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       note: note?.trim() || void 0,
-      snapshot: snapshot2
+      snapshot: snapshot2,
+      taskMemory: this.state.taskMemory ? clone(this.state.taskMemory) : null
     };
     this.state.checkpoints = [...this.state.checkpoints, checkpoint].slice(
       -20
@@ -32822,6 +33433,7 @@ class AgentRuntime {
     const checkpoint = this.state.checkpoints.find((item) => item.id === checkpointId) || null;
     if (!checkpoint) return null;
     this.tabManager.restoreSession(checkpoint.snapshot);
+    this.state.taskMemory = checkpoint.taskMemory ? clone(checkpoint.taskMemory) : null;
     this.captureSession(`Restored ${checkpoint.name}`);
     return clone(checkpoint);
   }
@@ -32938,6 +33550,54 @@ class AgentRuntime {
   getTaskTrackerContext() {
     return formatTaskTracker(this.state.taskTracker);
   }
+  // --- Task Memory ---
+  startTaskMemory(goal, options) {
+    this.state.taskMemory = createTaskMemory(goal, options);
+    this.emit();
+    return clone(this.state.taskMemory);
+  }
+  updateTaskMemory(patch) {
+    if (!this.state.taskMemory || this.state.taskMemory.completedAt) return null;
+    this.state.taskMemory = updateTaskMemory(this.state.taskMemory, patch);
+    this.emit();
+    return clone(this.state.taskMemory);
+  }
+  addTaskNote(text) {
+    if (!this.state.taskMemory || this.state.taskMemory.completedAt) return null;
+    this.state.taskMemory = addTaskNote(this.state.taskMemory, text);
+    this.emit();
+    return clone(this.state.taskMemory);
+  }
+  setTaskBlocker(blocker) {
+    if (!this.state.taskMemory || this.state.taskMemory.completedAt) return null;
+    this.state.taskMemory = setTaskBlocker(
+      this.state.taskMemory,
+      blocker
+    );
+    this.emit();
+    return clone(this.state.taskMemory);
+  }
+  resolveTaskMemory(summary) {
+    if (!this.state.taskMemory || this.state.taskMemory.completedAt) return null;
+    const resolved = resolveTaskMemory(this.state.taskMemory, summary);
+    this.state.taskMemory = null;
+    this.emit();
+    return clone(resolved);
+  }
+  abandonTaskMemory(reason) {
+    if (!this.state.taskMemory || this.state.taskMemory.completedAt) return null;
+    const abandoned = abandonTaskMemory(this.state.taskMemory, reason);
+    this.state.taskMemory = null;
+    this.emit();
+    return clone(abandoned);
+  }
+  clearTaskMemory() {
+    this.state.taskMemory = null;
+    this.emit();
+  }
+  getTaskMemoryContext() {
+    return formatTaskMemory(this.state.taskMemory);
+  }
   // --- Speedee Flow State ---
   startFlow(goal, steps, startUrl) {
     const flow = {
@@ -33163,7 +33823,8 @@ ${progress}
         lastError: this.state.supervisor.lastError
       },
       actions: this.state.actions.slice(-120),
-      checkpoints: this.state.checkpoints.slice(-20)
+      checkpoints: this.state.checkpoints.slice(-20),
+      taskMemory: this.state.taskMemory
     };
     return fs$1.promises.mkdir(path.dirname(getRuntimeStatePath()), { recursive: true }).then(
       () => fs$1.promises.writeFile(