@quanta-intellect/vessel-browser 0.1.53 → 0.1.56

package/out/main/index.js

@@ -4,12 +4,12 @@ const fs$1 = require("node:fs");
 const path = require("path");
 const fs = require("fs");
 const crypto$1 = require("crypto");
-const crypto$2 = require("node:crypto");
-const path$1 = require("node:path");
 const Anthropic = require("@anthropic-ai/sdk");
 const OpenAI = require("openai");
+const path$1 = require("node:path");
 const node_module = require("node:module");
 const zod = require("zod");
+const crypto$2 = require("node:crypto");
 const http = require("node:http");
 const os = require("node:os");
 const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
@@ -38,13 +38,13 @@ const defaults = {
     expiresAt: ""
   }
 };
-const SAVE_DEBOUNCE_MS$3 = 150;
+const SAVE_DEBOUNCE_MS$5 = 150;
 const CHAT_PROVIDER_SECRET_FILENAME = "vessel-chat-provider-secret";
 const SETTABLE_KEYS = new Set(Object.keys(defaults));
 let settings = null;
 let settingsIssues = [];
-let saveTimer$3 = null;
-let saveDirty$3 = false;
+let saveTimer = null;
+let saveDirty = false;
 function getUserDataPath() {
   if (typeof electron.app?.getPath === "function") {
     return electron.app.getPath("userData");
@@ -57,7 +57,7 @@ function getSettingsPath() {
 function getChatProviderSecretPath() {
   return path.join(getUserDataPath(), CHAT_PROVIDER_SECRET_FILENAME);
 }
-function canUseSafeStorage() {
+function canUseSafeStorage$1() {
   try {
     return electron.safeStorage.isEncryptionAvailable();
   } catch {
@@ -67,7 +67,7 @@ function canUseSafeStorage() {
 function readStoredProviderSecret() {
   try {
     const raw = fs.readFileSync(getChatProviderSecretPath());
-    const decoded = canUseSafeStorage() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const decoded = canUseSafeStorage$1() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
     const parsed = JSON.parse(decoded);
     if (parsed && typeof parsed === "object" && typeof parsed.providerId === "string" && typeof parsed.apiKey === "string") {
       return parsed;
@@ -80,7 +80,7 @@ function writeStoredProviderSecret(secret) {
   const filePath = getChatProviderSecretPath();
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   const payload = JSON.stringify(secret);
-  if (canUseSafeStorage()) {
+  if (canUseSafeStorage$1()) {
     const encrypted = electron.safeStorage.encryptString(payload);
     fs.writeFileSync(filePath, encrypted, { mode: 384 });
     return;
@@ -174,11 +174,11 @@ function loadSettings() {
   }
   return settings;
 }
-function persistNow$3() {
-  saveDirty$3 = false;
-  if (saveTimer$3) {
-    clearTimeout(saveTimer$3);
-    saveTimer$3 = null;
+function persistNow() {
+  saveDirty = false;
+  if (saveTimer) {
+    clearTimeout(saveTimer);
+    saveTimer = null;
   }
   return fs.promises.mkdir(path.dirname(getSettingsPath()), { recursive: true }).then(
     () => fs.promises.writeFile(
@@ -188,14 +188,14 @@ function persistNow$3() {
   ).catch((err) => console.error("[Vessel] Failed to save settings:", err));
 }
 function saveSettings() {
-  saveDirty$3 = true;
-  if (saveTimer$3) return;
-  saveTimer$3 = setTimeout(() => {
-    saveTimer$3 = null;
-    if (saveDirty$3) {
-      void persistNow$3();
+  saveDirty = true;
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    if (saveDirty) {
+      void persistNow();
     }
-  }, SAVE_DEBOUNCE_MS$3);
+  }, SAVE_DEBOUNCE_MS$5);
 }
 function setSetting(key, value) {
   loadSettings();
@@ -231,8 +231,8 @@ function setSetting(key, value) {
   saveSettings();
   return { ...settings };
 }
-function flushPersist$3() {
-  return saveDirty$3 ? persistNow$3() : Promise.resolve();
+function flushPersist$5() {
+  return saveDirty ? persistNow() : Promise.resolve();
 }
 function checkDomainPolicy(url) {
   if (!url || url.startsWith("about:")) return null;
@@ -746,48 +746,132 @@ class Tab {
     this.view.webContents.close();
   }
 }
-let state$3 = null;
-const listeners$2 = /* @__PURE__ */ new Set();
-const SAVE_DEBOUNCE_MS$2 = 250;
-let saveTimer$2 = null;
-let saveDirty$2 = false;
-function getHighlightsPath() {
-  return path.join(electron.app.getPath("userData"), "vessel-highlights.json");
+function canUseSafeStorage() {
+  try {
+    return electron.safeStorage.isEncryptionAvailable();
+  } catch {
+    return false;
+  }
 }
-function load$2() {
-  if (state$3) return state$3;
+function decodeStoredData(data, secure) {
+  if (secure && canUseSafeStorage() && electron.safeStorage.decryptString) {
+    return electron.safeStorage.decryptString(data);
+  }
+  return data.toString("utf-8");
+}
+function encodeStoredData(payload, secure) {
+  if (secure && canUseSafeStorage() && electron.safeStorage.encryptString) {
+    return electron.safeStorage.encryptString(payload);
+  }
+  return payload;
+}
+function loadJsonFile({
+  filePath,
+  fallback,
+  parse,
+  secure = false
+}) {
   try {
-    const raw = fs.readFileSync(getHighlightsPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    state$3 = {
-      highlights: Array.isArray(parsed.highlights) ? parsed.highlights : []
-    };
+    const raw = fs.readFileSync(filePath);
+    const decoded = decodeStoredData(raw, secure);
+    return parse(JSON.parse(decoded));
   } catch {
-    state$3 = { highlights: [] };
+    return fallback;
   }
-  return state$3;
 }
-function persistNow$2() {
-  if (!state$3) return Promise.resolve();
-  saveDirty$2 = false;
-  return fs.promises.writeFile(getHighlightsPath(), JSON.stringify(state$3, null, 2), "utf-8").catch((err) => console.error("[Vessel] Failed to save highlights:", err));
+function createDebouncedJsonPersistence({
+  debounceMs,
+  filePath,
+  getValue,
+  logLabel,
+  resetOnSchedule = false,
+  secure = false,
+  serialize
+}) {
+  let saveTimer2 = null;
+  let saveDirty2 = false;
+  const persistNow2 = async () => {
+    saveDirty2 = false;
+    if (saveTimer2) {
+      clearTimeout(saveTimer2);
+      saveTimer2 = null;
+    }
+    const value = getValue();
+    if (value == null) return;
+    const payload = JSON.stringify(
+      serialize ? serialize(value) : value,
+      null,
+      2
+    );
+    const data = encodeStoredData(payload, secure);
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true }).then(
+      () => fs.promises.writeFile(
+        filePath,
+        data,
+        typeof data === "string" ? { encoding: "utf-8", mode: 384 } : { mode: 384 }
+      )
+    ).catch(
+      (err) => console.error(`[Vessel] Failed to save ${logLabel}:`, err)
+    );
+  };
+  const schedule = () => {
+    saveDirty2 = true;
+    if (saveTimer2) {
+      if (!resetOnSchedule) return;
+      clearTimeout(saveTimer2);
+    }
+    saveTimer2 = setTimeout(() => {
+      saveTimer2 = null;
+      if (saveDirty2) void persistNow2();
+    }, debounceMs);
+  };
+  const flush2 = () => {
+    return saveDirty2 ? persistNow2() : Promise.resolve();
+  };
+  return {
+    persistNow: persistNow2,
+    schedule,
+    flush: flush2
+  };
+}
+let state$4 = null;
+const listeners$2 = /* @__PURE__ */ new Set();
+const SAVE_DEBOUNCE_MS$4 = 250;
+function getHighlightsPath() {
+  return path.join(electron.app.getPath("userData"), "vessel-highlights.json");
 }
+function load$4() {
+  if (state$4) return state$4;
+  state$4 = loadJsonFile({
+    filePath: getHighlightsPath(),
+    fallback: { highlights: [] },
+    parse: (raw) => {
+      const parsed = raw;
+      return {
+        highlights: Array.isArray(parsed.highlights) ? parsed.highlights : []
+      };
+    }
+  });
+  return state$4;
+}
+const persistence$4 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$4,
+  filePath: getHighlightsPath(),
+  getValue: () => state$4,
+  logLabel: "highlights",
+  resetOnSchedule: true
+});
 function save$2() {
-  saveDirty$2 = true;
-  if (saveTimer$2) clearTimeout(saveTimer$2);
-  saveTimer$2 = setTimeout(() => {
-    saveTimer$2 = null;
-    void persistNow$2();
-  }, SAVE_DEBOUNCE_MS$2);
+  persistence$4.schedule();
 }
 function emit$2() {
-  if (!state$3) return;
-  const snapshot = { highlights: [...state$3.highlights] };
+  if (!state$4) return;
+  const snapshot = { highlights: [...state$4.highlights] };
   for (const listener of listeners$2) {
     listener(snapshot);
   }
 }
-function normalizeUrl(rawUrl) {
+function normalizeUrl$1(rawUrl) {
   try {
     const parsed = new URL(rawUrl);
     parsed.hash = "";
@@ -797,19 +881,19 @@ function normalizeUrl(rawUrl) {
   }
 }
 function getState$2() {
-  load$2();
-  return { highlights: [...state$3.highlights] };
+  load$4();
+  return { highlights: [...state$4.highlights] };
 }
 function getHighlightsForUrl(url) {
-  load$2();
-  const normalized = normalizeUrl(url);
-  return state$3.highlights.filter((h) => h.url === normalized);
+  load$4();
+  const normalized = normalizeUrl$1(url);
+  return state$4.highlights.filter((h) => h.url === normalized);
 }
 function addHighlight(url, selector, text, label, color, source) {
-  load$2();
+  load$4();
   const highlight = {
     id: crypto$1.randomUUID(),
-    url: normalizeUrl(url),
+    url: normalizeUrl$1(url),
     selector: selector || void 0,
     text: text || void 0,
     label: label || void 0,
@@ -817,30 +901,30 @@ function addHighlight(url, selector, text, label, color, source) {
     source: source || void 0,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state$3.highlights.push(highlight);
+  state$4.highlights.push(highlight);
   save$2();
   emit$2();
   return highlight;
 }
 function removeHighlight(id) {
-  load$2();
-  const index = state$3.highlights.findIndex((h) => h.id === id);
+  load$4();
+  const index = state$4.highlights.findIndex((h) => h.id === id);
   if (index === -1) return null;
-  const [removed] = state$3.highlights.splice(index, 1);
+  const [removed] = state$4.highlights.splice(index, 1);
   save$2();
   emit$2();
   return removed;
 }
 function findHighlightByText(url, text) {
-  load$2();
-  const normalized = normalizeUrl(url);
-  return state$3.highlights.find(
+  load$4();
+  const normalized = normalizeUrl$1(url);
+  return state$4.highlights.find(
     (h) => h.url === normalized && h.text && h.text === text
   ) ?? null;
 }
 function updateHighlightColor(id, color) {
-  load$2();
-  const highlight = state$3.highlights.find((h) => h.id === id);
+  load$4();
+  const highlight = state$4.highlights.find((h) => h.id === id);
   if (!highlight) return null;
   highlight.color = color;
   save$2();
@@ -848,24 +932,19 @@ function updateHighlightColor(id, color) {
   return highlight;
 }
 function clearHighlightsForUrl(url) {
-  load$2();
-  const normalized = normalizeUrl(url);
-  const before = state$3.highlights.length;
-  state$3.highlights = state$3.highlights.filter((h) => h.url !== normalized);
-  const removed = before - state$3.highlights.length;
+  load$4();
+  const normalized = normalizeUrl$1(url);
+  const before = state$4.highlights.length;
+  state$4.highlights = state$4.highlights.filter((h) => h.url !== normalized);
+  const removed = before - state$4.highlights.length;
   if (removed > 0) {
     save$2();
     emit$2();
   }
   return removed;
 }
-function flushPersist$2() {
-  if (saveTimer$2) {
-    clearTimeout(saveTimer$2);
-    saveTimer$2 = null;
-  }
-  if (!saveDirty$2) return Promise.resolve();
-  return persistNow$2();
+function flushPersist$4() {
+  return persistence$4.flush();
 }
 const SKIP_TAGS_JS = "var SKIP_TAGS = {SCRIPT:1,STYLE:1,NOSCRIPT:1,TEMPLATE:1,IFRAME:1,SVG:1};";
 const CONTENT_ROOTS_JS = `
@@ -1433,61 +1512,45 @@ function persistHighlight(url, text) {
   return { success: true, text: capped, id: highlight.id };
 }
 const MAX_HISTORY_ENTRIES = 5e3;
-const SAVE_DEBOUNCE_MS$1 = 250;
-let state$2 = null;
+const SAVE_DEBOUNCE_MS$3 = 250;
+let state$3 = null;
 const listeners$1 = /* @__PURE__ */ new Set();
-let saveTimer$1 = null;
-let saveDirty$1 = false;
 function getHistoryPath() {
   return path.join(electron.app.getPath("userData"), "vessel-history.json");
 }
-function load$1() {
-  if (state$2) return state$2;
-  try {
-    const raw = fs.readFileSync(getHistoryPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    state$2 = {
-      entries: Array.isArray(parsed.entries) ? parsed.entries : []
-    };
-  } catch {
-    state$2 = { entries: [] };
-  }
-  return state$2;
-}
-function persistNow$1() {
-  saveDirty$1 = false;
-  if (saveTimer$1) {
-    clearTimeout(saveTimer$1);
-    saveTimer$1 = null;
-  }
-  return fs.promises.mkdir(path.dirname(getHistoryPath()), { recursive: true }).then(
-    () => fs.promises.writeFile(
-      getHistoryPath(),
-      JSON.stringify(state$2, null, 2),
-      "utf-8"
-    )
-  ).catch((err) => console.error("[Vessel] Failed to save history:", err));
+function load$3() {
+  if (state$3) return state$3;
+  state$3 = loadJsonFile({
+    filePath: getHistoryPath(),
+    fallback: { entries: [] },
+    parse: (raw) => {
+      const parsed = raw;
+      return {
+        entries: Array.isArray(parsed.entries) ? parsed.entries : []
+      };
+    }
+  });
+  return state$3;
 }
+const persistence$3 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$3,
+  filePath: getHistoryPath(),
+  getValue: () => state$3,
+  logLabel: "history"
+});
 function save$1() {
-  saveDirty$1 = true;
-  if (saveTimer$1) return;
-  saveTimer$1 = setTimeout(() => {
-    saveTimer$1 = null;
-    if (saveDirty$1) {
-      void persistNow$1();
-    }
-  }, SAVE_DEBOUNCE_MS$1);
+  persistence$3.schedule();
 }
 function emit$1() {
-  if (!state$2) return;
-  const snapshot = { entries: [...state$2.entries] };
+  if (!state$3) return;
+  const snapshot = { entries: [...state$3.entries] };
   for (const listener of listeners$1) {
     listener(snapshot);
   }
 }
 function getState$1() {
-  load$1();
-  return { entries: [...state$2.entries] };
+  load$3();
+  return { entries: [...state$3.entries] };
 }
 function subscribe$1(listener) {
   listeners$1.add(listener);
@@ -1497,8 +1560,8 @@ function subscribe$1(listener) {
 }
 function addEntry$1(url, title) {
   if (!url || url === "about:blank") return;
-  load$1();
-  const last = state$2.entries[0];
+  load$3();
+  const last = state$3.entries[0];
   if (last && last.url === url) {
     if (title && title !== last.title) {
       last.title = title;
@@ -1512,28 +1575,28 @@ function addEntry$1(url, title) {
     title: title || url,
     visitedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state$2.entries.unshift(entry);
-  if (state$2.entries.length > MAX_HISTORY_ENTRIES) {
-    state$2.entries = state$2.entries.slice(0, MAX_HISTORY_ENTRIES);
+  state$3.entries.unshift(entry);
+  if (state$3.entries.length > MAX_HISTORY_ENTRIES) {
+    state$3.entries = state$3.entries.slice(0, MAX_HISTORY_ENTRIES);
   }
   save$1();
   emit$1();
 }
 function search(query, limit = 50) {
-  load$1();
-  if (!query.trim()) return state$2.entries.slice(0, limit);
+  load$3();
+  if (!query.trim()) return state$3.entries.slice(0, limit);
   const normalized = query.toLowerCase();
-  return state$2.entries.filter(
+  return state$3.entries.filter(
     (e) => e.url.toLowerCase().includes(normalized) || e.title.toLowerCase().includes(normalized)
   ).slice(0, limit);
 }
 function clearAll$1() {
-  state$2 = { entries: [] };
+  state$3 = { entries: [] };
   save$1();
   emit$1();
 }
-function flushPersist$1() {
-  return saveDirty$1 ? persistNow$1() : Promise.resolve();
+function flushPersist$3() {
+  return persistence$3.flush();
 }
 const MAX_CONSOLE_ENTRIES = 500;
 const MAX_NETWORK_ENTRIES = 200;
@@ -2246,10 +2309,14 @@ class TabManager {
   window;
   onStateChange;
   highlightCaptureCallback = null;
+  pageLoadCallback = null;
   constructor(window2, onStateChange) {
     this.window = window2;
     this.onStateChange = onStateChange;
   }
+  onPageLoad(cb) {
+    this.pageLoadCallback = cb;
+  }
   createTab(url = "about:blank", options) {
     const background = options?.background ?? false;
     const id = crypto$1.randomUUID();
@@ -2262,6 +2329,7 @@ class TabManager {
       onPageLoad: (pageUrl, wc) => {
         this.reapplyHighlights(pageUrl, wc);
         addEntry$1(pageUrl, wc.getTitle());
+        this.pageLoadCallback?.(pageUrl, wc);
       },
       onHighlightSelection: (wc) => this.captureHighlightFromPage(wc),
       onHighlightRemove: (url2, text) => this.removeHighlightByText(url2, text),
@@ -2415,7 +2483,7 @@ class TabManager {
     const wcId = wc.id;
     const now = Date.now();
     const last = this.lastReapply.get(wcId);
-    const normalized = normalizeUrl(url);
+    const normalized = normalizeUrl$1(url);
     if (last && last.url === normalized && now - last.at < 500) return;
     this.lastReapply.set(wcId, { url: normalized, at: now });
     const highlights = getHighlightsForUrl(url);
@@ -2464,14 +2532,14 @@ class TabManager {
     if (highlight) {
       removeHighlight(highlight.id);
     }
-    const normalized = normalizeUrl(url);
+    const normalized = normalizeUrl$1(url);
     for (const id of this.order) {
       const tab = this.tabs.get(id);
       if (!tab) continue;
       const wc = tab.view.webContents;
       if (wc.isDestroyed()) continue;
       try {
-        const tabUrl = normalizeUrl(wc.getURL());
+        const tabUrl = normalizeUrl$1(wc.getURL());
         if (tabUrl === normalized) {
           void this.removeHighlightMarksForText(wc, text);
         }
@@ -2488,14 +2556,14 @@ class TabManager {
     if (highlight) {
       updateHighlightColor(highlight.id, color);
     }
-    const normalized = normalizeUrl(url);
+    const normalized = normalizeUrl$1(url);
     for (const id of this.order) {
       const tab = this.tabs.get(id);
       if (!tab) continue;
       const wc = tab.view.webContents;
       if (wc.isDestroyed()) continue;
       try {
-        const tabUrl = normalizeUrl(wc.getURL());
+        const tabUrl = normalizeUrl$1(wc.getURL());
         if (tabUrl === normalized) {
           void this.removeHighlightMarksForText(wc, text).then(() => {
             void highlightOnPage(
@@ -2651,316 +2719,399 @@ const Channels = {
   // Window controls
   WINDOW_MINIMIZE: "window:minimize",
   WINDOW_MAXIMIZE: "window:maximize",
-  WINDOW_CLOSE: "window:close"
+  WINDOW_CLOSE: "window:close",
+  // Autofill
+  AUTOFILL_LIST: "autofill:list",
+  AUTOFILL_ADD: "autofill:add",
+  AUTOFILL_UPDATE: "autofill:update",
+  AUTOFILL_DELETE: "autofill:delete",
+  AUTOFILL_FILL: "autofill:fill",
+  // Page snapshots / What Changed
+  PAGE_DIFF_ACTIVITY: "page:diff-activity",
+  PAGE_CHANGED: "page:changed",
+  PAGE_DIFF_GET: "page:diff-get",
+  PAGE_DIFF_DIRTY: "page:diff-dirty"
 };
-function enableClipboardShortcuts(view) {
-  view.webContents.on("before-input-event", (event, input) => {
-    if (!input.control && !input.meta) return;
-    const key = input.key.toLowerCase();
-    const wc = view.webContents;
-    if (input.type === "keyDown") {
-      if (key === "c") {
-        wc.copy();
-        event.preventDefault();
-      } else if (key === "v") {
-        wc.paste();
-        event.preventDefault();
-      } else if (key === "x") {
-        wc.cut();
-        event.preventDefault();
-      } else if (key === "a") {
-        wc.selectAll();
-        event.preventDefault();
-      }
+const MAX_DETAIL_ITEMS = 3;
+const MIN_BLOCK_SIMILARITY = 0.82;
+function normalizeText$2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncateText(value, max = 180) {
+  const normalized = normalizeText$2(value);
+  if (normalized.length <= max) return normalized;
+  return `${normalized.slice(0, max - 3)}...`;
+}
+function tokenize(text) {
+  return normalizeText$2(text).toLowerCase().split(/\s+/).filter(Boolean);
+}
+function countOverlap(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of b) {
+    counts.set(token, (counts.get(token) || 0) + 1);
+  }
+  let overlap = 0;
+  for (const token of a) {
+    const remaining = counts.get(token) || 0;
+    if (remaining > 0) {
+      overlap += 1;
+      counts.set(token, remaining - 1);
+    }
+  }
+  return overlap;
+}
+function similarityScore(a, b) {
+  const aTokens = tokenize(a);
+  const bTokens = tokenize(b);
+  if (aTokens.length === 0 && bTokens.length === 0) return 1;
+  if (aTokens.length === 0 || bTokens.length === 0) return 0;
+  return countOverlap(aTokens, bTokens) / Math.max(aTokens.length, bTokens.length);
+}
+function extractTextBlocks(text) {
+  const compact = text.replace(/\r\n/g, "\n").trim();
+  if (!compact) return [];
+  const paragraphs = compact.split(/\n\s*\n+/).map((block) => normalizeText$2(block)).filter(Boolean);
+  if (paragraphs.length > 1) return paragraphs;
+  return compact.split(/\n+/).map((line) => normalizeText$2(line)).filter(Boolean);
+}
+function buildLcsTable(a, b) {
+  const table = Array.from(
+    { length: a.length + 1 },
+    () => Array.from({ length: b.length + 1 }).fill(0)
+  );
+  for (let i = a.length - 1; i >= 0; i -= 1) {
+    for (let j = b.length - 1; j >= 0; j -= 1) {
+      table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  return table;
+}
+function diffBlocks(oldBlocks, newBlocks) {
+  const table = buildLcsTable(oldBlocks, newBlocks);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < oldBlocks.length && j < newBlocks.length) {
+    if (oldBlocks[i] === newBlocks[j]) {
+      ops.push({ type: "equal", value: oldBlocks[i] });
+      i += 1;
+      j += 1;
+      continue;
     }
-  });
+    if (table[i + 1][j] >= table[i][j + 1]) {
+      ops.push({ type: "removed", value: oldBlocks[i] });
+      i += 1;
+    } else {
+      ops.push({ type: "added", value: newBlocks[j] });
+      j += 1;
+    }
+  }
+  while (i < oldBlocks.length) {
+    ops.push({ type: "removed", value: oldBlocks[i] });
+    i += 1;
+  }
+  while (j < newBlocks.length) {
+    ops.push({ type: "added", value: newBlocks[j] });
+    j += 1;
+  }
+  return ops;
 }
-const CHROME_HEIGHT = 110;
-const DEFAULT_DEVTOOLS_PANEL_HEIGHT = 250;
-const MIN_DEVTOOLS_PANEL = 120;
-const MAX_DEVTOOLS_PANEL = 600;
-async function getSidebarContextTarget(sidebarView, x, y) {
-  try {
-    return await sidebarView.webContents.executeJavaScript(
-      `(() => {
-        const el = document.elementFromPoint(${x}, ${y});
-        const nav = el && typeof el.closest === "function"
-          ? el.closest(".highlight-nav")
-          : null;
-        const label = nav?.querySelector(".highlight-nav-label")?.textContent?.trim() || "";
-        return {
-          inHighlightNav: !!nav,
-          canRemoveCurrent: /\\d+\\s*\\/\\s*\\d+/.test(label),
-          bookmarkId:
-            el && typeof el.closest === "function"
-              ? el.closest("[data-bookmark-id]")?.getAttribute("data-bookmark-id") || undefined
-              : undefined,
-        };
-      })()`,
-      true
+function summarizeContentChange(changedCount, addedCount, removedCount) {
+  const parts = [];
+  if (changedCount > 0) {
+    parts.push(
+      `${changedCount} updated ${changedCount === 1 ? "section" : "sections"}`
     );
-  } catch {
-    return { inHighlightNav: false, canRemoveCurrent: false };
   }
-}
-async function showSidebarContextMenu(mainWindow, sidebarView, params) {
-  const target = await getSidebarContextTarget(sidebarView, params.x, params.y);
-  const menu = new electron.Menu();
-  if (target.inHighlightNav) {
-    if (target.canRemoveCurrent) {
-      menu.append(
-        new electron.MenuItem({
-          label: "Remove Current Highlight",
-          click: () => sidebarView.webContents.send(
-            Channels.SIDEBAR_HIGHLIGHT_ACTION,
-            "remove-current"
-          )
-        })
-      );
-    }
-    menu.append(
-      new electron.MenuItem({
-        label: "Clear All Highlights",
-        click: () => sidebarView.webContents.send(
-          Channels.SIDEBAR_HIGHLIGHT_ACTION,
-          "clear-all"
-        )
-      })
+  if (addedCount > 0) {
+    parts.push(
+      `${addedCount} added ${addedCount === 1 ? "section" : "sections"}`
     );
   }
-  if (target.bookmarkId) {
-    if (menu.items.length > 0) {
-      menu.append(new electron.MenuItem({ type: "separator" }));
-    }
-    menu.append(
-      new electron.MenuItem({
-        label: "Add Context to Chat",
-        click: () => sidebarView.webContents.send(
-          Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT,
-          target.bookmarkId
-        )
-      })
+  if (removedCount > 0) {
+    parts.push(
+      `${removedCount} removed ${removedCount === 1 ? "section" : "sections"}`
     );
   }
-  if (params.isEditable) {
-    if (menu.items.length > 0) {
-      menu.append(new electron.MenuItem({ type: "separator" }));
+  return parts.join(", ");
+}
+function diffSnapshots(oldSnap, currentContent, currentTitle, currentHeadings) {
+  const changes = [];
+  if (oldSnap.title !== currentTitle) {
+    changes.push({
+      kind: "changed",
+      section: "title",
+      summary: `"${oldSnap.title}" → "${currentTitle}"`,
+      before: oldSnap.title,
+      after: currentTitle
+    });
+  }
+  const oldHeadings = oldSnap.headings.split("\n").filter(Boolean);
+  const newHeadings = currentHeadings.split("\n").filter(Boolean);
+  if (oldHeadings.join("\n") !== newHeadings.join("\n")) {
+    const added = newHeadings.filter((h) => !oldHeadings.includes(h));
+    const removed = oldHeadings.filter((h) => !newHeadings.includes(h));
+    const parts = [];
+    if (added.length > 0) parts.push(`New: ${added.join(", ")}`);
+    if (removed.length > 0) parts.push(`Gone: ${removed.join(", ")}`);
+    if (parts.length > 0) {
+      changes.push({
+        kind: added.length > 0 && removed.length > 0 ? "changed" : added.length > 0 ? "added" : "removed",
+        section: "headings",
+        summary: parts.join(". "),
+        addedItems: added.slice(0, MAX_DETAIL_ITEMS),
+        removedItems: removed.slice(0, MAX_DETAIL_ITEMS)
+      });
     }
-    menu.append(
-      new electron.MenuItem({
-        role: "undo",
-        enabled: params.editFlags.canUndo
-      })
-    );
-    menu.append(
-      new electron.MenuItem({
-        role: "redo",
-        enabled: params.editFlags.canRedo
-      })
-    );
-    menu.append(new electron.MenuItem({ type: "separator" }));
-    menu.append(
-      new electron.MenuItem({
-        role: "cut",
-        enabled: params.editFlags.canCut
-      })
-    );
-    menu.append(
-      new electron.MenuItem({
-        role: "copy",
-        enabled: params.editFlags.canCopy
-      })
-    );
-    menu.append(
-      new electron.MenuItem({
-        role: "paste",
-        enabled: params.editFlags.canPaste
-      })
-    );
-    menu.append(
-      new electron.MenuItem({
-        role: "selectAll",
-        enabled: params.editFlags.canSelectAll
-      })
-    );
-  } else if (params.selectionText?.trim()) {
-    if (menu.items.length > 0) {
-      menu.append(new electron.MenuItem({ type: "separator" }));
+  }
+  const oldBlocks = extractTextBlocks(oldSnap.textContent);
+  const newBlocks = extractTextBlocks(currentContent);
+  const overallSimilarity = similarityScore(oldSnap.textContent, currentContent);
+  if (overallSimilarity < 0.98) {
+    const ops = diffBlocks(oldBlocks, newBlocks);
+    const addedBlocks = [];
+    const removedBlocks = [];
+    const changedPairs = [];
+    let idx = 0;
+    while (idx < ops.length) {
+      if (ops[idx]?.type === "equal") {
+        idx += 1;
+        continue;
+      }
+      const pendingRemoved = [];
+      const pendingAdded = [];
+      while (idx < ops.length && ops[idx]?.type !== "equal") {
+        const op = ops[idx];
+        if (op?.type === "removed") pendingRemoved.push(op.value);
+        if (op?.type === "added") pendingAdded.push(op.value);
+        idx += 1;
+      }
+      while (pendingRemoved.length > 0 && pendingAdded.length > 0) {
+        const before = pendingRemoved[0];
+        const after = pendingAdded[0];
+        if (similarityScore(before, after) < MIN_BLOCK_SIMILARITY) break;
+        changedPairs.push({ before, after });
+        pendingRemoved.shift();
+        pendingAdded.shift();
+      }
+      removedBlocks.push(...pendingRemoved);
+      addedBlocks.push(...pendingAdded);
+    }
+    if (changedPairs.length > 0 || addedBlocks.length > 0 || removedBlocks.length > 0) {
+      changes.push({
+        kind: "changed",
+        section: "content",
+        summary: summarizeContentChange(
+          changedPairs.length,
+          addedBlocks.length,
+          removedBlocks.length
+        ),
+        before: changedPairs[0] ? truncateText(changedPairs[0].before) : removedBlocks[0] ? truncateText(removedBlocks[0]) : void 0,
+        after: changedPairs[0] ? truncateText(changedPairs[0].after) : addedBlocks[0] ? truncateText(addedBlocks[0]) : void 0,
+        addedItems: addedBlocks.slice(0, MAX_DETAIL_ITEMS).map((item) => truncateText(item)),
+        removedItems: removedBlocks.slice(0, MAX_DETAIL_ITEMS).map((item) => truncateText(item))
+      });
     }
-    menu.append(new electron.MenuItem({ role: "copy" }));
   }
-  if (menu.items.length === 0) return;
-  sidebarView.webContents.focus();
-  menu.popup({ window: mainWindow });
+  return {
+    url: oldSnap.url,
+    hasChanges: changes.length > 0,
+    oldSnapshot: { capturedAt: oldSnap.capturedAt, title: oldSnap.title },
+    changes
+  };
 }
-function getWindowIconPath() {
-  const candidates = [
-    path.join(electron.app.getAppPath(), "resources", "vessel-icon.png"),
-    path.join(process.resourcesPath, "vessel-icon.png"),
-    path.join(__dirname, "../../resources/vessel-icon.png")
-  ];
-  return candidates.find((candidate) => fs.existsSync(candidate));
+function normalizePageUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    const pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return `${url.origin}${pathname}`.toLowerCase();
+  } catch {
+    return rawUrl.trim().replace(/\/+$/, "").toLowerCase();
+  }
 }
-function createMainWindow(onTabStateChange) {
-  const mainWindow = new electron.BaseWindow({
-    width: 1280,
-    height: 800,
-    minWidth: 800,
-    minHeight: 600,
-    frame: false,
-    show: false,
-    backgroundColor: "#1a1a1e",
-    icon: getWindowIconPath()
-  });
-  const chromeView = new electron.WebContentsView({
-    webPreferences: {
-      preload: path.join(__dirname, "../preload/index.js"),
-      sandbox: true,
-      contextIsolation: true,
-      nodeIntegration: false
-    }
-  });
-  chromeView.setBackgroundColor("#00000000");
-  mainWindow.contentView.addChildView(chromeView);
-  const sidebarView = new electron.WebContentsView({
-    webPreferences: {
-      preload: path.join(__dirname, "../preload/index.js"),
-      sandbox: true,
-      contextIsolation: true,
-      nodeIntegration: false
-    }
-  });
-  sidebarView.setBackgroundColor("#00000000");
-  sidebarView.webContents.on("context-menu", (event, params) => {
-    event.preventDefault();
-    void showSidebarContextMenu(mainWindow, sidebarView, params);
-  });
-  mainWindow.contentView.addChildView(sidebarView);
-  const devtoolsPanelView = new electron.WebContentsView({
-    webPreferences: {
-      preload: path.join(__dirname, "../preload/index.js"),
-      sandbox: true,
-      contextIsolation: true,
-      nodeIntegration: false
-    }
-  });
-  devtoolsPanelView.setBackgroundColor("#00000000");
-  mainWindow.contentView.addChildView(devtoolsPanelView);
-  enableClipboardShortcuts(chromeView);
-  enableClipboardShortcuts(sidebarView);
-  enableClipboardShortcuts(devtoolsPanelView);
-  const settings2 = loadSettings();
-  const uiState = {
-    sidebarOpen: true,
-    sidebarWidth: settings2.sidebarWidth,
-    focusMode: false,
-    settingsOpen: false,
-    devtoolsPanelOpen: false,
-    devtoolsPanelHeight: DEFAULT_DEVTOOLS_PANEL_HEIGHT
-  };
-  const tabManager = new TabManager(mainWindow, onTabStateChange);
-  const state2 = {
-    mainWindow,
-    chromeView,
-    sidebarView,
-    devtoolsPanelView,
-    tabManager,
-    uiState
-  };
-  mainWindow.on("resize", () => layoutViews(state2));
-  mainWindow.on("show", () => layoutViews(state2));
-  mainWindow.on("focus", () => layoutViews(state2));
-  layoutViews(state2);
-  return state2;
+const SNAPSHOT_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "q",
+  "query",
+  "search",
+  "s",
+  "term",
+  "keyword",
+  "keywords",
+  "page",
+  "p",
+  "offset",
+  "cursor",
+  "sort",
+  "order",
+  "filter",
+  "filters",
+  "category",
+  "categories",
+  "tag",
+  "tags",
+  "tab",
+  "view"
+]);
+const TRACKING_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "fbclid",
+  "gclid",
+  "mc_cid",
+  "mc_eid",
+  "ref",
+  "source",
+  "si"
+]);
+function normalizeQueryValue(value) {
+  return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function serializeSnapshotParams(params) {
+  return params.map(
+    ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+  ).join("&");
+}
+function normalizeSnapshotParams(entries, pathname) {
+  return Array.from(entries).filter(
+    ([key, value]) => shouldKeepSnapshotQueryParam(pathname, key, value)
+  ).map(([key, value]) => [
+    key.trim().toLowerCase(),
+    normalizeQueryValue(value)
+  ]).sort(
+    ([keyA, valueA], [keyB, valueB]) => keyA === keyB ? valueA.localeCompare(valueB) : keyA.localeCompare(keyB)
+  );
 }
-function layoutViews(state2) {
-  const {
-    mainWindow,
-    chromeView,
-    sidebarView,
-    devtoolsPanelView,
-    tabManager,
-    uiState
-  } = state2;
-  const [width, height] = mainWindow.getContentSize();
-  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
-  const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
-  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
-  const chromeNeedsFullHeight = uiState.settingsOpen;
-  if (chromeNeedsFullHeight) {
-    chromeView.setBounds({ x: 0, y: 0, width, height });
-  } else {
-    chromeView.setBounds({ x: 0, y: 0, width, height: chromeHeight });
+function shouldKeepSnapshotQueryParam(pathname, rawKey, value) {
+  const key = rawKey.trim().toLowerCase();
+  if (!key || !value.trim()) return false;
+  if (key.startsWith("utm_")) return false;
+  if (TRACKING_QUERY_KEYS.has(key)) return false;
+  if (SNAPSHOT_QUERY_KEYS.has(key)) return true;
+  return /\/(search|results|browse|discover|find|category|tag|topics?|collections?|list)(\/|$)/i.test(
+    pathname
+  );
+}
+function buildSnapshotHashKey(hash, pathname) {
+  let raw = hash.replace(/^#/, "").trim();
+  if (!raw) return null;
+  let bang = false;
+  if (raw.startsWith("!")) {
+    bang = true;
+    raw = raw.slice(1).trim();
+  }
+  if (raw.startsWith("/")) {
+    const [routePart, queryPart = ""] = raw.split("?");
+    const route = routePart.replace(/\/+$/, "") || "/";
+    const params = normalizeSnapshotParams(
+      new URLSearchParams(queryPart).entries(),
+      pathname
+    );
+    const query = serializeSnapshotParams(params);
+    return `#${bang ? "!" : ""}${route.toLowerCase()}${query ? `?${query}` : ""}`;
+  }
+  const queryLike = raw.startsWith("?") ? raw.slice(1) : raw;
+  if (queryLike.includes("=")) {
+    const params = normalizeSnapshotParams(
+      new URLSearchParams(queryLike).entries(),
+      pathname
+    );
+    if (params.length === 0) return null;
+    const query = serializeSnapshotParams(params);
+    return `#${bang ? "!" : ""}?${query}`;
   }
-  const resizeHandleOverlap = 6;
-  if (uiState.sidebarOpen) {
-    sidebarView.setBounds({
-      x: width - sidebarWidth - resizeHandleOverlap,
-      y: 0,
-      width: sidebarWidth + resizeHandleOverlap,
-      height
-    });
-  } else {
-    sidebarView.setBounds({ x: width, y: 0, width: 0, height: 0 });
+  return null;
+}
+function buildPageSnapshotKey(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    const pathname = url.pathname.replace(/\/+$/, "") || "/";
+    const params = normalizeSnapshotParams(url.searchParams.entries(), pathname);
+    const query = serializeSnapshotParams(params);
+    const hash = buildSnapshotHashKey(url.hash, pathname);
+    return `${url.origin.toLowerCase()}${pathname.toLowerCase()}${query ? `?${query}` : ""}${hash || ""}`;
+  } catch {
+    return normalizePageUrl(rawUrl);
   }
-  const contentWidth = width - sidebarWidth;
-  if (uiState.devtoolsPanelOpen) {
-    devtoolsPanelView.setBounds({
-      x: 0,
-      y: height - devtoolsHeight,
-      width: contentWidth,
-      height: devtoolsHeight
-    });
-  } else {
-    devtoolsPanelView.setBounds({ x: 0, y: height, width: 0, height: 0 });
+}
+function isTrackablePageUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
   }
-  mainWindow.contentView.removeChildView(chromeView);
-  mainWindow.contentView.addChildView(chromeView);
-  mainWindow.contentView.removeChildView(sidebarView);
-  mainWindow.contentView.addChildView(sidebarView);
-  mainWindow.contentView.removeChildView(devtoolsPanelView);
-  mainWindow.contentView.addChildView(devtoolsPanelView);
-  const activeTab = tabManager.getActiveTab();
-  if (activeTab) {
-    activeTab.view.setBounds({
-      x: 0,
-      y: chromeHeight,
-      width: contentWidth,
-      height: height - chromeHeight - devtoolsHeight
-    });
+}
+const SAVE_DEBOUNCE_MS$2 = 500;
+const MAX_TEXT_LENGTH = 8e3;
+let snapshots = null;
+function getFilePath$1() {
+  return path.join(electron.app.getPath("userData"), "vessel-page-snapshots.json");
+}
+function normalizeStoredSnapshot(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.url !== "string" || typeof raw.title !== "string" || typeof raw.textContent !== "string" || typeof raw.headings !== "string" || typeof raw.capturedAt !== "string") {
+    return null;
   }
+  return {
+    url: raw.url,
+    title: raw.title,
+    textContent: raw.textContent,
+    headings: raw.headings,
+    capturedAt: raw.capturedAt
+  };
 }
-function resizeSidebarViews(state2) {
-  const { mainWindow, sidebarView, devtoolsPanelView, tabManager, uiState } = state2;
-  const [width, height] = mainWindow.getContentSize();
-  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
-  const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
-  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
-  const resizeHandleOverlap = 6;
-  const contentWidth = width - sidebarWidth;
-  sidebarView.setBounds({
-    x: width - sidebarWidth - resizeHandleOverlap,
-    y: 0,
-    width: sidebarWidth + resizeHandleOverlap,
-    height
+function load$2() {
+  if (snapshots) return snapshots;
+  snapshots = loadJsonFile({
+    filePath: getFilePath$1(),
+    fallback: /* @__PURE__ */ new Map(),
+    secure: true,
+    parse: (raw) => {
+      const next = /* @__PURE__ */ new Map();
+      if (!Array.isArray(raw)) return next;
+      for (const entry of raw) {
+        const snapshot = normalizeStoredSnapshot(entry);
+        if (snapshot) next.set(snapshot.url, snapshot);
+      }
+      return next;
+    }
   });
-  if (uiState.devtoolsPanelOpen) {
-    devtoolsPanelView.setBounds({
-      x: 0,
-      y: height - devtoolsHeight,
-      width: contentWidth,
-      height: devtoolsHeight
-    });
-  }
-  const activeTab = tabManager.getActiveTab();
-  if (activeTab) {
-    activeTab.view.setBounds({
-      x: 0,
-      y: chromeHeight,
-      width: contentWidth,
-      height: height - chromeHeight - devtoolsHeight
-    });
-  }
+  return snapshots;
+}
+const persistence$2 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$2,
+  filePath: getFilePath$1(),
+  getValue: () => snapshots,
+  logLabel: "page snapshots",
+  secure: true,
+  serialize: (value) => Array.from(value.values()).slice(-500)
+});
+function normalizeUrl(rawUrl) {
+  return buildPageSnapshotKey(rawUrl);
+}
+function shouldTrackSnapshotUrl(rawUrl) {
+  return isTrackablePageUrl(rawUrl);
+}
+function getSnapshot(normalizedUrl) {
+  return load$2().get(normalizedUrl);
+}
+function saveSnapshot(rawUrl, title, textContent, headings) {
+  const s = load$2();
+  const key = normalizeUrl(rawUrl);
+  const snapshot = {
+    url: key,
+    title,
+    textContent: textContent.slice(0, MAX_TEXT_LENGTH),
+    headings: headings.map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n"),
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.delete(key);
+  s.set(key, snapshot);
+  persistence$2.schedule();
+  return snapshot;
+}
+function flushPersist$2() {
+  return persistence$2.flush();
 }
 const SEARCH_ENGINE_HOSTS = [
   "google.",
@@ -5013,35 +5164,455 @@ function normalizePageContent(value) {
     pageIssues: Array.isArray(page.pageIssues) ? page.pageIssues : []
   };
 }
-function generateReaderHTML(page) {
-  const escapedTitle = escapeHtml(page.title);
-  const escapedByline = escapeHtml(page.byline);
-  const renderedContent = renderReaderContent(page);
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'">
-  <title>${escapedTitle}</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      background: #1a1a1e;
-      color: #d4d4d8;
-      font-family: Charter, Georgia, serif;
-      font-size: 19px;
-      line-height: 1.7;
-      padding: 3rem 1.5rem;
+const latestPageDiffs = /* @__PURE__ */ new Map();
+const recentPageDiffBursts = /* @__PURE__ */ new Map();
+const pendingPageSnapshotTimers = /* @__PURE__ */ new Map();
+const pendingPageSnapshotDueAt = /* @__PURE__ */ new Map();
+const lastMutationSnapshotAt = /* @__PURE__ */ new Map();
+const lastMutationActivityAt = /* @__PURE__ */ new Map();
+const MIN_MUTATION_CAPTURE_INTERVAL_MS = 5e3;
+const SETTLE_AFTER_ACTIVITY_MS = 1500;
+function getLatestPageDiff(rawUrl) {
+  if (!shouldTrackSnapshotUrl(rawUrl)) return null;
+  return latestPageDiffs.get(normalizeUrl(rawUrl)) ?? null;
+}
+function summarizeDiffBurst(diff) {
+  const items = diff.changes.slice(0, 2).map((change) => `${change.section}: ${change.summary}`);
+  return items.join(" | ");
+}
+function enrichWithBurstHistory(key, diff) {
+  const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nextBurst = {
+    detectedAt,
+    summary: summarizeDiffBurst(diff)
+  };
+  const bursts = [...recentPageDiffBursts.get(key) || [], nextBurst].slice(
+    -5
+  );
+  recentPageDiffBursts.set(key, bursts);
+  return {
+    ...diff,
+    burstCount: bursts.length,
+    firstDetectedAt: bursts[0]?.detectedAt,
+    lastDetectedAt: bursts[bursts.length - 1]?.detectedAt,
+    recentBursts: bursts
+  };
+}
+async function capturePageSnapshot(url, wc, sendToRendererViews) {
+  try {
+    if (!shouldTrackSnapshotUrl(url)) return;
+    const key = normalizeUrl(url);
+    const oldSnap = getSnapshot(key);
+    const content = await extractContent(wc);
+    const textContent = content.content || "";
+    const title = content.title || "";
+    const headings = content.headings || [];
+    const currentHeadings = headings.map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n");
+    if (oldSnap) {
+      const diff = diffSnapshots(oldSnap, textContent, title, currentHeadings);
+      if (diff.hasChanges) {
+        const enrichedDiff = enrichWithBurstHistory(key, diff);
+        latestPageDiffs.set(key, enrichedDiff);
+        sendToRendererViews(Channels.PAGE_CHANGED, enrichedDiff);
+      } else {
+        latestPageDiffs.delete(key);
+      }
+    } else {
+      latestPageDiffs.delete(key);
+      recentPageDiffBursts.delete(key);
     }
-    .reader-container {
-      max-width: 680px;
-      margin: 0 auto;
+    saveSnapshot(url, title, textContent, headings);
+  } catch {
+  }
+}
+function computeNextSnapshotDueAt(wcId, now, delayMs) {
+  const lastCaptureAt = lastMutationSnapshotAt.get(wcId) || 0;
+  const lastActivityAt = lastMutationActivityAt.get(wcId) || 0;
+  const earliestAllowedAt = lastCaptureAt + MIN_MUTATION_CAPTURE_INTERVAL_MS;
+  const stableAfterActivityAt = lastActivityAt ? lastActivityAt + SETTLE_AFTER_ACTIVITY_MS : 0;
+  return Math.max(now + delayMs, earliestAllowedAt, stableAfterActivityAt);
+}
+function scheduleTimerAt(wc, sendToRendererViews, dueAt) {
+  const wcId = wc.id;
+  const existing = pendingPageSnapshotTimers.get(wcId);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
+    pendingPageSnapshotTimers.delete(wcId);
+    pendingPageSnapshotDueAt.delete(wcId);
+    if (wc.isDestroyed()) return;
+    lastMutationSnapshotAt.set(wcId, Date.now());
+    void capturePageSnapshot(wc.getURL(), wc, sendToRendererViews);
+  }, Math.max(0, dueAt - Date.now()));
+  pendingPageSnapshotTimers.set(wcId, timer);
+  pendingPageSnapshotDueAt.set(wcId, dueAt);
+}
+function notePageMutationActivity(wc, sendToRendererViews) {
+  if (wc.isDestroyed()) return;
+  const wcId = wc.id;
+  const now = Date.now();
+  lastMutationActivityAt.set(wcId, now);
+  const existingDueAt = pendingPageSnapshotDueAt.get(wcId);
+  if (existingDueAt == null) return;
+  const nextDueAt = computeNextSnapshotDueAt(wcId, now, 0);
+  if (nextDueAt <= existingDueAt) return;
+  scheduleTimerAt(wc, sendToRendererViews, nextDueAt);
+}
+function schedulePageSnapshotCapture(wc, sendToRendererViews, delayMs = 0) {
+  if (wc.isDestroyed()) return;
+  const wcId = wc.id;
+  const now = Date.now();
+  const nextDueAt = computeNextSnapshotDueAt(wcId, now, delayMs);
+  const existingDueAt = pendingPageSnapshotDueAt.get(wcId);
+  if (existingDueAt != null && existingDueAt >= nextDueAt) {
+    return;
+  }
+  scheduleTimerAt(wc, sendToRendererViews, nextDueAt);
+}
+function enableClipboardShortcuts(view) {
+  view.webContents.on("before-input-event", (event, input) => {
+    if (!input.control && !input.meta) return;
+    const key = input.key.toLowerCase();
+    const wc = view.webContents;
+    if (input.type === "keyDown") {
+      if (key === "c") {
+        wc.copy();
+        event.preventDefault();
+      } else if (key === "v") {
+        wc.paste();
+        event.preventDefault();
+      } else if (key === "x") {
+        wc.cut();
+        event.preventDefault();
+      } else if (key === "a") {
+        wc.selectAll();
+        event.preventDefault();
+      }
     }
-    h1 {
-      font-size: 1.8em;
-      line-height: 1.3;
-      margin-bottom: 0.5rem;
+  });
+}
+const CHROME_HEIGHT = 110;
+const DEFAULT_DEVTOOLS_PANEL_HEIGHT = 250;
+const MIN_DEVTOOLS_PANEL = 120;
+const MAX_DEVTOOLS_PANEL = 600;
+async function getSidebarContextTarget(sidebarView, x, y) {
+  try {
+    return await sidebarView.webContents.executeJavaScript(
+      `(() => {
+        const el = document.elementFromPoint(${x}, ${y});
+        const nav = el && typeof el.closest === "function"
+          ? el.closest(".highlight-nav")
+          : null;
+        const label = nav?.querySelector(".highlight-nav-label")?.textContent?.trim() || "";
+        return {
+          inHighlightNav: !!nav,
+          canRemoveCurrent: /\\d+\\s*\\/\\s*\\d+/.test(label),
+          bookmarkId:
+            el && typeof el.closest === "function"
+              ? el.closest("[data-bookmark-id]")?.getAttribute("data-bookmark-id") || undefined
+              : undefined,
+        };
+      })()`,
+      true
+    );
+  } catch {
+    return { inHighlightNav: false, canRemoveCurrent: false };
+  }
+}
+async function showSidebarContextMenu(mainWindow, sidebarView, params) {
+  const target = await getSidebarContextTarget(sidebarView, params.x, params.y);
+  const menu = new electron.Menu();
+  if (target.inHighlightNav) {
+    if (target.canRemoveCurrent) {
+      menu.append(
+        new electron.MenuItem({
+          label: "Remove Current Highlight",
+          click: () => sidebarView.webContents.send(
+            Channels.SIDEBAR_HIGHLIGHT_ACTION,
+            "remove-current"
+          )
+        })
+      );
+    }
+    menu.append(
+      new electron.MenuItem({
+        label: "Clear All Highlights",
+        click: () => sidebarView.webContents.send(
+          Channels.SIDEBAR_HIGHLIGHT_ACTION,
+          "clear-all"
+        )
+      })
+    );
+  }
+  if (target.bookmarkId) {
+    if (menu.items.length > 0) {
+      menu.append(new electron.MenuItem({ type: "separator" }));
+    }
+    menu.append(
+      new electron.MenuItem({
+        label: "Add Context to Chat",
+        click: () => sidebarView.webContents.send(
+          Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT,
+          target.bookmarkId
+        )
+      })
+    );
+  }
+  if (params.isEditable) {
+    if (menu.items.length > 0) {
+      menu.append(new electron.MenuItem({ type: "separator" }));
+    }
+    menu.append(
+      new electron.MenuItem({
+        role: "undo",
+        enabled: params.editFlags.canUndo
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        role: "redo",
+        enabled: params.editFlags.canRedo
+      })
+    );
+    menu.append(new electron.MenuItem({ type: "separator" }));
+    menu.append(
+      new electron.MenuItem({
+        role: "cut",
+        enabled: params.editFlags.canCut
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        role: "copy",
+        enabled: params.editFlags.canCopy
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        role: "paste",
+        enabled: params.editFlags.canPaste
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        role: "selectAll",
+        enabled: params.editFlags.canSelectAll
+      })
+    );
+  } else if (params.selectionText?.trim()) {
+    if (menu.items.length > 0) {
+      menu.append(new electron.MenuItem({ type: "separator" }));
+    }
+    menu.append(new electron.MenuItem({ role: "copy" }));
+  }
+  if (menu.items.length === 0) return;
+  sidebarView.webContents.focus();
+  menu.popup({ window: mainWindow });
+}
+function getWindowIconPath() {
+  const candidates = [
+    path.join(electron.app.getAppPath(), "resources", "vessel-icon.png"),
+    path.join(process.resourcesPath, "vessel-icon.png"),
+    path.join(__dirname, "../../resources/vessel-icon.png")
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+function createMainWindow(onTabStateChange) {
+  const mainWindow = new electron.BaseWindow({
+    width: 1280,
+    height: 800,
+    minWidth: 800,
+    minHeight: 600,
+    frame: false,
+    show: false,
+    backgroundColor: "#1a1a1e",
+    icon: getWindowIconPath()
+  });
+  const chromeView = new electron.WebContentsView({
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  chromeView.setBackgroundColor("#00000000");
+  mainWindow.contentView.addChildView(chromeView);
+  const sidebarView = new electron.WebContentsView({
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  sidebarView.setBackgroundColor("#00000000");
+  sidebarView.webContents.on("context-menu", (event, params) => {
+    event.preventDefault();
+    void showSidebarContextMenu(mainWindow, sidebarView, params);
+  });
+  mainWindow.contentView.addChildView(sidebarView);
+  const devtoolsPanelView = new electron.WebContentsView({
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  devtoolsPanelView.setBackgroundColor("#00000000");
+  mainWindow.contentView.addChildView(devtoolsPanelView);
+  enableClipboardShortcuts(chromeView);
+  enableClipboardShortcuts(sidebarView);
+  enableClipboardShortcuts(devtoolsPanelView);
+  const settings2 = loadSettings();
+  const uiState = {
+    sidebarOpen: true,
+    sidebarWidth: settings2.sidebarWidth,
+    focusMode: false,
+    settingsOpen: false,
+    devtoolsPanelOpen: false,
+    devtoolsPanelHeight: DEFAULT_DEVTOOLS_PANEL_HEIGHT
+  };
+  const tabManager = new TabManager(mainWindow, onTabStateChange);
+  const sendToRendererViews = (channel, ...args) => {
+    chromeView.webContents.send(channel, ...args);
+    sidebarView.webContents.send(channel, ...args);
+  };
+  tabManager.onPageLoad((url, wc) => {
+    void capturePageSnapshot(url, wc, sendToRendererViews);
+  });
+  const state2 = {
+    mainWindow,
+    chromeView,
+    sidebarView,
+    devtoolsPanelView,
+    tabManager,
+    uiState
+  };
+  mainWindow.on("resize", () => layoutViews(state2));
+  mainWindow.on("show", () => layoutViews(state2));
+  mainWindow.on("focus", () => layoutViews(state2));
+  layoutViews(state2);
+  return state2;
+}
+function layoutViews(state2) {
+  const {
+    mainWindow,
+    chromeView,
+    sidebarView,
+    devtoolsPanelView,
+    tabManager,
+    uiState
+  } = state2;
+  const [width, height] = mainWindow.getContentSize();
+  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
+  const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
+  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
+  const chromeNeedsFullHeight = uiState.settingsOpen;
+  if (chromeNeedsFullHeight) {
+    chromeView.setBounds({ x: 0, y: 0, width, height });
+  } else {
+    chromeView.setBounds({ x: 0, y: 0, width, height: chromeHeight });
+  }
+  const resizeHandleOverlap = 6;
+  if (uiState.sidebarOpen) {
+    sidebarView.setBounds({
+      x: width - sidebarWidth - resizeHandleOverlap,
+      y: 0,
+      width: sidebarWidth + resizeHandleOverlap,
+      height
+    });
+  } else {
+    sidebarView.setBounds({ x: width, y: 0, width: 0, height: 0 });
+  }
+  const contentWidth = width - sidebarWidth;
+  if (uiState.devtoolsPanelOpen) {
+    devtoolsPanelView.setBounds({
+      x: 0,
+      y: height - devtoolsHeight,
+      width: contentWidth,
+      height: devtoolsHeight
+    });
+  } else {
+    devtoolsPanelView.setBounds({ x: 0, y: height, width: 0, height: 0 });
+  }
+  mainWindow.contentView.removeChildView(chromeView);
+  mainWindow.contentView.addChildView(chromeView);
+  mainWindow.contentView.removeChildView(sidebarView);
+  mainWindow.contentView.addChildView(sidebarView);
+  mainWindow.contentView.removeChildView(devtoolsPanelView);
+  mainWindow.contentView.addChildView(devtoolsPanelView);
+  const activeTab = tabManager.getActiveTab();
+  if (activeTab) {
+    activeTab.view.setBounds({
+      x: 0,
+      y: chromeHeight,
+      width: contentWidth,
+      height: height - chromeHeight - devtoolsHeight
+    });
+  }
+}
+function resizeSidebarViews(state2) {
+  const { mainWindow, sidebarView, devtoolsPanelView, tabManager, uiState } = state2;
+  const [width, height] = mainWindow.getContentSize();
+  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
+  const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
+  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
+  const resizeHandleOverlap = 6;
+  const contentWidth = width - sidebarWidth;
+  sidebarView.setBounds({
+    x: width - sidebarWidth - resizeHandleOverlap,
+    y: 0,
+    width: sidebarWidth + resizeHandleOverlap,
+    height
+  });
+  if (uiState.devtoolsPanelOpen) {
+    devtoolsPanelView.setBounds({
+      x: 0,
+      y: height - devtoolsHeight,
+      width: contentWidth,
+      height: devtoolsHeight
+    });
+  }
+  const activeTab = tabManager.getActiveTab();
+  if (activeTab) {
+    activeTab.view.setBounds({
+      x: 0,
+      y: chromeHeight,
+      width: contentWidth,
+      height: height - chromeHeight - devtoolsHeight
+    });
+  }
+}
+function generateReaderHTML(page) {
+  const escapedTitle = escapeHtml(page.title);
+  const escapedByline = escapeHtml(page.byline);
+  const renderedContent = renderReaderContent(page);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'">
+  <title>${escapedTitle}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      background: #1a1a1e;
+      color: #d4d4d8;
+      font-family: Charter, Georgia, serif;
+      font-size: 19px;
+      line-height: 1.7;
+      padding: 3rem 1.5rem;
+    }
+    .reader-container {
+      max-width: 680px;
+      margin: 0 auto;
+    }
+    h1 {
+      font-size: 1.8em;
+      line-height: 1.3;
+      margin-bottom: 0.5rem;
       color: #e4e4e8;
     }
     .byline {
@@ -5123,7 +5694,7 @@ function onRuntimeHealthChange(listener) {
   };
 }
 function getMcpStatus() {
-  return state$1.mcp.status;
+  return state$2.mcp.status;
 }
 function emitRuntimeHealthChange() {
   const snapshot = getRuntimeHealth();
@@ -5131,7 +5702,7 @@ function emitRuntimeHealthChange() {
     listener(snapshot);
   }
 }
-const state$1 = {
+const state$2 = {
   userDataPath: "",
   settingsPath: "",
   startupIssues: [],
@@ -5144,248 +5715,46 @@ const state$1 = {
   }
 };
 function initializeRuntimeHealth(paths) {
-  state$1.userDataPath = paths.userDataPath;
-  state$1.settingsPath = paths.settingsPath;
-  state$1.mcp.configuredPort = paths.configuredPort;
-  state$1.mcp.activePort = null;
-  state$1.mcp.endpoint = null;
-  state$1.mcp.status = "stopped";
-  state$1.mcp.message = "MCP server has not started yet.";
-  emitRuntimeHealthChange();
-}
-function setStartupIssues(issues) {
-  state$1.startupIssues = issues.map((issue) => ({ ...issue }));
-  emitRuntimeHealthChange();
-}
-function getRuntimeHealth() {
-  return {
-    userDataPath: state$1.userDataPath,
-    settingsPath: state$1.settingsPath,
-    startupIssues: state$1.startupIssues.map((issue) => ({ ...issue })),
-    mcp: { ...state$1.mcp }
-  };
-}
-function setMcpHealth(update) {
-  if (typeof update.configuredPort === "number") {
-    state$1.mcp.configuredPort = update.configuredPort;
-  }
-  if ("activePort" in update) {
-    state$1.mcp.activePort = update.activePort ?? null;
-  }
-  if ("endpoint" in update) {
-    state$1.mcp.endpoint = update.endpoint ?? null;
-  }
-  const prevStatus = state$1.mcp.status;
-  state$1.mcp.status = update.status;
-  state$1.mcp.message = update.message;
-  if (prevStatus !== state$1.mcp.status) {
-    for (const listener of mcpStatusChangeListeners) {
-      listener(state$1.mcp.status);
-    }
-  }
-  emitRuntimeHealthChange();
-}
-const VAULT_FILENAME = "vessel-vault.enc";
-const KEY_FILENAME = "vessel-vault.key";
-const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 12;
-const AUTH_TAG_LENGTH = 16;
-let cachedEntries = null;
-function getVaultDir() {
-  return electron.app.getPath("userData");
-}
-function getVaultPath() {
-  return path$1.join(getVaultDir(), VAULT_FILENAME);
-}
-function getKeyPath() {
-  return path$1.join(getVaultDir(), KEY_FILENAME);
-}
-function assertVaultSecretStorageAvailable() {
-  if (!electron.safeStorage.isEncryptionAvailable()) {
-    throw new Error(
-      "Agent Credential Vault requires OS-backed secret storage. Enable Keychain, DPAPI, or libsecret support and restart Vessel."
-    );
-  }
-}
-function getOrCreateEncryptionKey() {
-  assertVaultSecretStorageAvailable();
-  const keyPath = getKeyPath();
-  if (fs$1.existsSync(keyPath)) {
-    const encryptedKey = fs$1.readFileSync(keyPath);
-    return Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8");
-  }
-  const key = crypto$2.randomBytes(32);
-  fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
-  const encrypted = electron.safeStorage.encryptString(key.toString("utf-8"));
-  fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
-  return key;
-}
-function encrypt(plaintext) {
-  const key = getOrCreateEncryptionKey();
-  const iv = crypto$2.randomBytes(IV_LENGTH);
-  const cipher = crypto$2.createCipheriv(ALGORITHM, key, iv, {
-    authTagLength: AUTH_TAG_LENGTH
-  });
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext, "utf-8"),
-    cipher.final()
-  ]);
-  const authTag = cipher.getAuthTag();
-  return Buffer.concat([iv, authTag, encrypted]);
-}
-function decrypt(data) {
-  const key = getOrCreateEncryptionKey();
-  const iv = data.subarray(0, IV_LENGTH);
-  const authTag = data.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
-  const ciphertext = data.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
-  const decipher = crypto$2.createDecipheriv(ALGORITHM, key, iv, {
-    authTagLength: AUTH_TAG_LENGTH
-  });
-  decipher.setAuthTag(authTag);
-  return decipher.update(ciphertext, void 0, "utf-8") + decipher.final("utf-8");
-}
-function loadVault() {
-  if (cachedEntries) return cachedEntries;
-  const vaultPath = getVaultPath();
-  if (!fs$1.existsSync(vaultPath)) {
-    cachedEntries = [];
-    return cachedEntries;
-  }
-  try {
-    const raw = fs$1.readFileSync(vaultPath);
-    const json = decrypt(raw);
-    cachedEntries = JSON.parse(json);
-    return cachedEntries;
-  } catch (err) {
-    console.error("[Vessel Vault] Failed to load vault:", err);
-    throw new Error(
-      "Could not unlock the Agent Credential Vault. Check that OS secret storage is available and that the stored vault key can be decrypted."
-    );
-  }
-}
-function saveVault(entries) {
-  const json = JSON.stringify(entries, null, 2);
-  const encrypted = encrypt(json);
-  const vaultPath = getVaultPath();
-  fs$1.mkdirSync(path$1.dirname(vaultPath), { recursive: true });
-  fs$1.writeFileSync(vaultPath, encrypted);
-  fs$1.chmodSync(vaultPath, 384);
-  cachedEntries = entries;
-}
-function domainMatches(pattern, hostname) {
-  const p = pattern.toLowerCase().trim();
-  const h = hostname.toLowerCase().trim();
-  if (p === h) return true;
-  if (p.startsWith("*.")) {
-    const suffix = p.slice(2);
-    return h === suffix || h.endsWith("." + suffix);
-  }
-  return false;
-}
-function listEntries() {
-  return loadVault().map(({ password, totpSecret, ...rest }) => rest);
-}
-function findEntriesForDomain(url) {
-  let hostname;
-  try {
-    hostname = new URL(url).hostname;
-  } catch {
-    return [];
-  }
-  return loadVault().filter((e) => domainMatches(e.domainPattern, hostname)).map(({ password, totpSecret, ...rest }) => rest);
-}
-function addEntry(entry) {
-  const entries = loadVault();
-  const newEntry = {
-    ...entry,
-    id: crypto$2.randomUUID(),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    useCount: 0
-  };
-  entries.push(newEntry);
-  saveVault(entries);
-  return newEntry;
-}
-function updateEntry(id, updates) {
-  const entries = loadVault();
-  const idx = entries.findIndex((e) => e.id === id);
-  if (idx === -1) return null;
-  entries[idx] = { ...entries[idx], ...updates };
-  saveVault(entries);
-  return entries[idx];
-}
-function removeEntry(id) {
-  const entries = loadVault();
-  const idx = entries.findIndex((e) => e.id === id);
-  if (idx === -1) return false;
-  entries.splice(idx, 1);
-  saveVault(entries);
-  return true;
-}
-function recordUsage(id) {
-  const entries = loadVault();
-  const entry = entries.find((e) => e.id === id);
-  if (!entry) return;
-  entry.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
-  entry.useCount += 1;
-  saveVault(entries);
+  state$2.userDataPath = paths.userDataPath;
+  state$2.settingsPath = paths.settingsPath;
+  state$2.mcp.configuredPort = paths.configuredPort;
+  state$2.mcp.activePort = null;
+  state$2.mcp.endpoint = null;
+  state$2.mcp.status = "stopped";
+  state$2.mcp.message = "MCP server has not started yet.";
+  emitRuntimeHealthChange();
 }
-function getCredential(id) {
-  const entry = loadVault().find((e) => e.id === id);
-  if (!entry) return null;
-  return { username: entry.username, password: entry.password };
+function setStartupIssues(issues) {
+  state$2.startupIssues = issues.map((issue) => ({ ...issue }));
+  emitRuntimeHealthChange();
 }
-function getTotpSecret(id) {
-  const entry = loadVault().find((e) => e.id === id);
-  return entry?.totpSecret ?? null;
+function getRuntimeHealth() {
+  return {
+    userDataPath: state$2.userDataPath,
+    settingsPath: state$2.settingsPath,
+    startupIssues: state$2.startupIssues.map((issue) => ({ ...issue })),
+    mcp: { ...state$2.mcp }
+  };
 }
-function generateTotpCode(secret) {
-  const epoch = Math.floor(Date.now() / 1e3);
-  const counter = Math.floor(epoch / 30);
-  const base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-  const cleanSecret = secret.replace(/[\s=-]/g, "").toUpperCase();
-  let bits = "";
-  for (const ch of cleanSecret) {
-    const val = base32Chars.indexOf(ch);
-    if (val === -1) continue;
-    bits += val.toString(2).padStart(5, "0");
+function setMcpHealth(update) {
+  if (typeof update.configuredPort === "number") {
+    state$2.mcp.configuredPort = update.configuredPort;
   }
-  const keyBytes = Buffer.alloc(Math.floor(bits.length / 8));
-  for (let i = 0; i < keyBytes.length; i++) {
-    keyBytes[i] = parseInt(bits.slice(i * 8, i * 8 + 8), 2);
+  if ("activePort" in update) {
+    state$2.mcp.activePort = update.activePort ?? null;
   }
-  const counterBuf = Buffer.alloc(8);
-  counterBuf.writeUInt32BE(Math.floor(counter / 4294967296), 0);
-  counterBuf.writeUInt32BE(counter & 4294967295, 4);
-  const hmac = crypto$2.createHmac("sha1", keyBytes).update(counterBuf).digest();
-  const offset = hmac[hmac.length - 1] & 15;
-  const code = (hmac[offset] & 127) << 24 | (hmac[offset + 1] & 255) << 16 | (hmac[offset + 2] & 255) << 8 | hmac[offset + 3] & 255;
-  return (code % 1e6).toString().padStart(6, "0");
-}
-const AUDIT_FILENAME = "vessel-vault-audit.jsonl";
-const MAX_ENTRIES = 1e3;
-function getAuditPath() {
-  return path$1.join(electron.app.getPath("userData"), AUDIT_FILENAME);
-}
-function appendAuditEntry(entry) {
-  try {
-    const auditPath = getAuditPath();
-    fs$1.mkdirSync(path$1.dirname(auditPath), { recursive: true });
-    fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n");
-  } catch (err) {
-    console.error("[Vessel Vault] Failed to write audit log:", err);
+  if ("endpoint" in update) {
+    state$2.mcp.endpoint = update.endpoint ?? null;
   }
-}
-function readAuditLog(limit = 100) {
-  try {
-    const auditPath = getAuditPath();
-    if (!fs$1.existsSync(auditPath)) return [];
-    const lines = fs$1.readFileSync(auditPath, "utf-8").split("\n").filter((l) => l.trim());
-    return lines.slice(-Math.min(limit, MAX_ENTRIES)).map((line) => JSON.parse(line)).reverse();
-  } catch (err) {
-    console.error("[Vessel Vault] Failed to read audit log:", err);
-    return [];
+  const prevStatus = state$2.mcp.status;
+  state$2.mcp.status = update.status;
+  state$2.mcp.message = update.message;
+  if (prevStatus !== state$2.mcp.status) {
+    for (const listener of mcpStatusChangeListeners) {
+      listener(state$2.mcp.status);
+    }
   }
+  emitRuntimeHealthChange();
 }
 function isRichToolResult(value) {
   return typeof value === "object" && value !== null && "__richResult" in value && value.__richResult === true;
@@ -9993,11 +10362,9 @@ function getBookmarkSearchMatch(args) {
 }
 const UNSORTED_ID = "unsorted";
 const ARCHIVE_FOLDER_NAME = "Archive";
-const SAVE_DEBOUNCE_MS = 250;
-let state = null;
+const SAVE_DEBOUNCE_MS$1 = 250;
+let state$1 = null;
 const listeners = /* @__PURE__ */ new Set();
-let saveTimer = null;
-let saveDirty = false;
 function cloneState(current) {
   return {
     folders: current.folders.map((folder) => ({ ...folder })),
@@ -10007,53 +10374,39 @@ function cloneState(current) {
 function getBookmarksPath() {
   return path.join(electron.app.getPath("userData"), "vessel-bookmarks.json");
 }
-function load() {
-  if (state) return state;
-  try {
-    const raw = fs.readFileSync(getBookmarksPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    state = {
-      folders: Array.isArray(parsed.folders) ? parsed.folders : [],
-      bookmarks: Array.isArray(parsed.bookmarks) ? parsed.bookmarks : []
-    };
-  } catch {
-    state = { folders: [], bookmarks: [] };
-  }
-  return state;
-}
-function persistNow() {
-  saveDirty = false;
-  if (saveTimer) {
-    clearTimeout(saveTimer);
-    saveTimer = null;
-  }
-  return fs.promises.mkdir(path.dirname(getBookmarksPath()), { recursive: true }).then(
-    () => fs.promises.writeFile(
-      getBookmarksPath(),
-      JSON.stringify(state, null, 2),
-      "utf-8"
-    )
-  ).catch((err) => console.error("[Vessel] Failed to save bookmarks:", err));
+function load$1() {
+  if (state$1) return state$1;
+  state$1 = loadJsonFile({
+    filePath: getBookmarksPath(),
+    fallback: { folders: [], bookmarks: [] },
+    parse: (raw) => {
+      const parsed = raw;
+      return {
+        folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+        bookmarks: Array.isArray(parsed.bookmarks) ? parsed.bookmarks : []
+      };
+    }
+  });
+  return state$1;
 }
+const persistence$1 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$1,
+  filePath: getBookmarksPath(),
+  getValue: () => state$1,
+  logLabel: "bookmarks"
+});
 function save() {
-  saveDirty = true;
-  if (saveTimer) return;
-  saveTimer = setTimeout(() => {
-    saveTimer = null;
-    if (saveDirty) {
-      void persistNow();
-    }
-  }, SAVE_DEBOUNCE_MS);
+  persistence$1.schedule();
 }
 function emit() {
-  if (!state) return;
-  const snapshot = cloneState(state);
+  if (!state$1) return;
+  const snapshot = cloneState(state$1);
   for (const listener of listeners) {
     listener(snapshot);
   }
 }
 function getState() {
-  return cloneState(load());
+  return cloneState(load$1());
 }
 function subscribe(listener) {
   listeners.add(listener);
@@ -10062,51 +10415,51 @@ function subscribe(listener) {
   };
 }
 function clearAll() {
-  state = { folders: [], bookmarks: [] };
+  state$1 = { folders: [], bookmarks: [] };
   save();
   emit();
 }
 function getBookmark(id) {
-  load();
-  const bookmark = state.bookmarks.find((item) => item.id === id);
+  load$1();
+  const bookmark = state$1.bookmarks.find((item) => item.id === id);
   return bookmark ? { ...bookmark } : null;
 }
 function getBookmarkByUrl(url) {
-  load();
+  load$1();
   const normalized = url.trim();
   if (!normalized) return null;
-  const bookmark = [...state.bookmarks].reverse().find((item) => item.url === normalized);
+  const bookmark = [...state$1.bookmarks].reverse().find((item) => item.url === normalized);
   return bookmark ? { ...bookmark } : null;
 }
 function getBookmarkByUrlInFolder(url, folderId) {
-  load();
+  load$1();
   const normalizedUrl = url.trim();
   if (!normalizedUrl) return null;
-  const targetFolderId = folderId && folderId !== UNSORTED_ID ? state.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
-  const bookmark = [...state.bookmarks].reverse().find(
+  const targetFolderId = folderId && folderId !== UNSORTED_ID ? state$1.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+  const bookmark = [...state$1.bookmarks].reverse().find(
     (item) => item.url === normalizedUrl && item.folderId === targetFolderId
   );
   return bookmark ? { ...bookmark } : null;
 }
 function getFolder(id) {
-  load();
+  load$1();
   if (!id || id === UNSORTED_ID) return null;
-  const folder = state.folders.find((item) => item.id === id);
+  const folder = state$1.folders.find((item) => item.id === id);
   return folder ? { ...folder } : null;
 }
 function findFolderByName(name) {
-  load();
+  load$1();
   const normalized = name.trim().toLowerCase();
   if (!normalized || normalized === "unsorted") return null;
-  const folder = state.folders.find(
+  const folder = state$1.folders.find(
     (item) => item.name.trim().toLowerCase() === normalized
   );
   return folder ? { ...folder } : null;
 }
 function listFolderOverviews() {
-  load();
+  load$1();
   const counts = /* @__PURE__ */ new Map();
-  for (const bookmark of state.bookmarks) {
+  for (const bookmark of state$1.bookmarks) {
     counts.set(bookmark.folderId, (counts.get(bookmark.folderId) ?? 0) + 1);
   }
   return [
@@ -10115,7 +10468,7 @@ function listFolderOverviews() {
       name: "Unsorted",
       count: counts.get(UNSORTED_ID) ?? 0
     },
-    ...state.folders.map((folder) => ({
+    ...state$1.folders.map((folder) => ({
       id: folder.id,
       name: folder.name,
       summary: folder.summary,
@@ -10124,10 +10477,10 @@ function listFolderOverviews() {
   ];
 }
 function searchBookmarks(query) {
-  load();
+  load$1();
   if (!query.trim()) return [];
-  return state.bookmarks.map((bookmark) => {
-    const folder = state.folders.find(
+  return state$1.bookmarks.map((bookmark) => {
+    const folder = state$1.folders.find(
       (item) => item.id === bookmark.folderId
     );
     const { matchedFields, score } = getBookmarkSearchMatch({
@@ -10154,7 +10507,7 @@ function searchBookmarks(query) {
   );
 }
 function createFolderWithSummary(name, summary) {
-  load();
+  load$1();
   const trimmed = name.trim();
   if (!trimmed) throw new Error("Folder name cannot be empty");
   const folder = {
@@ -10163,7 +10516,7 @@ function createFolderWithSummary(name, summary) {
     summary: summary?.trim() || void 0,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state.folders.push(folder);
+  state$1.folders.push(folder);
   save();
   emit();
   return folder;
@@ -10188,13 +10541,13 @@ function saveBookmark(url, title, folderId, note) {
   return result.bookmark;
 }
 function saveBookmarkWithPolicy(url, title, folderId, note, options) {
-  load();
+  load$1();
   const normalizedUrl = url.trim();
   if (!normalizedUrl) {
     throw new Error("Bookmark URL cannot be empty");
   }
   const normalizedTitle = title.trim() || normalizedUrl;
-  const targetId = folderId && folderId !== UNSORTED_ID ? state.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+  const targetId = folderId && folderId !== UNSORTED_ID ? state$1.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   const duplicatePolicy = options?.onDuplicate ?? "ask";
   const existing = getBookmarkByUrlInFolder(normalizedUrl, targetId);
   if (existing) {
@@ -10205,7 +10558,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
       };
     }
     if (duplicatePolicy === "update") {
-      const bookmark2 = state.bookmarks.find((item) => item.id === existing.id);
+      const bookmark2 = state$1.bookmarks.find((item) => item.id === existing.id);
       if (!bookmark2) {
         return {
           status: "conflict",
@@ -10233,7 +10586,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
     folderId: targetId,
     savedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state.bookmarks.push(bookmark);
+  state$1.bookmarks.push(bookmark);
   save();
   emit();
   return {
@@ -10242,10 +10595,10 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
   };
 }
 function removeBookmark(id) {
-  load();
-  const before = state.bookmarks.length;
-  state.bookmarks = state.bookmarks.filter((b) => b.id !== id);
-  if (state.bookmarks.length !== before) {
+  load$1();
+  const before = state$1.bookmarks.length;
+  state$1.bookmarks = state$1.bookmarks.filter((b) => b.id !== id);
+  if (state$1.bookmarks.length !== before) {
     save();
     emit();
     return true;
@@ -10253,8 +10606,8 @@ function removeBookmark(id) {
   return false;
 }
 function updateBookmark(id, updates) {
-  load();
-  const bookmark = state.bookmarks.find((item) => item.id === id);
+  load$1();
+  const bookmark = state$1.bookmarks.find((item) => item.id === id);
   if (!bookmark) return null;
   if (typeof updates.title === "string") {
     const trimmed = updates.title.trim();
@@ -10265,31 +10618,31 @@ function updateBookmark(id, updates) {
     bookmark.note = trimmed || void 0;
   }
   if (typeof updates.folderId === "string") {
-    bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+    bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state$1.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   }
   save();
   emit();
   return { ...bookmark };
 }
 function removeFolder(id, deleteContents = false) {
-  load();
-  const exists = state.folders.some((f) => f.id === id);
+  load$1();
+  const exists = state$1.folders.some((f) => f.id === id);
   if (!exists) return false;
   if (deleteContents) {
-    state.bookmarks = state.bookmarks.filter((b) => b.folderId !== id);
+    state$1.bookmarks = state$1.bookmarks.filter((b) => b.folderId !== id);
   } else {
-    state.bookmarks = state.bookmarks.map(
+    state$1.bookmarks = state$1.bookmarks.map(
       (b) => b.folderId === id ? { ...b, folderId: UNSORTED_ID } : b
     );
   }
-  state.folders = state.folders.filter((f) => f.id !== id);
+  state$1.folders = state$1.folders.filter((f) => f.id !== id);
   save();
   emit();
   return true;
 }
 function renameFolder(id, newName, summary) {
-  load();
-  const folder = state.folders.find((f) => f.id === id);
+  load$1();
+  const folder = state$1.folders.find((f) => f.id === id);
   if (!folder) return null;
   const trimmed = newName.trim();
   if (!trimmed) return null;
@@ -10299,8 +10652,8 @@ function renameFolder(id, newName, summary) {
   emit();
   return { ...folder };
 }
-function flushPersist() {
-  return saveDirty ? persistNow() : Promise.resolve();
+function flushPersist$1() {
+  return persistence$1.flush();
 }
 function normalizeText(text) {
   return text?.trim() ?? "";
@@ -10911,7 +11264,7 @@ function isInvalidTextTargetQuery(rawQuery) {
   return false;
 }
 function resolveTextTargetInDocument(doc, rawQuery, mode) {
-  function normalize(value) {
+  function normalize2(value) {
     return String(value || "").toLowerCase().replace(/\s+/g, " ").trim();
   }
   function text(value) {
@@ -11009,7 +11362,7 @@ function resolveTextTargetInDocument(doc, rawQuery, mode) {
     return [ariaLabel, title, ownText].filter(Boolean).join(" ");
   }
   function scoreText(query2, candidate) {
-    const normalizedCandidate = normalize(candidate);
+    const normalizedCandidate = normalize2(candidate);
     if (!normalizedCandidate) return -1;
     if (normalizedCandidate === query2) return 180;
     if (normalizedCandidate.startsWith(query2)) return 150;
@@ -11025,7 +11378,7 @@ function resolveTextTargetInDocument(doc, rawQuery, mode) {
   function interactiveBonus(el) {
     const htmlEl = el;
     const tag = el.tagName.toLowerCase();
-    const label = normalize(labelFor(el));
+    const label = normalize2(labelFor(el));
     let score = 0;
     if (tag === "button") score += 40;
     if (tag === "a") score += 35;
@@ -11063,7 +11416,7 @@ function resolveTextTargetInDocument(doc, rawQuery, mode) {
     return best;
   }
   if (isInvalidTextTargetQuery(rawQuery)) return null;
-  const query = normalize(rawQuery);
+  const query = normalize2(rawQuery);
   if (!query) return null;
   let bestInteractive = null;
   const interactiveSelector = "a[href], button, [role='button'], input[type='submit'], input[type='button'], input[type='radio'], input[type='checkbox'], select, textarea";
@@ -13554,7 +13907,21 @@ async function setElementValue$1(wc, selector, value) {
       (function() {
         var el = window.__vessel?.resolveShadowSelector?.(${JSON.stringify(selector)});
         if (!el) return "Error[stale-index]: Shadow DOM element not found — call read_page to refresh.";
-        if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return "Error[not-input]: Element is not a text input";
+        if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) return "Error[not-input]: Element is not a fillable input";
+        if (el.disabled || el.getAttribute("aria-disabled") === "true") return "Error[disabled]: Input is disabled";
+        if (el instanceof HTMLSelectElement) {
+          var requested = ${JSON.stringify(value)}.trim().toLowerCase();
+          var option = Array.from(el.options).find(function(item) {
+            return item.value.trim().toLowerCase() === requested ||
+              (item.textContent || "").trim().toLowerCase() === requested;
+          });
+          if (!option) return "Error[option-not-found]: Option not found";
+          el.value = option.value;
+          el.focus();
+          el.dispatchEvent(new Event("input", { bubbles: true }));
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+          return "Selected: " + ((option.textContent || option.value).trim().slice(0, 100));
+        }
         var proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
         var desc = Object.getOwnPropertyDescriptor(proto, "value");
         if (desc && desc.set) { desc.set.call(el, ${JSON.stringify(value)}); } else { el.value = ${JSON.stringify(value)}; }
@@ -13576,13 +13943,29 @@ async function setElementValue$1(wc, selector, value) {
     (function() {
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return 'Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh.';
-      if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
-        return 'Error[not-input]: Element is not a text input';
+      if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
+        return 'Error[not-input]: Element is not a fillable input';
       }
       if (el.disabled || el.getAttribute('aria-disabled') === 'true') {
         return 'Error[disabled]: Input is disabled';
       }
 
+      if (el instanceof HTMLSelectElement) {
+        const requested = ${JSON.stringify(value)}.trim().toLowerCase();
+        const option = Array.from(el.options).find((item) => {
+          const label = (item.textContent || '').trim().toLowerCase();
+          return label === requested || item.value.trim().toLowerCase() === requested;
+        });
+        if (!option) {
+          return 'Error[option-not-found]: Option not found';
+        }
+        el.value = option.value;
+        el.focus();
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        return 'Selected: ' + ((option.textContent || option.value).trim().slice(0, 100));
+      }
+
       const prototype = el instanceof HTMLTextAreaElement
         ? HTMLTextAreaElement.prototype
         : HTMLInputElement.prototype;
@@ -16654,6 +17037,183 @@ Exception: ${result.exceptionDetails}`);
     }
   );
 }
+const VAULT_FILENAME = "vessel-vault.enc";
+const KEY_FILENAME = "vessel-vault.key";
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
+let cachedEntries = null;
+function getVaultDir() {
+  return electron.app.getPath("userData");
+}
+function getVaultPath() {
+  return path$1.join(getVaultDir(), VAULT_FILENAME);
+}
+function getKeyPath() {
+  return path$1.join(getVaultDir(), KEY_FILENAME);
+}
+function assertVaultSecretStorageAvailable() {
+  if (!electron.safeStorage.isEncryptionAvailable()) {
+    throw new Error(
+      "Agent Credential Vault requires OS-backed secret storage. Enable Keychain, DPAPI, or libsecret support and restart Vessel."
+    );
+  }
+}
+function getOrCreateEncryptionKey() {
+  assertVaultSecretStorageAvailable();
+  const keyPath = getKeyPath();
+  if (fs$1.existsSync(keyPath)) {
+    const encryptedKey = fs$1.readFileSync(keyPath);
+    return Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8");
+  }
+  const key = crypto$2.randomBytes(32);
+  fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
+  const encrypted = electron.safeStorage.encryptString(key.toString("utf-8"));
+  fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
+  return key;
+}
+function encrypt(plaintext) {
+  const key = getOrCreateEncryptionKey();
+  const iv = crypto$2.randomBytes(IV_LENGTH);
+  const cipher = crypto$2.createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf-8"),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  return Buffer.concat([iv, authTag, encrypted]);
+}
+function decrypt(data) {
+  const key = getOrCreateEncryptionKey();
+  const iv = data.subarray(0, IV_LENGTH);
+  const authTag = data.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
+  const ciphertext = data.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
+  const decipher = crypto$2.createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(authTag);
+  return decipher.update(ciphertext, void 0, "utf-8") + decipher.final("utf-8");
+}
+function loadVault() {
+  if (cachedEntries) return cachedEntries;
+  const vaultPath = getVaultPath();
+  if (!fs$1.existsSync(vaultPath)) {
+    cachedEntries = [];
+    return cachedEntries;
+  }
+  try {
+    const raw = fs$1.readFileSync(vaultPath);
+    const json = decrypt(raw);
+    cachedEntries = JSON.parse(json);
+    return cachedEntries;
+  } catch (err) {
+    console.error("[Vessel Vault] Failed to load vault:", err);
+    throw new Error(
+      "Could not unlock the Agent Credential Vault. Check that OS secret storage is available and that the stored vault key can be decrypted."
+    );
+  }
+}
+function saveVault(entries) {
+  const json = JSON.stringify(entries, null, 2);
+  const encrypted = encrypt(json);
+  const vaultPath = getVaultPath();
+  fs$1.mkdirSync(path$1.dirname(vaultPath), { recursive: true });
+  fs$1.writeFileSync(vaultPath, encrypted);
+  fs$1.chmodSync(vaultPath, 384);
+  cachedEntries = entries;
+}
+function domainMatches(pattern, hostname) {
+  const p = pattern.toLowerCase().trim();
+  const h = hostname.toLowerCase().trim();
+  if (p === h) return true;
+  if (p.startsWith("*.")) {
+    const suffix = p.slice(2);
+    return h === suffix || h.endsWith("." + suffix);
+  }
+  return false;
+}
+function listEntries() {
+  return loadVault().map(({ password, totpSecret, ...rest }) => rest);
+}
+function findEntriesForDomain(url) {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return [];
+  }
+  return loadVault().filter((e) => domainMatches(e.domainPattern, hostname)).map(({ password, totpSecret, ...rest }) => rest);
+}
+function addEntry(entry) {
+  const entries = loadVault();
+  const newEntry = {
+    ...entry,
+    id: crypto$2.randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    useCount: 0
+  };
+  entries.push(newEntry);
+  saveVault(entries);
+  return newEntry;
+}
+function updateEntry(id, updates) {
+  const entries = loadVault();
+  const idx = entries.findIndex((e) => e.id === id);
+  if (idx === -1) return null;
+  entries[idx] = { ...entries[idx], ...updates };
+  saveVault(entries);
+  return entries[idx];
+}
+function removeEntry(id) {
+  const entries = loadVault();
+  const idx = entries.findIndex((e) => e.id === id);
+  if (idx === -1) return false;
+  entries.splice(idx, 1);
+  saveVault(entries);
+  return true;
+}
+function recordUsage(id) {
+  const entries = loadVault();
+  const entry = entries.find((e) => e.id === id);
+  if (!entry) return;
+  entry.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+  entry.useCount += 1;
+  saveVault(entries);
+}
+function getCredential(id) {
+  const entry = loadVault().find((e) => e.id === id);
+  if (!entry) return null;
+  return { username: entry.username, password: entry.password };
+}
+function getTotpSecret(id) {
+  const entry = loadVault().find((e) => e.id === id);
+  return entry?.totpSecret ?? null;
+}
+function generateTotpCode(secret) {
+  const epoch = Math.floor(Date.now() / 1e3);
+  const counter = Math.floor(epoch / 30);
+  const base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  const cleanSecret = secret.replace(/[\s=-]/g, "").toUpperCase();
+  let bits = "";
+  for (const ch of cleanSecret) {
+    const val = base32Chars.indexOf(ch);
+    if (val === -1) continue;
+    bits += val.toString(2).padStart(5, "0");
+  }
+  const keyBytes = Buffer.alloc(Math.floor(bits.length / 8));
+  for (let i = 0; i < keyBytes.length; i++) {
+    keyBytes[i] = parseInt(bits.slice(i * 8, i * 8 + 8), 2);
+  }
+  const counterBuf = Buffer.alloc(8);
+  counterBuf.writeUInt32BE(Math.floor(counter / 4294967296), 0);
+  counterBuf.writeUInt32BE(counter & 4294967295, 4);
+  const hmac = crypto$2.createHmac("sha1", keyBytes).update(counterBuf).digest();
+  const offset = hmac[hmac.length - 1] & 15;
+  const code = (hmac[offset] & 127) << 24 | (hmac[offset + 1] & 255) << 16 | (hmac[offset + 2] & 255) << 8 | hmac[offset + 3] & 255;
+  return (code % 1e6).toString().padStart(6, "0");
+}
 const sessionTrustedDomains = /* @__PURE__ */ new Set();
 async function requestConsent(request) {
   const domain = request.domain.toLowerCase();
@@ -16689,6 +17249,31 @@ async function requestConsent(request) {
   }
   return { approved: true, trustForSession };
 }
+const AUDIT_FILENAME = "vessel-vault-audit.jsonl";
+const MAX_ENTRIES = 1e3;
+function getAuditPath() {
+  return path$1.join(electron.app.getPath("userData"), AUDIT_FILENAME);
+}
+function appendAuditEntry(entry) {
+  try {
+    const auditPath = getAuditPath();
+    fs$1.mkdirSync(path$1.dirname(auditPath), { recursive: true });
+    fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n");
+  } catch (err) {
+    console.error("[Vessel Vault] Failed to write audit log:", err);
+  }
+}
+function readAuditLog(limit = 100) {
+  try {
+    const auditPath = getAuditPath();
+    if (!fs$1.existsSync(auditPath)) return [];
+    const lines = fs$1.readFileSync(auditPath, "utf-8").split("\n").filter((l) => l.trim());
+    return lines.slice(-Math.min(limit, MAX_ENTRIES)).map((line) => JSON.parse(line)).reverse();
+  } catch (err) {
+    console.error("[Vessel Vault] Failed to read audit log:", err);
+    return [];
+  }
+}
 let httpServer = null;
 let mcpAuthToken = null;
 const MCP_AUTH_FILENAME = "mcp-auth.json";
@@ -19291,7 +19876,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
             color
           );
           if (persist && !durationMs && !result.startsWith("Error") && !result.includes("not found")) {
-            const url = normalizeUrl(wc.getURL());
+            const url = normalizeUrl$1(wc.getURL());
             addHighlight(
               url,
               resolvedSelector ?? void 0,
@@ -19322,7 +19907,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
         {},
         async () => {
           const wc = tab.view.webContents;
-          const url = normalizeUrl(wc.getURL());
+          const url = normalizeUrl$1(wc.getURL());
           clearHighlightsForUrl(url);
           return clearHighlights(wc);
         }
@@ -19343,7 +19928,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
     async ({ url }) => {
       const state2 = getState$2();
       const activeTab = tabManager.getActiveTab();
-      const activeUrl = activeTab ? normalizeUrl(activeTab.view.webContents.getURL()) : null;
+      const activeUrl = activeTab ? normalizeUrl$1(activeTab.view.webContents.getURL()) : null;
       const activeSavedHighlights = activeUrl ? state2.highlights.filter((highlight) => highlight.url === activeUrl) : [];
       const liveSnapshot = activeTab && activeUrl ? await captureLiveHighlightSnapshot(
         activeTab.view.webContents,
@@ -19354,9 +19939,9 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
       );
       if (url) {
         const filtered = state2.highlights.filter(
-          (h) => h.url === normalizeUrl(url)
+          (h) => h.url === normalizeUrl$1(url)
         );
-        const normalizedUrl = normalizeUrl(url);
+        const normalizedUrl = normalizeUrl$1(url);
         const sections2 = [];
         if (activeUrl && activeUrl === normalizedUrl) {
           if (liveSnapshot.activeSelection) {
@@ -19437,7 +20022,7 @@ ${JSON.stringify(otherHighlights, null, 2)}`
       }
       const remaining = getHighlightsForUrl(removed.url);
       for (const tabState of tabManager.getAllStates()) {
-        if (normalizeUrl(tabState.url) !== removed.url) {
+        if (normalizeUrl$1(tabState.url) !== removed.url) {
           continue;
         }
         const tab = tabManager.getTab(tabState.id);
@@ -21694,16 +22279,491 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     return true;
   });
 }
-let activeChatProvider = null;
 function assertString(value, name) {
   if (typeof value !== "string") throw new Error(`${name} must be a string`);
 }
 function assertOptionalString(value, name) {
-  if (value !== void 0 && typeof value !== "string") throw new Error(`${name} must be a string`);
+  if (value !== void 0 && typeof value !== "string") {
+    throw new Error(`${name} must be a string`);
+  }
 }
 function assertNumber(value, name) {
-  if (typeof value !== "number" || Number.isNaN(value)) throw new Error(`${name} must be a number`);
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new Error(`${name} must be a number`);
+  }
+}
+const SAVE_DEBOUNCE_MS = 250;
+const PROFILE_FIELDS = [
+  "label",
+  "firstName",
+  "lastName",
+  "email",
+  "phone",
+  "organization",
+  "addressLine1",
+  "addressLine2",
+  "city",
+  "state",
+  "postalCode",
+  "country"
+];
+let state = null;
+function getFilePath() {
+  return path.join(electron.app.getPath("userData"), "vessel-autofill.json");
+}
+function getDefaultState() {
+  return { profiles: [] };
+}
+function normalizeStoredProfile(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.id !== "string" || typeof raw.createdAt !== "string" || typeof raw.updatedAt !== "string") {
+    return null;
+  }
+  const profile = {
+    id: raw.id,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+  for (const field of PROFILE_FIELDS) {
+    if (typeof raw[field] !== "string") return null;
+    profile[field] = raw[field];
+  }
+  return profile;
+}
+function load() {
+  if (state) return state;
+  state = loadJsonFile({
+    filePath: getFilePath(),
+    fallback: getDefaultState(),
+    secure: true,
+    parse: (raw) => {
+      const parsed = raw;
+      return {
+        profiles: Array.isArray(parsed.profiles) ? parsed.profiles.map(normalizeStoredProfile).filter((profile) => profile !== null) : []
+      };
+    }
+  });
+  return state;
+}
+const persistence = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS,
+  filePath: getFilePath(),
+  getValue: () => state,
+  logLabel: "autofill",
+  secure: true
+});
+function listProfiles() {
+  return load().profiles;
+}
+function getProfile(id) {
+  return load().profiles.find((p) => p.id === id);
+}
+function addProfile(input) {
+  const s = load();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const profile = {
+    ...input,
+    id: crypto$1.randomUUID(),
+    createdAt: now,
+    updatedAt: now
+  };
+  s.profiles.push(profile);
+  persistence.schedule();
+  return profile;
+}
+function updateProfile(id, updates) {
+  const s = load();
+  const idx = s.profiles.findIndex((p) => p.id === id);
+  if (idx === -1) return null;
+  s.profiles[idx] = {
+    ...s.profiles[idx],
+    ...updates,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  persistence.schedule();
+  return s.profiles[idx];
+}
+function deleteProfile(id) {
+  const s = load();
+  const len = s.profiles.length;
+  s.profiles = s.profiles.filter((p) => p.id !== id);
+  if (s.profiles.length === len) return false;
+  persistence.schedule();
+  return true;
+}
+function flushPersist() {
+  return persistence.flush();
+}
+const AUTOCOMPLETE_MAP = {
+  "given-name": "firstName",
+  "family-name": "lastName",
+  "surname": "lastName",
+  "email": "email",
+  "tel": "phone",
+  "tel-national": "phone",
+  "phone": "phone",
+  "organization": "organization",
+  "company": "organization",
+  "street-address": "addressLine1",
+  "address-line1": "addressLine1",
+  "address-line2": "addressLine2",
+  "address-level1": "state",
+  "address-level2": "city",
+  "state": "state",
+  "province": "state",
+  "city": "city",
+  "postal-code": "postalCode",
+  "zip": "postalCode",
+  "zip-code": "postalCode",
+  "country": "country",
+  "country-name": "country",
+  "country-code": "country"
+};
+const INPUT_TYPE_MAP = {
+  email: "email",
+  tel: "phone"
+};
+const NAME_MAP = {
+  firstname: "firstName",
+  first_name: "firstName",
+  "first-name": "firstName",
+  fname: "firstName",
+  givenname: "firstName",
+  lastname: "lastName",
+  last_name: "lastName",
+  "last-name": "lastName",
+  lname: "lastName",
+  surname: "lastName",
+  familyname: "lastName",
+  email: "email",
+  e_mail: "email",
+  "e-mail": "email",
+  emailaddress: "email",
+  mail: "email",
+  phone: "phone",
+  telephone: "phone",
+  tel: "phone",
+  mobile: "phone",
+  cell: "phone",
+  company: "organization",
+  organization: "organization",
+  organisation: "organization",
+  companyname: "organization",
+  address: "addressLine1",
+  street: "addressLine1",
+  "street-address": "addressLine1",
+  address1: "addressLine1",
+  "address-line1": "addressLine1",
+  "addr-line1": "addressLine1",
+  address2: "addressLine2",
+  "address-line2": "addressLine2",
+  "addr-line2": "addressLine2",
+  city: "city",
+  town: "city",
+  locality: "city",
+  state: "state",
+  province: "state",
+  region: "state",
+  zip: "postalCode",
+  zipcode: "postalCode",
+  "zip-code": "postalCode",
+  "postal-code": "postalCode",
+  postalcode: "postalCode",
+  postcode: "postalCode",
+  country: "country"
+};
+const LABEL_MAP = {
+  "first name": "firstName",
+  "given name": "firstName",
+  "last name": "lastName",
+  "surname": "lastName",
+  "family name": "lastName",
+  email: "email",
+  "e-mail": "email",
+  "email address": "email",
+  phone: "phone",
+  telephone: "phone",
+  "phone number": "phone",
+  mobile: "phone",
+  cell: "phone",
+  company: "organization",
+  organization: "organization",
+  organisation: "organization",
+  "company name": "organization",
+  address: "addressLine1",
+  "street address": "addressLine1",
+  "address line 1": "addressLine1",
+  "address line 2": "addressLine2",
+  city: "city",
+  town: "city",
+  state: "state",
+  province: "state",
+  region: "state",
+  zip: "postalCode",
+  "zip code": "postalCode",
+  "postal code": "postalCode",
+  "post code": "postalCode",
+  country: "country"
+};
+function normalize(s) {
+  return s.toLowerCase().trim().replace(/[\s_-]+/g, " ");
+}
+function getFullName(profile) {
+  return [profile.firstName, profile.lastName].filter(Boolean).join(" ").trim();
+}
+function mk(val, confidence, matchedBy, profileKey) {
+  return { value: val, confidence, matchedBy, profileKey };
+}
+function matchField(el, profile) {
+  if (el.type !== "input" && el.type !== "select" && el.type !== "textarea") return null;
+  if (el.disabled) return null;
+  const inputType = (el.inputType || "text").toLowerCase();
+  if (inputType === "hidden" || inputType === "submit" || inputType === "button" || inputType === "file" || inputType === "image") return null;
+  if (inputType === "password" || inputType === "checkbox" || inputType === "radio") return null;
+  if (el.autocomplete) {
+    const key = el.autocomplete.replace(/section-\w+\s+/, "").replace(/^shipping\s+|^billing\s+/, "");
+    if (key === "name" || key === "additional-name") {
+      const fullName = getFullName(profile);
+      if (fullName) return mk(fullName, 100, "autocomplete", "fullName");
+    }
+    const pk = AUTOCOMPLETE_MAP[key];
+    if (pk && profile[pk]) return mk(profile[pk], 100, "autocomplete", pk);
+  }
+  if (INPUT_TYPE_MAP[inputType]) {
+    const pk = INPUT_TYPE_MAP[inputType];
+    if (profile[pk]) return mk(profile[pk], 90, "inputType", pk);
+  }
+  if (el.name) {
+    const norm = normalize(el.name);
+    const pk = NAME_MAP[norm];
+    if (pk && profile[pk]) return mk(profile[pk], 80, "name", pk);
+    for (const [pattern, pk2] of Object.entries(NAME_MAP)) {
+      if (norm.includes(pattern) && profile[pk2]) return mk(profile[pk2], 70, "name", pk2);
+    }
+  }
+  if (el.label) {
+    const norm = normalize(el.label);
+    if (norm === "full name" || norm.includes("full name")) {
+      const fullName = getFullName(profile);
+      if (fullName) return mk(fullName, 75, "label", "fullName");
+    }
+    const pk = LABEL_MAP[norm];
+    if (pk && profile[pk]) return mk(profile[pk], 75, "label", pk);
+    for (const [pattern, pk2] of Object.entries(LABEL_MAP)) {
+      if (norm.includes(pattern) && profile[pk2]) return mk(profile[pk2], 65, "label", pk2);
+    }
+  }
+  if (el.placeholder) {
+    const norm = normalize(el.placeholder);
+    if (norm === "full name" || norm.includes("full name")) {
+      const fullName = getFullName(profile);
+      if (fullName) return mk(fullName, 50, "placeholder", "fullName");
+    }
+    for (const [pattern, pk] of Object.entries(LABEL_MAP)) {
+      if (norm.includes(pattern) && profile[pk]) return mk(profile[pk], 50, "placeholder", pk);
+    }
+  }
+  return null;
+}
+function matchFields(elements, profile) {
+  const assigned = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    const candidate = matchField(el, profile);
+    if (!candidate) continue;
+    const existing = assigned.get(candidate.profileKey);
+    if (existing && existing.confidence >= candidate.confidence) continue;
+    if (el.index == null || !el.selector) continue;
+    assigned.set(candidate.profileKey, {
+      fieldIndex: el.index,
+      selector: el.selector,
+      value: candidate.value,
+      confidence: candidate.confidence,
+      matchedBy: candidate.matchedBy
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const match of assigned.values()) {
+    if (seen.has(match.fieldIndex)) continue;
+    seen.add(match.fieldIndex);
+    results.push(match);
+  }
+  return results;
+}
+const AUTOFILL_PROFILE_FIELDS = [
+  "label",
+  "firstName",
+  "lastName",
+  "email",
+  "phone",
+  "organization",
+  "addressLine1",
+  "addressLine2",
+  "city",
+  "state",
+  "postalCode",
+  "country"
+];
+function sanitizeAutofillProfile(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid profile");
+  const raw = value;
+  const profile = {};
+  for (const field of AUTOFILL_PROFILE_FIELDS) {
+    assertString(raw[field], field);
+    profile[field] = raw[field];
+  }
+  if (!profile.label.trim()) throw new Error("Label is required");
+  return profile;
+}
+function sanitizeAutofillUpdates(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid updates");
+  const raw = value;
+  const updates = {};
+  for (const field of AUTOFILL_PROFILE_FIELDS) {
+    if (!(field in raw)) continue;
+    assertString(raw[field], field);
+    updates[field] = raw[field];
+  }
+  if ("label" in updates && !updates.label?.trim()) {
+    throw new Error("Label is required");
+  }
+  return updates;
+}
+function registerAutofillHandlers(windowState) {
+  electron.ipcMain.handle(Channels.AUTOFILL_LIST, () => {
+    return listProfiles();
+  });
+  electron.ipcMain.handle(
+    Channels.AUTOFILL_ADD,
+    (_, profile) => {
+      return addProfile(sanitizeAutofillProfile(profile));
+    }
+  );
+  electron.ipcMain.handle(Channels.AUTOFILL_UPDATE, (_, id, updates) => {
+    assertString(id, "id");
+    return updateProfile(id, sanitizeAutofillUpdates(updates));
+  });
+  electron.ipcMain.handle(Channels.AUTOFILL_DELETE, (_, id) => {
+    assertString(id, "id");
+    return deleteProfile(id);
+  });
+  electron.ipcMain.handle(Channels.AUTOFILL_FILL, async (_, profileId) => {
+    assertString(profileId, "profileId");
+    const profile = getProfile(profileId);
+    if (!profile) throw new Error("Profile not found");
+    const activeTab = windowState.tabManager.getActiveTab();
+    const wc = activeTab?.view.webContents;
+    if (!wc) throw new Error("No active tab");
+    const content = await extractContent(wc);
+    const elements = content.interactiveElements || [];
+    const matches = matchFields(elements, profile);
+    if (matches.length === 0) {
+      return { filled: 0, skipped: 0, details: [] };
+    }
+    const fields = matches.map((match) => ({
+      index: match.fieldIndex,
+      selector: match.selector,
+      value: match.value
+    }));
+    const results = await fillFormFields(wc, fields);
+    const filled = results.filter(
+      (result) => result.result.startsWith("Typed into:") || result.result.startsWith("Selected:")
+    ).length;
+    return {
+      filled,
+      skipped: results.length - filled,
+      details: results.map((result, index) => ({
+        label: elements.find((element) => element.index === matches[index]?.fieldIndex)?.label || `Field ${index + 1}`,
+        value: matches[index]?.value || "",
+        matchedBy: matches[index]?.matchedBy || "unknown",
+        result: result.result
+      }))
+    };
+  });
+}
+function registerPageDiffHandlers(windowState, sendToRendererViews) {
+  electron.ipcMain.handle(Channels.PAGE_DIFF_GET, () => {
+    const activeTab = windowState.tabManager.getActiveTab();
+    const wc = activeTab?.view.webContents;
+    if (!wc) return null;
+    return getLatestPageDiff(wc.getURL());
+  });
+  electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
+    const wc = event.sender;
+    if (!wc || wc.isDestroyed()) return;
+    notePageMutationActivity(wc, sendToRendererViews);
+  });
+  electron.ipcMain.on(Channels.PAGE_DIFF_DIRTY, (event) => {
+    const wc = event.sender;
+    if (!wc || wc.isDestroyed()) return;
+    schedulePageSnapshotCapture(wc, sendToRendererViews);
+  });
+}
+function registerVaultHandlers() {
+  electron.ipcMain.handle(Channels.VAULT_LIST, () => {
+    return listEntries();
+  });
+  electron.ipcMain.handle(
+    Channels.VAULT_ADD,
+    (_, entry) => {
+      if (!entry || typeof entry !== "object") {
+        throw new Error("Invalid vault entry");
+      }
+      assertString(entry.label, "label");
+      assertString(entry.domainPattern, "domainPattern");
+      assertString(entry.username, "username");
+      assertString(entry.password, "password");
+      if (!entry.label.trim() || !entry.domainPattern.trim() || !entry.username.trim() || !entry.password.trim()) {
+        throw new Error("Label, domain, username, and password are required");
+      }
+      assertOptionalString(entry.totpSecret, "totpSecret");
+      assertOptionalString(entry.notes, "notes");
+      trackVaultAction("credential_added");
+      const created = addEntry(entry);
+      return {
+        id: created.id,
+        label: created.label,
+        domainPattern: created.domainPattern,
+        username: created.username
+      };
+    }
+  );
+  electron.ipcMain.handle(
+    Channels.VAULT_UPDATE,
+    (_, id, updates) => {
+      assertString(id, "id");
+      if (!updates || typeof updates !== "object") {
+        throw new Error("Invalid updates");
+      }
+      return updateEntry(id, updates) !== null;
+    }
+  );
+  electron.ipcMain.handle(Channels.VAULT_REMOVE, (_, id) => {
+    assertString(id, "id");
+    trackVaultAction("credential_removed");
+    return removeEntry(id);
+  });
+  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (_, limit) => {
+    return readAuditLog(limit);
+  });
 }
+function registerWindowControlHandlers(mainWindow) {
+  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, () => {
+    mainWindow.minimize();
+  });
+  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, () => {
+    if (mainWindow.isMaximized()) {
+      mainWindow.unmaximize();
+    } else {
+      mainWindow.maximize();
+    }
+  });
+  electron.ipcMain.handle(Channels.WINDOW_CLOSE, () => {
+    mainWindow.close();
+  });
+}
+let activeChatProvider = null;
 const VALID_APPROVAL_MODES = /* @__PURE__ */ new Set(["auto", "confirm-dangerous", "manual"]);
 function registerIpcHandlers(windowState, runtime2) {
   const { tabManager, chromeView, sidebarView, devtoolsPanelView, mainWindow } = windowState;
@@ -22302,56 +23362,8 @@ function registerIpcHandlers(windowState, runtime2) {
     }
     return result;
   });
-  electron.ipcMain.handle(Channels.VAULT_LIST, () => {
-    return listEntries();
-  });
-  electron.ipcMain.handle(
-    Channels.VAULT_ADD,
-    (_, entry) => {
-      if (!entry || typeof entry !== "object") throw new Error("Invalid vault entry");
-      assertString(entry.label, "label");
-      assertString(entry.domainPattern, "domainPattern");
-      assertString(entry.username, "username");
-      assertString(entry.password, "password");
-      if (!entry.label.trim() || !entry.domainPattern.trim() || !entry.username.trim() || !entry.password.trim()) {
-        throw new Error("Label, domain, username, and password are required");
-      }
-      assertOptionalString(entry.totpSecret, "totpSecret");
-      assertOptionalString(entry.notes, "notes");
-      trackVaultAction("credential_added");
-      const created = addEntry(entry);
-      return { id: created.id, label: created.label, domainPattern: created.domainPattern, username: created.username };
-    }
-  );
-  electron.ipcMain.handle(
-    Channels.VAULT_UPDATE,
-    (_, id, updates) => {
-      assertString(id, "id");
-      if (!updates || typeof updates !== "object") throw new Error("Invalid updates");
-      return updateEntry(id, updates) !== null;
-    }
-  );
-  electron.ipcMain.handle(Channels.VAULT_REMOVE, (_, id) => {
-    assertString(id, "id");
-    trackVaultAction("credential_removed");
-    return removeEntry(id);
-  });
-  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (_, limit) => {
-    return readAuditLog(limit);
-  });
-  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, () => {
-    mainWindow.minimize();
-  });
-  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, () => {
-    if (mainWindow.isMaximized()) {
-      mainWindow.unmaximize();
-    } else {
-      mainWindow.maximize();
-    }
-  });
-  electron.ipcMain.handle(Channels.WINDOW_CLOSE, () => {
-    mainWindow.close();
-  });
+  registerVaultHandlers();
+  registerWindowControlHandlers(mainWindow);
   electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, () => {
     return getInstalledKits();
   });
@@ -22363,6 +23375,8 @@ function registerIpcHandlers(windowState, runtime2) {
     return uninstallKit(id, getScheduledKitIds());
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
+  registerAutofillHandlers(windowState);
+  registerPageDiffHandlers(windowState, sendToRendererViews);
 }
 function makeStep(label, status = "pending") {
   return { label, status };
@@ -23815,10 +24829,12 @@ electron.app.on("window-all-closed", () => {
   stopBackgroundRevalidation();
   void Promise.all([
     runtime?.flushPersist() ?? Promise.resolve(),
-    flushPersist(),
     flushPersist$1(),
+    flushPersist$3(),
+    flushPersist$4(),
+    flushPersist(),
     flushPersist$2(),
-    flushPersist$3()
+    flushPersist$5()
   ]).finally(() => {
     void stopMcpServer().finally(() => {
       electron.app.quit();