@quanta-intellect/vessel-browser 0.1.67 → 0.1.69

package/out/main/index.js

@@ -65,6 +65,7 @@ const defaults = {
   domainPolicy: { allowedDomains: [], blockedDomains: [] },
   downloadPath: "",
   telemetryEnabled: true,
+  defaultSearchEngine: "duckduckgo",
   premium: {
     status: "free",
     customerId: "",
@@ -74,7 +75,7 @@ const defaults = {
     expiresAt: ""
   }
 };
-const SAVE_DEBOUNCE_MS$5 = 150;
+const SAVE_DEBOUNCE_MS$6 = 150;
 const CHAT_PROVIDER_SECRET_FILENAME = "vessel-chat-provider-secret";
 const logger$j = createLogger("Settings");
 const SETTABLE_KEYS = new Set(Object.keys(defaults));
@@ -232,7 +233,7 @@ function saveSettings() {
     if (saveDirty) {
       void persistNow();
     }
-  }, SAVE_DEBOUNCE_MS$5);
+  }, SAVE_DEBOUNCE_MS$6);
 }
 function setSetting(key, value) {
   loadSettings();
@@ -871,7 +872,7 @@ function createDebouncedJsonPersistence({
 }
 let state$4 = null;
 const listeners$2 = /* @__PURE__ */ new Set();
-const SAVE_DEBOUNCE_MS$4 = 250;
+const SAVE_DEBOUNCE_MS$5 = 250;
 function getHighlightsPath() {
   return path.join(electron.app.getPath("userData"), "vessel-highlights.json");
 }
@@ -889,15 +890,15 @@ function load$4() {
   });
   return state$4;
 }
-const persistence$4 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$4,
+const persistence$5 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$5,
   filePath: getHighlightsPath(),
   getValue: () => state$4,
   logLabel: "highlights",
   resetOnSchedule: true
 });
 function save$2() {
-  persistence$4.schedule();
+  persistence$5.schedule();
 }
 function emit$2() {
   if (!state$4) return;
@@ -979,7 +980,7 @@ function clearHighlightsForUrl(url) {
   return removed;
 }
 function flushPersist$4() {
-  return persistence$4.flush();
+  return persistence$5.flush();
 }
 const SKIP_TAGS_JS = "var SKIP_TAGS = {SCRIPT:1,STYLE:1,NOSCRIPT:1,TEMPLATE:1,IFRAME:1,SVG:1};";
 const CONTENT_ROOTS_JS = `
@@ -1551,7 +1552,7 @@ function persistHighlight(url, text) {
   return { success: true, text: capped, id: highlight.id };
 }
 const MAX_HISTORY_ENTRIES = 5e3;
-const SAVE_DEBOUNCE_MS$3 = 250;
+const SAVE_DEBOUNCE_MS$4 = 250;
 let state$3 = null;
 const listeners$1 = /* @__PURE__ */ new Set();
 function getHistoryPath() {
@@ -1571,14 +1572,14 @@ function load$3() {
   });
   return state$3;
 }
-const persistence$3 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$3,
+const persistence$4 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$4,
   filePath: getHistoryPath(),
   getValue: () => state$3,
   logLabel: "history"
 });
 function save$1() {
-  persistence$3.schedule();
+  persistence$4.schedule();
 }
 function emit$1() {
   if (!state$3) return;
@@ -1635,7 +1636,7 @@ function clearAll$1() {
   emit$1();
 }
 function flushPersist$3() {
-  return persistence$3.flush();
+  return persistence$4.flush();
 }
 const MAX_CONSOLE_ENTRIES = 500;
 const MAX_NETWORK_ENTRIES = 200;
@@ -2684,6 +2685,8 @@ const Channels = {
   AGENT_APPROVAL_RESOLVE: "agent:approval-resolve",
   AGENT_CHECKPOINT_CREATE: "agent:checkpoint-create",
   AGENT_CHECKPOINT_RESTORE: "agent:checkpoint-restore",
+  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",
   // Content
@@ -2691,6 +2694,7 @@ const Channels = {
   READER_MODE_TOGGLE: "reader:toggle",
   // UI state
   SIDEBAR_TOGGLE: "ui:sidebar-toggle",
+  SIDEBAR_NAVIGATE: "ui:sidebar-navigate",
   SIDEBAR_RESIZE: "ui:sidebar-resize",
   SIDEBAR_RESIZE_START: "ui:sidebar-resize-start",
   SIDEBAR_RESIZE_COMMIT: "ui:sidebar-resize-commit",
@@ -2707,6 +2711,7 @@ const Channels = {
   BOOKMARKS_GET: "bookmarks:get",
   BOOKMARKS_UPDATE: "bookmarks:update",
   BOOKMARK_SAVE: "bookmarks:save",
+  BOOKMARK_UPDATE: "bookmarks:update-item",
   BOOKMARK_REMOVE: "bookmarks:remove",
   BOOKMARK_ADD_CONTEXT_TO_CHAT: "bookmarks:add-context-to-chat",
   FOLDER_CREATE: "bookmarks:folder-create",
@@ -2786,6 +2791,7 @@ const Channels = {
   PAGE_DIFF_ACTIVITY: "page:diff-activity",
   PAGE_CHANGED: "page:changed",
   PAGE_DIFF_GET: "page:diff-get",
+  PAGE_DIFF_HISTORY: "page:diff-history",
   PAGE_DIFF_DIRTY: "page:diff-dirty"
 };
 const MAX_DETAIL_ITEMS = 3;
@@ -3101,7 +3107,7 @@ function isTrackablePageUrl(rawUrl) {
     return false;
   }
 }
-const SAVE_DEBOUNCE_MS$2 = 500;
+const SAVE_DEBOUNCE_MS$3 = 500;
 const MAX_TEXT_LENGTH = 8e3;
 let snapshots = null;
 function getFilePath$1() {
@@ -3139,8 +3145,8 @@ function load$2() {
   });
   return snapshots;
 }
-const persistence$2 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$2,
+const persistence$3 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$3,
   filePath: getFilePath$1(),
   getValue: () => snapshots,
   logLabel: "page snapshots",
@@ -3168,11 +3174,11 @@ function saveSnapshot(rawUrl, title, textContent, headings) {
   };
   s.delete(key);
   s.set(key, snapshot);
-  persistence$2.schedule();
+  persistence$3.schedule();
   return snapshot;
 }
 function flushPersist$2() {
-  return persistence$2.flush();
+  return persistence$3.flush();
 }
 const SEARCH_ENGINE_HOSTS = [
   "google.",
@@ -3749,6 +3755,24 @@ const VERIFICATION_API = process.env.VESSEL_PREMIUM_API || "https://vesselpremiu
 const FREE_TOOL_ITERATION_LIMIT = 50;
 const REVALIDATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 const OFFLINE_GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+const MAX_API_ERROR_LOG_LENGTH = 300;
+async function readApiErrorDetail(res) {
+  try {
+    const text = (await res.text()).trim();
+    if (!text) return "";
+    try {
+      const data = JSON.parse(text);
+      const detail = data.error || data.message;
+      if (typeof detail === "string" && detail.trim()) {
+        return detail.trim().slice(0, MAX_API_ERROR_LOG_LENGTH);
+      }
+    } catch {
+    }
+    return text.slice(0, MAX_API_ERROR_LOG_LENGTH);
+  } catch {
+    return "";
+  }
+}
 const PREMIUM_TOOLS = /* @__PURE__ */ new Set([
   "screenshot",
   "save_session",
@@ -3838,7 +3862,12 @@ async function verifySubscription(identifier) {
       body: JSON.stringify({ identifier: verificationIdentifier })
     });
     if (!res.ok) {
-      logger$f.warn("Verification API returned a non-OK status:", res.status);
+      const detail = await readApiErrorDetail(res);
+      logger$f.warn(
+        "Verification API returned a non-OK status:",
+        res.status,
+        detail
+      );
       return current;
     }
     const data = await res.json();
@@ -5355,8 +5384,32 @@ function normalizePageContent(value) {
     pageSchema: page.pageSchema
   };
 }
+function normalizePageDiffHistoryItem(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.detectedAt !== "string" || typeof raw.summary !== "string") {
+    return null;
+  }
+  return {
+    detectedAt: raw.detectedAt,
+    summary: raw.summary
+  };
+}
+function prunePageDiffHistory(items, options) {
+  const cutoff = (options.now ?? Date.now()) - options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  return items.filter((item) => {
+    const detectedAt = Date.parse(item.detectedAt);
+    return Number.isFinite(detectedAt) && detectedAt >= cutoff;
+  }).sort(
+    (left, right) => Date.parse(left.detectedAt) - Date.parse(right.detectedAt)
+  ).slice(-options.maxItems);
+}
+function appendPageDiffHistoryItem(items, next, options) {
+  return prunePageDiffHistory([...items, next], options);
+}
 const latestPageDiffs = /* @__PURE__ */ new Map();
 const recentPageDiffBursts = /* @__PURE__ */ new Map();
+let historyLoaded = false;
 const pendingPageSnapshotTimers = /* @__PURE__ */ new Map();
 const pendingPageSnapshotDueAt = /* @__PURE__ */ new Map();
 const lastMutationSnapshotAt = /* @__PURE__ */ new Map();
@@ -5377,10 +5430,81 @@ function attachDestroyCleanup(wc) {
     cleanupTimersForWcId(wc.id);
   });
 }
+const MAX_PERSISTED_DIFF_BURSTS = 50;
+const MAX_HISTORY_DAYS = 30;
+const SAVE_DEBOUNCE_MS$2 = 500;
+function getHistoryFilePath() {
+  return path.join(electron.app.getPath("userData"), "vessel-page-diff-history.json");
+}
+function loadHistory() {
+  if (historyLoaded) return recentPageDiffBursts;
+  historyLoaded = true;
+  const loaded = loadJsonFile({
+    filePath: getHistoryFilePath(),
+    fallback: /* @__PURE__ */ new Map(),
+    secure: true,
+    parse: (raw) => {
+      const next = /* @__PURE__ */ new Map();
+      if (!Array.isArray(raw)) return next;
+      for (const entry of raw) {
+        if (!entry || typeof entry !== "object") continue;
+        const record = entry;
+        if (typeof record.url !== "string" || !Array.isArray(record.bursts)) {
+          continue;
+        }
+        next.set(
+          record.url,
+          prunePageDiffHistory(
+            record.bursts.map((item) => normalizePageDiffHistoryItem(item)).filter((item) => item !== null),
+            {
+              maxAgeDays: MAX_HISTORY_DAYS,
+              maxItems: MAX_PERSISTED_DIFF_BURSTS
+            }
+          )
+        );
+      }
+      return next;
+    }
+  });
+  for (const [key, bursts] of loaded.entries()) {
+    recentPageDiffBursts.set(key, bursts);
+  }
+  return recentPageDiffBursts;
+}
+const persistence$2 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$2,
+  filePath: getHistoryFilePath(),
+  getValue: () => recentPageDiffBursts,
+  logLabel: "page diff history",
+  secure: true,
+  serialize: (value) => Array.from(value.entries()).map(([url, bursts]) => ({
+    url,
+    bursts
+  }))
+});
 function getLatestPageDiff(rawUrl) {
   if (!shouldTrackSnapshotUrl(rawUrl)) return null;
   return latestPageDiffs.get(normalizeUrl(rawUrl)) ?? null;
 }
+function getPageDiffBursts(rawUrl) {
+  if (!shouldTrackSnapshotUrl(rawUrl)) return [];
+  const key = normalizeUrl(rawUrl);
+  const history = loadHistory();
+  const bursts = prunePageDiffHistory(history.get(key) ?? [], {
+    maxAgeDays: MAX_HISTORY_DAYS,
+    maxItems: MAX_PERSISTED_DIFF_BURSTS
+  });
+  const current = history.get(key) ?? [];
+  if (current.length !== bursts.length) {
+    if (bursts.length > 0) {
+      history.set(key, bursts);
+    } else {
+      history.delete(key);
+    }
+    persistence$2.schedule();
+  }
+  return bursts.slice().reverse();
+}
 function summarizeDiffBurst(diff) {
   const items = diff.changes.slice(0, 2).map((change) => `${change.section}: ${change.summary}`);
   return items.join(" | ");
@@ -5391,16 +5515,21 @@ function enrichWithBurstHistory(key, diff) {
     detectedAt,
     summary: summarizeDiffBurst(diff)
   };
-  const bursts = [...recentPageDiffBursts.get(key) || [], nextBurst].slice(
-    -5
-  );
-  recentPageDiffBursts.set(key, bursts);
+  const history = loadHistory();
+  const bursts = appendPageDiffHistoryItem(history.get(key) ?? [], nextBurst, {
+    maxAgeDays: MAX_HISTORY_DAYS,
+    maxItems: MAX_PERSISTED_DIFF_BURSTS,
+    now: Date.parse(detectedAt)
+  });
+  history.set(key, bursts);
+  persistence$2.schedule();
+  const recentBursts = bursts.slice(-5);
   return {
     ...diff,
     burstCount: bursts.length,
     firstDetectedAt: bursts[0]?.detectedAt,
     lastDetectedAt: bursts[bursts.length - 1]?.detectedAt,
-    recentBursts: bursts
+    recentBursts: recentBursts.slice().reverse()
   };
 }
 async function capturePageSnapshot(url, wc, sendToRendererViews) {
@@ -5421,11 +5550,9 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
         sendToRendererViews(Channels.PAGE_CHANGED, enrichedDiff);
       } else {
         latestPageDiffs.delete(key);
-        recentPageDiffBursts.delete(key);
       }
     } else {
       latestPageDiffs.delete(key);
-      recentPageDiffBursts.delete(key);
     }
     saveSnapshot(url, title, textContent, headings);
   } catch {
@@ -6223,7 +6350,7 @@ class AnthropicProvider {
             });
             continue;
           }
-          const argSummary = [tb.input.url, tb.input.text, tb.input.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
+          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 : ""}>>
 `);
@@ -6414,11 +6541,52 @@ const SAFE_TOOL_ALIASES = {
   scroll_up: "scroll",
   read: "read_page",
   read_current_page: "read_page",
-  scan_page: "read_page"
+  scan_page: "read_page",
+  save_bookmark: "save_bookmark",
+  bookmark: "save_bookmark",
+  bookmark_page: "save_bookmark",
+  bookmark_url: "save_bookmark",
+  add_bookmark: "save_bookmark",
+  create_bookmark: "save_bookmark"
 };
+const CANONICAL_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "archive_bookmark",
+  "click",
+  "create_bookmark_folder",
+  "current_tab",
+  "go_back",
+  "go_forward",
+  "inspect_element",
+  "list_bookmarks",
+  "navigate",
+  "open_bookmark",
+  "organize_bookmark",
+  "read_page",
+  "save_bookmark",
+  "scroll",
+  "search",
+  "type_text"
+]);
+function repeatedTokenMatch(value, token) {
+  if (value === token) return true;
+  if (token.length === 0 || value.length <= token.length) return false;
+  if (value.length % token.length !== 0) return false;
+  return token.repeat(value.length / token.length) === value;
+}
 function normalizeToolAlias(name) {
   const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
-  return SAFE_TOOL_ALIASES[normalized] ?? name;
+  const direct = SAFE_TOOL_ALIASES[normalized] ?? normalized;
+  if (CANONICAL_TOOL_NAMES.has(direct)) return direct;
+  const knownTokens = [
+    ...Object.keys(SAFE_TOOL_ALIASES),
+    ...CANONICAL_TOOL_NAMES
+  ];
+  for (const token of knownTokens) {
+    if (repeatedTokenMatch(normalized, token)) {
+      return SAFE_TOOL_ALIASES[token] ?? token;
+    }
+  }
+  return name;
 }
 function parseModelSizeInBillions(model) {
   const match = model.toLowerCase().match(/(?:^|[:/_\-\s])(\d+(?:\.\d+)?)b(?:$|[:/_\-\s])/i);
@@ -6742,8 +6910,62 @@ function scalarArgsForTool(name, scalar) {
     const mode = trimmed.replace(/^["']|["']$/g, "").toLowerCase();
     if (mode) return { mode };
   }
+  if (name === "save_bookmark") {
+    const url = toLikelyUrl(trimmed);
+    if (url) return { url };
+    const lastSpace = trimmed.lastIndexOf(" ");
+    if (lastSpace > 0) {
+      const maybeUrl = toLikelyUrl(trimmed.slice(lastSpace + 1));
+      if (maybeUrl) return { url: maybeUrl, title: trimmed.slice(0, lastSpace).replace(/^["']|["']$/g, "") };
+    }
+  }
+  return null;
+}
+function firstStringArg(args, keys) {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
   return null;
 }
+function normalizeElementTargetArgs(args) {
+  const normalized = { ...args };
+  if (typeof normalized.index === "string" && /^\d+$/.test(normalized.index.trim())) {
+    normalized.index = Number(normalized.index.trim());
+  }
+  if (typeof normalized.selector !== "string" || !normalized.selector.trim()) {
+    const selector = firstStringArg(normalized, [
+      "cssSelector",
+      "css_selector",
+      "querySelector",
+      "query_selector"
+    ]);
+    if (selector) normalized.selector = selector;
+  }
+  if (typeof normalized.text !== "string" || !normalized.text.trim()) {
+    const text = firstStringArg(normalized, [
+      "label",
+      "title",
+      "name",
+      "target",
+      "element",
+      "linkText",
+      "link_text",
+      "ariaLabel",
+      "aria_label"
+    ]);
+    if (text) normalized.text = text;
+  }
+  return normalized;
+}
+function hasElementTarget(args) {
+  return typeof args.index === "number" || typeof args.selector === "string" && args.selector.trim().length > 0 || typeof args.text === "string" && args.text.trim().length > 0;
+}
+function isTargetlessClickArgs(args) {
+  return !hasElementTarget(normalizeElementTargetArgs(args));
+}
 function tryParseJsonWithCommonRepairs(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return {};
@@ -6797,7 +7019,10 @@ function parseToolArgsWithRepair(name, argsJson) {
   return scalarArgs ? { args: scalarArgs, repaired: true } : null;
 }
 function coerceToolArgsForExecution(name, args) {
-  const coerced = { ...args };
+  let coerced = { ...args };
+  if (name === "click" || name === "inspect_element" || name === "scroll_to_element") {
+    coerced = normalizeElementTargetArgs(coerced);
+  }
   if (name === "search") {
     if (typeof coerced.query !== "string" || !coerced.query.trim()) {
       if (typeof coerced.text === "string" && coerced.text.trim()) {
@@ -6818,6 +7043,25 @@ function coerceToolArgsForExecution(name, args) {
       }
     }
   }
+  if (name === "save_bookmark") {
+    if (typeof coerced.url !== "string" || !coerced.url.trim()) {
+      if (typeof coerced.link === "string" && coerced.link.trim()) {
+        coerced.url = coerced.link.trim();
+      } else if (typeof coerced.href === "string" && coerced.href.trim()) {
+        coerced.url = coerced.href.trim();
+      }
+    }
+    if (typeof coerced.folderName !== "string" || !coerced.folderName.trim()) {
+      if (typeof coerced.folder === "string" && coerced.folder.trim()) {
+        coerced.folderName = coerced.folder.trim();
+      } else if (typeof coerced.category === "string" && coerced.category.trim()) {
+        coerced.folderName = coerced.category.trim();
+      }
+    }
+    if (coerced.folderName && typeof coerced.createFolderIfMissing === "undefined") {
+      coerced.createFolderIfMissing = true;
+    }
+  }
   return coerced;
 }
 function canonicalizeArgsForTool(name, args) {
@@ -6834,6 +7078,24 @@ function canonicalizeArgsForTool(name, args) {
   }
   return canonical;
 }
+function unsupportedToolHint(name) {
+  const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+  const BOOKMARK_NAMES = [
+    "organize_bookmark",
+    "organize_bookmarks",
+    "manage_bookmark",
+    "manage_bookmarks",
+    "add_to_bookmarks",
+    "save_to_bookmarks",
+    "bookmark_link",
+    "save_link",
+    "store_bookmark"
+  ];
+  if (BOOKMARK_NAMES.includes(normalized) || /bookmark|save.*link|organize/.test(normalized)) {
+    return `Error: "${name}" is not a supported tool. Use save_bookmark to save a page as a bookmark, or create_bookmark_folder to create a folder. Example: save_bookmark with {"url": "...", "title": "...", "folderName": "..."}`;
+  }
+  return `Error: ${name} is not a supported tool. Choose one of the available browser tools instead.`;
+}
 function resolveToolCallName(rawName, args, availableToolNames) {
   const aliased = normalizeToolAlias(rawName);
   if (availableToolNames.has(aliased)) return aliased;
@@ -7138,6 +7400,7 @@ class OpenAICompatProvider {
           );
           if (recoveredToolCalls.length > 0) {
             toolCalls = recoveredToolCalls;
+            if (textAccum.trim()) onChunk("<<erase_prev>>");
           } else {
             const narratedToolCalls = recoverNarratedActionToolCalls(
               textAccum,
@@ -7145,6 +7408,7 @@ class OpenAICompatProvider {
             );
             if (narratedToolCalls.length > 0) {
               toolCalls = narratedToolCalls;
+              if (textAccum.trim()) onChunk("<<erase_prev>>");
             }
           }
         }
@@ -7211,6 +7475,25 @@ class OpenAICompatProvider {
         compactRecoveryCount = 0;
         const iterationToolResultPreviews = [];
         for (const tc of toolCalls) {
+          if (!availableToolNames.has(tc.name)) {
+            const hint = unsupportedToolHint(tc.name);
+            onChunk(`
+<<tool:${tc.name}:⚠ unsupported>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: hint
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "user",
+                content: `[System] You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
+              });
+            }
+            continue;
+          }
           if (malformedToolCalls.has(tc.id)) {
             onChunk(`
 <<tool:${tc.name}:⚠ invalid args>>
@@ -7237,25 +7520,23 @@ class OpenAICompatProvider {
           }
           args = repairedArgs.args;
           args = coerceToolArgsForExecution(tc.name, args);
-          if (!availableToolNames.has(tc.name)) {
+          const toolSignature = stableToolSignature(tc.name, args);
+          if (this.agentToolProfile === "compact" && tc.name === "click" && isTargetlessClickArgs(args)) {
             onChunk(`
-<<tool:unsupported_tool:⚠ unsupported>>
+<<tool:${tc.name}:⚠ missing target>>
 `);
             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.`
+              content: `Error: click requires an element target. Use click with {"index": N} from the latest read_page result, or {"text": "exact visible link/button text"}. If you do not have a current result index, call read_page(mode="results_only") first and then click one listed result.`
+            });
+            messages.push({
+              role: "user",
+              content: `[System] Your last click had no target. Do not call click with empty arguments. Refresh the page state with read_page(mode="results_only") if needed, then click exactly one result by index or exact visible text.`
             });
             compactCorrectionCount += 1;
-            if (compactCorrectionCount >= 2) {
-              messages.push({
-                role: "user",
-                content: `[System] You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
-              });
-            }
             continue;
           }
-          const toolSignature = stableToolSignature(tc.name, args);
           const neverSuppressDuplicate = [
             "read_page",
             "current_tab",
@@ -10080,6 +10361,13 @@ const TOOL_DEFINITIONS = [
     tier: 2,
     hiddenByDefault: true
   },
+  // --- Undo ---
+  {
+    name: "undo_last_action",
+    title: "Undo Last Action",
+    description: "Undo the most recent agent action by restoring the browser to its state before that action ran. Works for click, type, submit, navigate, and similar mutating actions. Returns the name of the undone action, or an error if nothing can be undone.",
+    tier: 1
+  },
   // --- Speedee System: Suggestion Engine ---
   {
     name: "suggest",
@@ -10469,6 +10757,14 @@ function pruneToolsForContext(tools, pageType, query = "", options = {}) {
     return description !== tool.description ? { ...tool, description } : tool;
   });
 }
+const SEARCH_ENGINE_PRESETS = {
+  duckduckgo: { label: "DuckDuckGo", url: "https://duckduckgo.com/?q=" },
+  google: { label: "Google", url: "https://www.google.com/search?q=" },
+  bing: { label: "Bing", url: "https://www.bing.com/search?q=" },
+  brave: { label: "Brave Search", url: "https://search.brave.com/search?q=" },
+  ecosia: { label: "Ecosia", url: "https://www.ecosia.org/search?q=" },
+  kagi: { label: "Kagi", url: "https://kagi.com/search?q=" }
+};
 function trimText(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -10604,6 +10900,60 @@ function getBookmarkSearchMatch(args) {
   }
   return { matchedFields, score };
 }
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeKeyFields(value) {
+  if (!Array.isArray(value)) return void 0;
+  const normalized = value.filter((field) => typeof field === "string").map((field) => field.trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeAgentHints(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const normalized = Object.fromEntries(
+    Object.entries(value).map(([key, hint]) => [key.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
+  );
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeBookmarkMetadata(input) {
+  const normalized = {};
+  const intent = normalizeOptionalString(input.intent);
+  const expectedContent = normalizeOptionalString(input.expectedContent);
+  const keyFields = normalizeKeyFields(input.keyFields);
+  const agentHints = normalizeAgentHints(input.agentHints);
+  if (intent !== void 0) normalized.intent = intent;
+  if (expectedContent !== void 0) {
+    normalized.expectedContent = expectedContent;
+  }
+  if (keyFields !== void 0) normalized.keyFields = keyFields;
+  if (agentHints !== void 0) normalized.agentHints = agentHints;
+  return normalized;
+}
+function normalizeBookmarkMetadataUpdate(input) {
+  const normalized = {};
+  if (hasOwn(input, "intent")) {
+    normalized.intent = normalizeOptionalString(input.intent);
+  }
+  if (hasOwn(input, "expectedContent")) {
+    normalized.expectedContent = normalizeOptionalString(
+      input.expectedContent
+    );
+  }
+  if (hasOwn(input, "keyFields")) {
+    normalized.keyFields = normalizeKeyFields(input.keyFields);
+  }
+  if (hasOwn(input, "agentHints")) {
+    normalized.agentHints = normalizeAgentHints(input.agentHints);
+  }
+  return normalized;
+}
 const UNSORTED_ID = "unsorted";
 const ARCHIVE_FOLDER_NAME = "Archive";
 const SAVE_DEBOUNCE_MS$1 = 250;
@@ -10642,6 +10992,13 @@ const persistence$1 = createDebouncedJsonPersistence({
 function save() {
   persistence$1.schedule();
 }
+function assignDefinedBookmarkFields(bookmark, fields) {
+  if (!fields) return;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    Object.assign(bookmark, { [key]: value });
+  }
+}
 function emit() {
   if (!state$1) return;
   const snapshot = cloneState(state$1);
@@ -10815,9 +11172,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
       if (note !== void 0) {
         bookmark2.note = note.trim() || void 0;
       }
-      if (options?.extra) {
-        Object.assign(bookmark2, options.extra);
-      }
+      assignDefinedBookmarkFields(bookmark2, options?.extra);
       bookmark2.savedAt = (/* @__PURE__ */ new Date()).toISOString();
       save();
       emit();
@@ -10859,6 +11214,12 @@ function updateBookmark(id, updates) {
   load$1();
   const bookmark = state$1.bookmarks.find((item) => item.id === id);
   if (!bookmark) return null;
+  const metadataUpdates = normalizeBookmarkMetadataUpdate({
+    intent: updates.intent,
+    expectedContent: updates.expectedContent,
+    keyFields: updates.keyFields,
+    agentHints: updates.agentHints
+  });
   if (typeof updates.title === "string") {
     const trimmed = updates.title.trim();
     bookmark.title = trimmed || bookmark.url;
@@ -10870,20 +11231,20 @@ function updateBookmark(id, updates) {
   if (typeof updates.folderId === "string") {
     bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state$1.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   }
-  if (typeof updates.intent === "string") {
-    bookmark.intent = updates.intent.trim() || void 0;
+  if ("intent" in metadataUpdates) {
+    bookmark.intent = metadataUpdates.intent;
   }
-  if (typeof updates.expectedContent === "string") {
-    bookmark.expectedContent = updates.expectedContent.trim() || void 0;
+  if ("expectedContent" in metadataUpdates) {
+    bookmark.expectedContent = metadataUpdates.expectedContent;
   }
-  if (updates.keyFields !== void 0) {
-    bookmark.keyFields = updates.keyFields;
+  if ("keyFields" in metadataUpdates) {
+    bookmark.keyFields = metadataUpdates.keyFields;
   }
   if (updates.pageSchema !== void 0) {
     bookmark.pageSchema = updates.pageSchema;
   }
-  if (updates.agentHints !== void 0) {
-    bookmark.agentHints = updates.agentHints;
+  if ("agentHints" in metadataUpdates) {
+    bookmark.agentHints = metadataUpdates.agentHints;
   }
   save();
   emit();
@@ -11878,33 +12239,6 @@ function formatCompactToolResult(name, result) {
       return limitText(result, 18, 1400);
   }
 }
-function normalizeOptionalString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed || void 0;
-}
-function normalizeKeyFields(value) {
-  if (!Array.isArray(value)) return void 0;
-  const normalized = value.filter((field) => typeof field === "string").map((field) => field.trim()).filter(Boolean);
-  return normalized.length > 0 ? normalized : void 0;
-}
-function normalizeAgentHints(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const normalized = Object.fromEntries(
-    Object.entries(value).map(([key, hint]) => [key.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
-  );
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function normalizeBookmarkMetadata(input) {
-  return {
-    intent: normalizeOptionalString(input.intent),
-    expectedContent: normalizeOptionalString(input.expectedContent),
-    keyFields: normalizeKeyFields(input.keyFields),
-    agentHints: normalizeAgentHints(input.agentHints)
-  };
-}
 const HUGGING_FACE_HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "www.huggingface.co"]);
 const HUGGING_FACE_MODEL_TASKS = [
   {
@@ -14818,8 +15152,19 @@ function buildCommonSearchUrlShortcut(currentUrl, rawQuery) {
     appliedFilters: existingParam ? [`updated ${existingParam} query`] : []
   };
 }
-function buildSearchShortcut(currentUrl, rawQuery) {
-  return buildHuggingFaceSearchShortcut(currentUrl, rawQuery) ?? buildCommonSearchUrlShortcut(currentUrl, rawQuery);
+function buildDefaultEngineShortcut(rawQuery) {
+  const settings2 = loadSettings();
+  const engineId = settings2.defaultSearchEngine ?? "duckduckgo";
+  if (engineId === "none") return null;
+  const preset = SEARCH_ENGINE_PRESETS[engineId];
+  if (!preset) return null;
+  const query = normalizeSearchQuery(rawQuery);
+  if (!query) return null;
+  return {
+    url: preset.url + encodeURIComponent(query),
+    source: "default search engine",
+    appliedFilters: []
+  };
 }
 async function locateSearchTarget(wc, explicitSelector) {
   if (explicitSelector) {
@@ -14872,7 +15217,7 @@ async function locateSearchTarget(wc, explicitSelector) {
           const seen = new Set();
           const ordered = [];
           const specific = document.querySelectorAll(
-            'input[type="search"], input[name="q"], input[name="query"], input[name="search"], input[role="searchbox"], input[aria-label*="search" i], input[placeholder*="search" i]'
+            'input[type="search"], input[name="q"], input[name="query"], input[name="search"], input[role="searchbox"], input[aria-label*="search" i], input[placeholder*="search" i], textarea[name="q"], textarea[name="query"], textarea[name="search"], textarea[role="searchbox"], textarea[aria-label*="search" i], textarea[placeholder*="search" i]'
           );
           specific.forEach((el) => {
             if (!seen.has(el)) {
@@ -14880,7 +15225,7 @@ async function locateSearchTarget(wc, explicitSelector) {
               ordered.push(el);
             }
           });
-          document.querySelectorAll('input[type="text"], input:not([type])').forEach((el) => {
+          document.querySelectorAll('input[type="text"], input:not([type]), textarea').forEach((el) => {
             if (seen.has(el)) return;
             const scope = nearestSearchScope(el);
             if (!scope) return;
@@ -14891,9 +15236,10 @@ async function locateSearchTarget(wc, explicitSelector) {
         }
 
         function scoreInput(el) {
-          if (!(el instanceof HTMLInputElement)) return -1;
+          if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return -1;
           if (isDisabled(el) || !isVisible(el)) return -1;
-          const type = normalize(el.getAttribute("type") || el.type);
+          const isTextarea = el instanceof HTMLTextAreaElement;
+          const type = isTextarea ? "text" : normalize(el.getAttribute("type") || el.type);
           if (type && !["search", "text", ""].includes(type)) return -1;
 
           let score = 0;
@@ -15040,16 +15386,19 @@ async function searchPage(wc, args) {
   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.`;
   }
+  const runShortcut = async (shortcut) => {
+    const beforeUrl2 = wc.getURL();
+    await loadPermittedUrl(wc, shortcut.url);
+    await waitForPotentialNavigation(wc, beforeUrl2, 4e3);
+    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}${await getPostSearchSummary(wc)}`;
+  };
   if (typeof args.selector !== "string") {
-    const shortcut = buildSearchShortcut(wc.getURL(), query);
+    const shortcut = buildHuggingFaceSearchShortcut(wc.getURL(), query) ?? buildCommonSearchUrlShortcut(wc.getURL(), query);
     if (shortcut) {
-      const beforeUrl2 = wc.getURL();
-      await loadPermittedUrl(wc, shortcut.url);
-      await waitForPotentialNavigation(wc, beforeUrl2, 4e3);
-      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}${await getPostSearchSummary(wc)}`;
+      return runShortcut(shortcut);
     }
   }
   const searchInfo = await locateSearchTarget(
@@ -15060,6 +15409,12 @@ async function searchPage(wc, args) {
     return pageBusyError("search");
   }
   if (!searchInfo?.selector) {
+    if (typeof args.selector !== "string") {
+      const fallback = buildDefaultEngineShortcut(query);
+      if (fallback) {
+        return runShortcut(fallback);
+      }
+    }
     return 'Error: Could not find a visible search input. Try read_page(mode="visible_only") or provide a selector.';
   }
   const fillResult = await setElementValue(wc, searchInfo.selector, query);
@@ -16056,6 +16411,11 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
           ctx.runtime.clearFlow();
           return "Workflow ended.";
         }
+        case "undo_last_action": {
+          const undone = ctx.runtime.undoLastAction();
+          if (!undone) return "Nothing to undo. No undo snapshots available.";
+          return `Undid action: ${undone}. Browser restored to state before that action.`;
+        }
         case "suggest": {
           if (!wc) return "No active tab. Use navigate to open a page.";
           let page;
@@ -20066,6 +20426,23 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
       return asTextResponse("Workflow ended.");
     }
   );
+  server.registerTool(
+    "undo_last_action",
+    {
+      title: "Undo Last Action",
+      description: "Undo the most recent agent action by restoring the browser to its state before that action ran. Works for click, type, submit, navigate, and similar mutating actions."
+    },
+    async () => {
+      const undone = runtime2.undoLastAction();
+      if (!undone)
+        return asTextResponse(
+          "Nothing to undo. No undo snapshots available."
+        );
+      return asTextResponse(
+        `Undid action: ${undone}. Browser restored to state before that action.`
+      );
+    }
+  );
   server.registerTool(
     "suggest",
     {
@@ -21939,6 +22316,19 @@ function registerPageDiffHandlers(windowState, sendToRendererViews) {
     if (!wc) return null;
     return getLatestPageDiff(wc.getURL());
   });
+  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, () => {
+    try {
+      if (!isPremiumActiveState(getPremiumState())) {
+        return { error: "Premium required" };
+      }
+      const activeTab = windowState.tabManager.getActiveTab();
+      const wc = activeTab?.view.webContents;
+      if (!wc) return [];
+      return getPageDiffBursts(wc.getURL());
+    } catch {
+      return [];
+    }
+  });
   electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
@@ -22299,6 +22689,20 @@ function registerIpcHandlers(windowState, runtime2) {
       width: windowState.uiState.sidebarWidth
     };
   });
+  electron.ipcMain.handle(Channels.SIDEBAR_NAVIGATE, (_, tab) => {
+    assertString(tab, "tab");
+    if (!windowState.uiState.sidebarOpen) {
+      windowState.uiState.sidebarOpen = true;
+      layoutViews(windowState);
+    }
+    if (!sidebarView.webContents.isDestroyed()) {
+      sidebarView.webContents.send(Channels.SIDEBAR_NAVIGATE, tab);
+    }
+    return {
+      open: windowState.uiState.sidebarOpen,
+      width: windowState.uiState.sidebarWidth
+    };
+  });
   electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_START, () => {
     sidebarResizeActive = true;
     clearSidebarResizeRecoveryTimer();
@@ -22397,6 +22801,14 @@ function registerIpcHandlers(windowState, runtime2) {
     Channels.AGENT_CHECKPOINT_RESTORE,
     (_, checkpointId) => runtime2.restoreCheckpoint(checkpointId)
   );
+  electron.ipcMain.handle(
+    Channels.AGENT_CHECKPOINT_UPDATE_NOTE,
+    (_, checkpointId, note) => runtime2.updateCheckpointNote(checkpointId, note || "")
+  );
+  electron.ipcMain.handle(
+    Channels.AGENT_UNDO_LAST_ACTION,
+    () => runtime2.undoLastAction()
+  );
   electron.ipcMain.handle(
     Channels.AGENT_SESSION_CAPTURE,
     (_, note) => runtime2.captureSession(note)
@@ -22436,6 +22848,13 @@ function registerIpcHandlers(windowState, runtime2) {
       return result.bookmark;
     }
   );
+  electron.ipcMain.handle(
+    Channels.BOOKMARK_UPDATE,
+    (_, id, updates) => {
+      trackBookmarkAction("save");
+      return updateBookmark(id, updates);
+    }
+  );
   electron.ipcMain.handle(Channels.BOOKMARK_REMOVE, (_, id) => {
     trackBookmarkAction("remove");
     return removeBookmark(id);
@@ -22725,6 +23144,41 @@ function registerIpcHandlers(windowState, runtime2) {
   registerAutofillHandlers(windowState);
   registerPageDiffHandlers(windowState, sendToRendererViews);
 }
+const UNDOABLE_ACTIONS = /* @__PURE__ */ new Set([
+  "accept_cookies",
+  "clear_overlays",
+  "click",
+  "close_tab",
+  "create_tab",
+  "dismiss_popup",
+  "fill_form",
+  "focus",
+  "go_back",
+  "go_forward",
+  "load_session",
+  "login",
+  "navigate",
+  "open_bookmark",
+  "paginate",
+  "press_key",
+  "reload",
+  "restore_checkpoint",
+  "scroll",
+  "scroll_to_element",
+  "search",
+  "select_option",
+  "set_ad_blocking",
+  "submit_form",
+  "switch_tab",
+  "type_text"
+]);
+function isUndoableAction(name) {
+  return UNDOABLE_ACTIONS.has(name);
+}
+function isUndoableResult(result) {
+  const normalized = result.trim().toLowerCase();
+  return normalized.length > 0 && !normalized.startsWith("error:") && !normalized.startsWith("nothing to ") && !normalized.startsWith("no active ") && !normalized.startsWith("action rejected:");
+}
 function makeStep(label, status = "pending") {
   return { label, status };
 }
@@ -23121,6 +23575,7 @@ class AgentRuntime {
   state;
   updateListener = null;
   pendingResolvers = /* @__PURE__ */ new Map();
+  undoSnapshots = [];
   setUpdateListener(listener) {
     this.updateListener = listener;
     if (listener) {
@@ -23130,6 +23585,8 @@ class AgentRuntime {
   getState() {
     const snapshot = clone(this.state);
     snapshot.mcpStatus = getMcpStatus();
+    snapshot.canUndo = this.canUndo();
+    snapshot.undoInfo = this.getUndoInfo();
     return snapshot;
   }
   onTabStateChanged() {
@@ -23137,6 +23594,21 @@ class AgentRuntime {
   }
   setApprovalMode(mode) {
     this.state.supervisor.approvalMode = mode;
+    if (mode === "auto" && !this.state.supervisor.paused) {
+      const approvals = this.state.supervisor.pendingApprovals;
+      if (approvals.length > 0) {
+        const actionIds = new Set(approvals.map((approval) => approval.actionId));
+        this.state.supervisor.pendingApprovals = [];
+        this.state.actions = this.state.actions.map(
+          (action) => actionIds.has(action.id) ? { ...action, status: "running", error: void 0 } : action
+        );
+        for (const approval of approvals) {
+          const resolve = this.pendingResolvers.get(approval.id);
+          this.pendingResolvers.delete(approval.id);
+          resolve?.(true);
+        }
+      }
+    }
     this.emit();
     return this.getState();
   }
@@ -23172,6 +23644,37 @@ class AgentRuntime {
     this.captureSession(`Restored ${checkpoint.name}`);
     return clone(checkpoint);
   }
+  updateCheckpointNote(checkpointId, note) {
+    const index = this.state.checkpoints.findIndex((item) => item.id === checkpointId);
+    if (index === -1) return null;
+    this.state.checkpoints[index] = {
+      ...this.state.checkpoints[index],
+      note: note.trim() || void 0
+    };
+    this.emit();
+    return clone(this.state.checkpoints[index]);
+  }
+  canUndo() {
+    return this.undoSnapshots.length > 0;
+  }
+  getUndoInfo() {
+    const latest = this.undoSnapshots[this.undoSnapshots.length - 1];
+    if (!latest) return null;
+    return { actionName: latest.actionName, capturedAt: latest.capturedAt };
+  }
+  undoLastAction() {
+    const snapshot = this.undoSnapshots.at(-1);
+    if (!snapshot) return null;
+    try {
+      this.tabManager.restoreSession(snapshot.snapshot);
+      this.undoSnapshots.pop();
+    } catch (error) {
+      logger$3.error("Failed to restore undo snapshot", error);
+      return null;
+    }
+    this.captureSession(`Undid ${snapshot.actionName}`);
+    return snapshot.actionName;
+  }
   captureSession(note) {
     const snapshot = this.tabManager.snapshotSession(note);
     this.state.session = snapshot;
@@ -23321,6 +23824,7 @@ ${progress}
     args = {},
     tabId = null,
     dangerous = false,
+    undoable,
     executor
   }) {
     const action = this.startAction({
@@ -23374,8 +23878,13 @@ ${progress}
       streamId: transcriptStreamId,
       mode: "replace"
     });
+    const shouldCaptureUndo = undoable ?? isUndoableAction(name);
+    const undoSnapshot = shouldCaptureUndo ? this.createUndoSnapshot(name) : null;
     try {
       const result = await executor();
+      if (undoSnapshot && isUndoableResult(result)) {
+        this.pushUndoSnapshot(undoSnapshot);
+      }
       this.finishAction(action.id, "completed", summarizeText(result));
       this.publishTranscript({
         source,
@@ -23402,6 +23911,21 @@ ${progress}
       throw error;
     }
   }
+  createUndoSnapshot(name) {
+    return {
+      id: crypto$2.randomUUID(),
+      actionName: name,
+      snapshot: this.tabManager.snapshotSession(
+        `Auto-checkpoint before ${name}`
+      ),
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  pushUndoSnapshot(snapshot) {
+    this.undoSnapshots = [...this.undoSnapshots, snapshot].slice(
+      -10
+    );
+  }
   resolveApproval(approvalId, approved) {
     const approval = this.state.supervisor.pendingApprovals.find(
       (item) => item.id === approvalId
@@ -23983,6 +24507,11 @@ function closeSplash(splash, delayMs = 0) {
 }
 const logger = createLogger("Bootstrap");
 let runtime = null;
+function configureUserAgent() {
+  const originalUA = electron.session.defaultSession.getUserAgent();
+  const maskedUA = originalUA.replace(/ Electron\/[^\s]+/, "") + " Vessel/" + electron.app.getVersion();
+  electron.session.defaultSession.setUserAgent(maskedUA);
+}
 function checkWritableUserData(userDataPath) {
   const issues = [];
   try {
@@ -24046,6 +24575,7 @@ Action: Open Settings (Ctrl+,) to choose a different port, then save to restart
   });
 }
 async function bootstrap() {
+  configureUserAgent();
   const splash = createSplashWindow();
   const settings2 = loadSettings();
   const userDataPath = electron.app.getPath("userData");