@quanta-intellect/vessel-browser 0.1.65 → 0.1.68

package/out/main/index.js

@@ -74,7 +74,7 @@ const defaults = {
     expiresAt: ""
   }
 };
-const SAVE_DEBOUNCE_MS$5 = 150;
+const SAVE_DEBOUNCE_MS$6 = 150;
 const CHAT_PROVIDER_SECRET_FILENAME = "vessel-chat-provider-secret";
 const logger$j = createLogger("Settings");
 const SETTABLE_KEYS = new Set(Object.keys(defaults));
@@ -232,7 +232,7 @@ function saveSettings() {
     if (saveDirty) {
       void persistNow();
     }
-  }, SAVE_DEBOUNCE_MS$5);
+  }, SAVE_DEBOUNCE_MS$6);
 }
 function setSetting(key, value) {
   loadSettings();
@@ -871,7 +871,7 @@ function createDebouncedJsonPersistence({
 }
 let state$4 = null;
 const listeners$2 = /* @__PURE__ */ new Set();
-const SAVE_DEBOUNCE_MS$4 = 250;
+const SAVE_DEBOUNCE_MS$5 = 250;
 function getHighlightsPath() {
   return path.join(electron.app.getPath("userData"), "vessel-highlights.json");
 }
@@ -889,15 +889,15 @@ function load$4() {
   });
   return state$4;
 }
-const persistence$4 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$4,
+const persistence$5 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$5,
   filePath: getHighlightsPath(),
   getValue: () => state$4,
   logLabel: "highlights",
   resetOnSchedule: true
 });
 function save$2() {
-  persistence$4.schedule();
+  persistence$5.schedule();
 }
 function emit$2() {
   if (!state$4) return;
@@ -979,7 +979,7 @@ function clearHighlightsForUrl(url) {
   return removed;
 }
 function flushPersist$4() {
-  return persistence$4.flush();
+  return persistence$5.flush();
 }
 const SKIP_TAGS_JS = "var SKIP_TAGS = {SCRIPT:1,STYLE:1,NOSCRIPT:1,TEMPLATE:1,IFRAME:1,SVG:1};";
 const CONTENT_ROOTS_JS = `
@@ -1551,7 +1551,7 @@ function persistHighlight(url, text) {
   return { success: true, text: capped, id: highlight.id };
 }
 const MAX_HISTORY_ENTRIES = 5e3;
-const SAVE_DEBOUNCE_MS$3 = 250;
+const SAVE_DEBOUNCE_MS$4 = 250;
 let state$3 = null;
 const listeners$1 = /* @__PURE__ */ new Set();
 function getHistoryPath() {
@@ -1571,14 +1571,14 @@ function load$3() {
   });
   return state$3;
 }
-const persistence$3 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$3,
+const persistence$4 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$4,
   filePath: getHistoryPath(),
   getValue: () => state$3,
   logLabel: "history"
 });
 function save$1() {
-  persistence$3.schedule();
+  persistence$4.schedule();
 }
 function emit$1() {
   if (!state$3) return;
@@ -1635,7 +1635,7 @@ function clearAll$1() {
   emit$1();
 }
 function flushPersist$3() {
-  return persistence$3.flush();
+  return persistence$4.flush();
 }
 const MAX_CONSOLE_ENTRIES = 500;
 const MAX_NETWORK_ENTRIES = 200;
@@ -2684,6 +2684,8 @@ const Channels = {
   AGENT_APPROVAL_RESOLVE: "agent:approval-resolve",
   AGENT_CHECKPOINT_CREATE: "agent:checkpoint-create",
   AGENT_CHECKPOINT_RESTORE: "agent:checkpoint-restore",
+  AGENT_CHECKPOINT_UPDATE_NOTE: "agent:checkpoint-update-note",
+  AGENT_UNDO_LAST_ACTION: "agent:undo-last-action",
   AGENT_SESSION_CAPTURE: "agent:session-capture",
   AGENT_SESSION_RESTORE: "agent:session-restore",
   // Content
@@ -2691,6 +2693,7 @@ const Channels = {
   READER_MODE_TOGGLE: "reader:toggle",
   // UI state
   SIDEBAR_TOGGLE: "ui:sidebar-toggle",
+  SIDEBAR_NAVIGATE: "ui:sidebar-navigate",
   SIDEBAR_RESIZE: "ui:sidebar-resize",
   SIDEBAR_RESIZE_START: "ui:sidebar-resize-start",
   SIDEBAR_RESIZE_COMMIT: "ui:sidebar-resize-commit",
@@ -2707,6 +2710,7 @@ const Channels = {
   BOOKMARKS_GET: "bookmarks:get",
   BOOKMARKS_UPDATE: "bookmarks:update",
   BOOKMARK_SAVE: "bookmarks:save",
+  BOOKMARK_UPDATE: "bookmarks:update-item",
   BOOKMARK_REMOVE: "bookmarks:remove",
   BOOKMARK_ADD_CONTEXT_TO_CHAT: "bookmarks:add-context-to-chat",
   FOLDER_CREATE: "bookmarks:folder-create",
@@ -2786,6 +2790,7 @@ const Channels = {
   PAGE_DIFF_ACTIVITY: "page:diff-activity",
   PAGE_CHANGED: "page:changed",
   PAGE_DIFF_GET: "page:diff-get",
+  PAGE_DIFF_HISTORY: "page:diff-history",
   PAGE_DIFF_DIRTY: "page:diff-dirty"
 };
 const MAX_DETAIL_ITEMS = 3;
@@ -3101,7 +3106,7 @@ function isTrackablePageUrl(rawUrl) {
     return false;
   }
 }
-const SAVE_DEBOUNCE_MS$2 = 500;
+const SAVE_DEBOUNCE_MS$3 = 500;
 const MAX_TEXT_LENGTH = 8e3;
 let snapshots = null;
 function getFilePath$1() {
@@ -3139,8 +3144,8 @@ function load$2() {
   });
   return snapshots;
 }
-const persistence$2 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$2,
+const persistence$3 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$3,
   filePath: getFilePath$1(),
   getValue: () => snapshots,
   logLabel: "page snapshots",
@@ -3168,11 +3173,11 @@ function saveSnapshot(rawUrl, title, textContent, headings) {
   };
   s.delete(key);
   s.set(key, snapshot);
-  persistence$2.schedule();
+  persistence$3.schedule();
   return snapshot;
 }
 function flushPersist$2() {
-  return persistence$2.flush();
+  return persistence$3.flush();
 }
 const SEARCH_ENGINE_HOSTS = [
   "google.",
@@ -4419,6 +4424,13 @@ function inferPageSchema(page) {
     confidence
   };
 }
+const DEFAULT_PAGE_SCRIPT_TIMEOUT_MS$1 = 1500;
+const EXTRACT_SCRIPT_TIMEOUT_MS = 3e3;
+const EXTRACT_TIMEOUT_BASE_MS = 12e3;
+const EXTRACT_TIMEOUT_MAX_MS = 2e4;
+const MUTATION_CAPTURE_INTERVAL_MS = 5e3;
+const MUTATION_SETTLE_AFTER_MS = 1500;
+const AGENT_STREAM_IDLE_TIMEOUT_MS = 3e4;
 const logger$e = createLogger("Extractor");
 const EMPTY_PAGE_CONTENT = {
   title: "",
@@ -5136,8 +5148,7 @@ const DIRECT_EXTRACTION_SCRIPT = String.raw`
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const EXECUTE_SCRIPT_TIMEOUT_MS = 3e3;
-async function waitForDomReady(webContents, timeoutMs = 1500) {
+async function waitForDomReady(webContents, timeoutMs = DEFAULT_PAGE_SCRIPT_TIMEOUT_MS$1) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const readyState = await executeScript(
@@ -5163,7 +5174,10 @@ async function executeScript(webContents, script) {
     return await Promise.race([
       webContents.executeJavaScript(script),
       new Promise((resolve) => {
-        timer = setTimeout(() => resolve(null), EXECUTE_SCRIPT_TIMEOUT_MS);
+        timer = setTimeout(
+          () => resolve(null),
+          EXTRACT_SCRIPT_TIMEOUT_MS
+        );
       })
     ]);
   } catch (err) {
@@ -5260,8 +5274,6 @@ function mergePageContent(candidates, webContents) {
     url: mergedBase.url || webContents.getURL() || ""
   };
 }
-const EXTRACT_TIMEOUT_BASE_MS = 12e3;
-const EXTRACT_TIMEOUT_MAX_MS = 2e4;
 async function estimateExtractionTimeout(webContents) {
   try {
     const elementCount = await executeScript(
@@ -5348,8 +5360,32 @@ function normalizePageContent(value) {
     pageSchema: page.pageSchema
   };
 }
+function normalizePageDiffHistoryItem(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.detectedAt !== "string" || typeof raw.summary !== "string") {
+    return null;
+  }
+  return {
+    detectedAt: raw.detectedAt,
+    summary: raw.summary
+  };
+}
+function prunePageDiffHistory(items, options) {
+  const cutoff = (options.now ?? Date.now()) - options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  return items.filter((item) => {
+    const detectedAt = Date.parse(item.detectedAt);
+    return Number.isFinite(detectedAt) && detectedAt >= cutoff;
+  }).sort(
+    (left, right) => Date.parse(left.detectedAt) - Date.parse(right.detectedAt)
+  ).slice(-options.maxItems);
+}
+function appendPageDiffHistoryItem(items, next, options) {
+  return prunePageDiffHistory([...items, next], options);
+}
 const latestPageDiffs = /* @__PURE__ */ new Map();
 const recentPageDiffBursts = /* @__PURE__ */ new Map();
+let historyLoaded = false;
 const pendingPageSnapshotTimers = /* @__PURE__ */ new Map();
 const pendingPageSnapshotDueAt = /* @__PURE__ */ new Map();
 const lastMutationSnapshotAt = /* @__PURE__ */ new Map();
@@ -5370,12 +5406,81 @@ function attachDestroyCleanup(wc) {
     cleanupTimersForWcId(wc.id);
   });
 }
-const MIN_MUTATION_CAPTURE_INTERVAL_MS = 5e3;
-const SETTLE_AFTER_ACTIVITY_MS = 1500;
+const MAX_PERSISTED_DIFF_BURSTS = 50;
+const MAX_HISTORY_DAYS = 30;
+const SAVE_DEBOUNCE_MS$2 = 500;
+function getHistoryFilePath() {
+  return path.join(electron.app.getPath("userData"), "vessel-page-diff-history.json");
+}
+function loadHistory() {
+  if (historyLoaded) return recentPageDiffBursts;
+  historyLoaded = true;
+  const loaded = loadJsonFile({
+    filePath: getHistoryFilePath(),
+    fallback: /* @__PURE__ */ new Map(),
+    secure: true,
+    parse: (raw) => {
+      const next = /* @__PURE__ */ new Map();
+      if (!Array.isArray(raw)) return next;
+      for (const entry of raw) {
+        if (!entry || typeof entry !== "object") continue;
+        const record = entry;
+        if (typeof record.url !== "string" || !Array.isArray(record.bursts)) {
+          continue;
+        }
+        next.set(
+          record.url,
+          prunePageDiffHistory(
+            record.bursts.map((item) => normalizePageDiffHistoryItem(item)).filter((item) => item !== null),
+            {
+              maxAgeDays: MAX_HISTORY_DAYS,
+              maxItems: MAX_PERSISTED_DIFF_BURSTS
+            }
+          )
+        );
+      }
+      return next;
+    }
+  });
+  for (const [key, bursts] of loaded.entries()) {
+    recentPageDiffBursts.set(key, bursts);
+  }
+  return recentPageDiffBursts;
+}
+const persistence$2 = createDebouncedJsonPersistence({
+  debounceMs: SAVE_DEBOUNCE_MS$2,
+  filePath: getHistoryFilePath(),
+  getValue: () => recentPageDiffBursts,
+  logLabel: "page diff history",
+  secure: true,
+  serialize: (value) => Array.from(value.entries()).map(([url, bursts]) => ({
+    url,
+    bursts
+  }))
+});
 function getLatestPageDiff(rawUrl) {
   if (!shouldTrackSnapshotUrl(rawUrl)) return null;
   return latestPageDiffs.get(normalizeUrl(rawUrl)) ?? null;
 }
+function getPageDiffBursts(rawUrl) {
+  if (!shouldTrackSnapshotUrl(rawUrl)) return [];
+  const key = normalizeUrl(rawUrl);
+  const history = loadHistory();
+  const bursts = prunePageDiffHistory(history.get(key) ?? [], {
+    maxAgeDays: MAX_HISTORY_DAYS,
+    maxItems: MAX_PERSISTED_DIFF_BURSTS
+  });
+  const current = history.get(key) ?? [];
+  if (current.length !== bursts.length) {
+    if (bursts.length > 0) {
+      history.set(key, bursts);
+    } else {
+      history.delete(key);
+    }
+    persistence$2.schedule();
+  }
+  return bursts.slice().reverse();
+}
 function summarizeDiffBurst(diff) {
   const items = diff.changes.slice(0, 2).map((change) => `${change.section}: ${change.summary}`);
   return items.join(" | ");
@@ -5386,16 +5491,21 @@ function enrichWithBurstHistory(key, diff) {
     detectedAt,
     summary: summarizeDiffBurst(diff)
   };
-  const bursts = [...recentPageDiffBursts.get(key) || [], nextBurst].slice(
-    -5
-  );
-  recentPageDiffBursts.set(key, bursts);
+  const history = loadHistory();
+  const bursts = appendPageDiffHistoryItem(history.get(key) ?? [], nextBurst, {
+    maxAgeDays: MAX_HISTORY_DAYS,
+    maxItems: MAX_PERSISTED_DIFF_BURSTS,
+    now: Date.parse(detectedAt)
+  });
+  history.set(key, bursts);
+  persistence$2.schedule();
+  const recentBursts = bursts.slice(-5);
   return {
     ...diff,
     burstCount: bursts.length,
     firstDetectedAt: bursts[0]?.detectedAt,
     lastDetectedAt: bursts[bursts.length - 1]?.detectedAt,
-    recentBursts: bursts
+    recentBursts: recentBursts.slice().reverse()
   };
 }
 async function capturePageSnapshot(url, wc, sendToRendererViews) {
@@ -5416,11 +5526,9 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
         sendToRendererViews(Channels.PAGE_CHANGED, enrichedDiff);
       } else {
         latestPageDiffs.delete(key);
-        recentPageDiffBursts.delete(key);
       }
     } else {
       latestPageDiffs.delete(key);
-      recentPageDiffBursts.delete(key);
     }
     saveSnapshot(url, title, textContent, headings);
   } catch {
@@ -5429,8 +5537,8 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
 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;
+  const earliestAllowedAt = lastCaptureAt + MUTATION_CAPTURE_INTERVAL_MS;
+  const stableAfterActivityAt = lastActivityAt ? lastActivityAt + MUTATION_SETTLE_AFTER_MS : 0;
   return Math.max(now + delayMs, earliestAllowedAt, stableAfterActivityAt);
 }
 function scheduleTimerAt(wc, sendToRendererViews, dueAt) {
@@ -6135,7 +6243,7 @@ class AnthropicProvider {
         let textContent = "";
         const toolUseBlocks = [];
         let currentToolUse = null;
-        const STREAM_IDLE_TIMEOUT_MS = 3e4;
+        const STREAM_IDLE_TIMEOUT_MS = AGENT_STREAM_IDLE_TIMEOUT_MS;
         let idleTimer = null;
         const resetIdleTimer = () => {
           if (idleTimer) clearTimeout(idleTimer);
@@ -6991,9 +7099,16 @@ class OpenAICompatProvider {
   constructor(config) {
     const meta = PROVIDERS[config.id];
     const baseURL = config.baseUrl || meta?.defaultBaseUrl || "https://api.openai.com/v1";
+    const isOpenRouter = baseURL.includes("openrouter.ai");
     this.client = new OpenAI({
       apiKey: config.apiKey || "ollama",
-      baseURL
+      baseURL,
+      ...isOpenRouter && {
+        defaultHeaders: {
+          "HTTP-Referer": "https://github.com/unmodeled/vessel-browser",
+          "X-Title": "Vessel"
+        }
+      }
     });
     this.providerId = config.id;
     this.model = config.model || meta?.defaultModel || "gpt-4o";
@@ -10068,6 +10183,13 @@ const TOOL_DEFINITIONS = [
     tier: 2,
     hiddenByDefault: true
   },
+  // --- Undo ---
+  {
+    name: "undo_last_action",
+    title: "Undo Last Action",
+    description: "Undo the most recent agent action by restoring the browser to its state before that action ran. Works for click, type, submit, navigate, and similar mutating actions. Returns the name of the undone action, or an error if nothing can be undone.",
+    tier: 1
+  },
   // --- Speedee System: Suggestion Engine ---
   {
     name: "suggest",
@@ -10592,6 +10714,60 @@ function getBookmarkSearchMatch(args) {
   }
   return { matchedFields, score };
 }
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeKeyFields(value) {
+  if (!Array.isArray(value)) return void 0;
+  const normalized = value.filter((field) => typeof field === "string").map((field) => field.trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeAgentHints(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const normalized = Object.fromEntries(
+    Object.entries(value).map(([key, hint]) => [key.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
+  );
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeBookmarkMetadata(input) {
+  const normalized = {};
+  const intent = normalizeOptionalString(input.intent);
+  const expectedContent = normalizeOptionalString(input.expectedContent);
+  const keyFields = normalizeKeyFields(input.keyFields);
+  const agentHints = normalizeAgentHints(input.agentHints);
+  if (intent !== void 0) normalized.intent = intent;
+  if (expectedContent !== void 0) {
+    normalized.expectedContent = expectedContent;
+  }
+  if (keyFields !== void 0) normalized.keyFields = keyFields;
+  if (agentHints !== void 0) normalized.agentHints = agentHints;
+  return normalized;
+}
+function normalizeBookmarkMetadataUpdate(input) {
+  const normalized = {};
+  if (hasOwn(input, "intent")) {
+    normalized.intent = normalizeOptionalString(input.intent);
+  }
+  if (hasOwn(input, "expectedContent")) {
+    normalized.expectedContent = normalizeOptionalString(
+      input.expectedContent
+    );
+  }
+  if (hasOwn(input, "keyFields")) {
+    normalized.keyFields = normalizeKeyFields(input.keyFields);
+  }
+  if (hasOwn(input, "agentHints")) {
+    normalized.agentHints = normalizeAgentHints(input.agentHints);
+  }
+  return normalized;
+}
 const UNSORTED_ID = "unsorted";
 const ARCHIVE_FOLDER_NAME = "Archive";
 const SAVE_DEBOUNCE_MS$1 = 250;
@@ -10630,6 +10806,13 @@ const persistence$1 = createDebouncedJsonPersistence({
 function save() {
   persistence$1.schedule();
 }
+function assignDefinedBookmarkFields(bookmark, fields) {
+  if (!fields) return;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    Object.assign(bookmark, { [key]: value });
+  }
+}
 function emit() {
   if (!state$1) return;
   const snapshot = cloneState(state$1);
@@ -10803,9 +10986,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
       if (note !== void 0) {
         bookmark2.note = note.trim() || void 0;
       }
-      if (options?.extra) {
-        Object.assign(bookmark2, options.extra);
-      }
+      assignDefinedBookmarkFields(bookmark2, options?.extra);
       bookmark2.savedAt = (/* @__PURE__ */ new Date()).toISOString();
       save();
       emit();
@@ -10847,6 +11028,12 @@ function updateBookmark(id, updates) {
   load$1();
   const bookmark = state$1.bookmarks.find((item) => item.id === id);
   if (!bookmark) return null;
+  const metadataUpdates = normalizeBookmarkMetadataUpdate({
+    intent: updates.intent,
+    expectedContent: updates.expectedContent,
+    keyFields: updates.keyFields,
+    agentHints: updates.agentHints
+  });
   if (typeof updates.title === "string") {
     const trimmed = updates.title.trim();
     bookmark.title = trimmed || bookmark.url;
@@ -10858,20 +11045,20 @@ function updateBookmark(id, updates) {
   if (typeof updates.folderId === "string") {
     bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state$1.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   }
-  if (typeof updates.intent === "string") {
-    bookmark.intent = updates.intent.trim() || void 0;
+  if ("intent" in metadataUpdates) {
+    bookmark.intent = metadataUpdates.intent;
   }
-  if (typeof updates.expectedContent === "string") {
-    bookmark.expectedContent = updates.expectedContent.trim() || void 0;
+  if ("expectedContent" in metadataUpdates) {
+    bookmark.expectedContent = metadataUpdates.expectedContent;
   }
-  if (updates.keyFields !== void 0) {
-    bookmark.keyFields = updates.keyFields;
+  if ("keyFields" in metadataUpdates) {
+    bookmark.keyFields = metadataUpdates.keyFields;
   }
   if (updates.pageSchema !== void 0) {
     bookmark.pageSchema = updates.pageSchema;
   }
-  if (updates.agentHints !== void 0) {
-    bookmark.agentHints = updates.agentHints;
+  if ("agentHints" in metadataUpdates) {
+    bookmark.agentHints = metadataUpdates.agentHints;
   }
   save();
   emit();
@@ -11231,9 +11418,13 @@ function formatDeadLinkMessage(label, result) {
   return `Skipped stale link "${label}" because ${destination} returned ${status}. Try a different link or URL instead.`;
 }
 const logger$b = createLogger("Screenshot");
+const SCREENSHOT_RETRY_COUNT = 3;
+const SCREENSHOT_RETRY_BASE_DELAY_MS = 120;
 async function captureScreenshot(wc) {
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
+  for (let attempt = 0; attempt < SCREENSHOT_RETRY_COUNT; attempt += 1) {
+    await new Promise(
+      (resolve) => setTimeout(resolve, SCREENSHOT_RETRY_BASE_DELAY_MS * (attempt + 1))
+    );
     try {
       const image = await wc.capturePage();
       if (!image.isEmpty()) {
@@ -11862,33 +12053,6 @@ function formatCompactToolResult(name, result) {
       return limitText(result, 18, 1400);
   }
 }
-function normalizeOptionalString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed || void 0;
-}
-function normalizeKeyFields(value) {
-  if (!Array.isArray(value)) return void 0;
-  const normalized = value.filter((field) => typeof field === "string").map((field) => field.trim()).filter(Boolean);
-  return normalized.length > 0 ? normalized : void 0;
-}
-function normalizeAgentHints(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const normalized = Object.fromEntries(
-    Object.entries(value).map(([key, hint]) => [key.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
-  );
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function normalizeBookmarkMetadata(input) {
-  return {
-    intent: normalizeOptionalString(input.intent),
-    expectedContent: normalizeOptionalString(input.expectedContent),
-    keyFields: normalizeKeyFields(input.keyFields),
-    agentHints: normalizeAgentHints(input.agentHints)
-  };
-}
 const HUGGING_FACE_HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "www.huggingface.co"]);
 const HUGGING_FACE_MODEL_TASKS = [
   {
@@ -16040,6 +16204,11 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
           ctx.runtime.clearFlow();
           return "Workflow ended.";
         }
+        case "undo_last_action": {
+          const undone = ctx.runtime.undoLastAction();
+          if (!undone) return "Nothing to undo. No undo snapshots available.";
+          return `Undid action: ${undone}. Browser restored to state before that action.`;
+        }
         case "suggest": {
           if (!wc) return "No active tab. Use navigate to open a page.";
           let page;
@@ -20050,6 +20219,23 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
       return asTextResponse("Workflow ended.");
     }
   );
+  server.registerTool(
+    "undo_last_action",
+    {
+      title: "Undo Last Action",
+      description: "Undo the most recent agent action by restoring the browser to its state before that action ran. Works for click, type, submit, navigate, and similar mutating actions."
+    },
+    async () => {
+      const undone = runtime2.undoLastAction();
+      if (!undone)
+        return asTextResponse(
+          "Nothing to undo. No undo snapshots available."
+        );
+      return asTextResponse(
+        `Undid action: ${undone}. Browser restored to state before that action.`
+      );
+    }
+  );
   server.registerTool(
     "suggest",
     {
@@ -21923,6 +22109,19 @@ function registerPageDiffHandlers(windowState, sendToRendererViews) {
     if (!wc) return null;
     return getLatestPageDiff(wc.getURL());
   });
+  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, () => {
+    try {
+      if (!isPremiumActiveState(getPremiumState())) {
+        return { error: "Premium required" };
+      }
+      const activeTab = windowState.tabManager.getActiveTab();
+      const wc = activeTab?.view.webContents;
+      if (!wc) return [];
+      return getPageDiffBursts(wc.getURL());
+    } catch {
+      return [];
+    }
+  });
   electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
@@ -22283,6 +22482,20 @@ function registerIpcHandlers(windowState, runtime2) {
       width: windowState.uiState.sidebarWidth
     };
   });
+  electron.ipcMain.handle(Channels.SIDEBAR_NAVIGATE, (_, tab) => {
+    assertString(tab, "tab");
+    if (!windowState.uiState.sidebarOpen) {
+      windowState.uiState.sidebarOpen = true;
+      layoutViews(windowState);
+    }
+    if (!sidebarView.webContents.isDestroyed()) {
+      sidebarView.webContents.send(Channels.SIDEBAR_NAVIGATE, tab);
+    }
+    return {
+      open: windowState.uiState.sidebarOpen,
+      width: windowState.uiState.sidebarWidth
+    };
+  });
   electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_START, () => {
     sidebarResizeActive = true;
     clearSidebarResizeRecoveryTimer();
@@ -22381,6 +22594,14 @@ function registerIpcHandlers(windowState, runtime2) {
     Channels.AGENT_CHECKPOINT_RESTORE,
     (_, checkpointId) => runtime2.restoreCheckpoint(checkpointId)
   );
+  electron.ipcMain.handle(
+    Channels.AGENT_CHECKPOINT_UPDATE_NOTE,
+    (_, checkpointId, note) => runtime2.updateCheckpointNote(checkpointId, note || "")
+  );
+  electron.ipcMain.handle(
+    Channels.AGENT_UNDO_LAST_ACTION,
+    () => runtime2.undoLastAction()
+  );
   electron.ipcMain.handle(
     Channels.AGENT_SESSION_CAPTURE,
     (_, note) => runtime2.captureSession(note)
@@ -22420,6 +22641,13 @@ function registerIpcHandlers(windowState, runtime2) {
       return result.bookmark;
     }
   );
+  electron.ipcMain.handle(
+    Channels.BOOKMARK_UPDATE,
+    (_, id, updates) => {
+      trackBookmarkAction("save");
+      return updateBookmark(id, updates);
+    }
+  );
   electron.ipcMain.handle(Channels.BOOKMARK_REMOVE, (_, id) => {
     trackBookmarkAction("remove");
     return removeBookmark(id);
@@ -22709,6 +22937,41 @@ function registerIpcHandlers(windowState, runtime2) {
   registerAutofillHandlers(windowState);
   registerPageDiffHandlers(windowState, sendToRendererViews);
 }
+const UNDOABLE_ACTIONS = /* @__PURE__ */ new Set([
+  "accept_cookies",
+  "clear_overlays",
+  "click",
+  "close_tab",
+  "create_tab",
+  "dismiss_popup",
+  "fill_form",
+  "focus",
+  "go_back",
+  "go_forward",
+  "load_session",
+  "login",
+  "navigate",
+  "open_bookmark",
+  "paginate",
+  "press_key",
+  "reload",
+  "restore_checkpoint",
+  "scroll",
+  "scroll_to_element",
+  "search",
+  "select_option",
+  "set_ad_blocking",
+  "submit_form",
+  "switch_tab",
+  "type_text"
+]);
+function isUndoableAction(name) {
+  return UNDOABLE_ACTIONS.has(name);
+}
+function isUndoableResult(result) {
+  const normalized = result.trim().toLowerCase();
+  return normalized.length > 0 && !normalized.startsWith("error:") && !normalized.startsWith("nothing to ") && !normalized.startsWith("no active ") && !normalized.startsWith("action rejected:");
+}
 function makeStep(label, status = "pending") {
   return { label, status };
 }
@@ -23105,6 +23368,7 @@ class AgentRuntime {
   state;
   updateListener = null;
   pendingResolvers = /* @__PURE__ */ new Map();
+  undoSnapshots = [];
   setUpdateListener(listener) {
     this.updateListener = listener;
     if (listener) {
@@ -23114,6 +23378,8 @@ class AgentRuntime {
   getState() {
     const snapshot = clone(this.state);
     snapshot.mcpStatus = getMcpStatus();
+    snapshot.canUndo = this.canUndo();
+    snapshot.undoInfo = this.getUndoInfo();
     return snapshot;
   }
   onTabStateChanged() {
@@ -23156,6 +23422,37 @@ class AgentRuntime {
     this.captureSession(`Restored ${checkpoint.name}`);
     return clone(checkpoint);
   }
+  updateCheckpointNote(checkpointId, note) {
+    const index = this.state.checkpoints.findIndex((item) => item.id === checkpointId);
+    if (index === -1) return null;
+    this.state.checkpoints[index] = {
+      ...this.state.checkpoints[index],
+      note: note.trim() || void 0
+    };
+    this.emit();
+    return clone(this.state.checkpoints[index]);
+  }
+  canUndo() {
+    return this.undoSnapshots.length > 0;
+  }
+  getUndoInfo() {
+    const latest = this.undoSnapshots[this.undoSnapshots.length - 1];
+    if (!latest) return null;
+    return { actionName: latest.actionName, capturedAt: latest.capturedAt };
+  }
+  undoLastAction() {
+    const snapshot = this.undoSnapshots.at(-1);
+    if (!snapshot) return null;
+    try {
+      this.tabManager.restoreSession(snapshot.snapshot);
+      this.undoSnapshots.pop();
+    } catch (error) {
+      logger$3.error("Failed to restore undo snapshot", error);
+      return null;
+    }
+    this.captureSession(`Undid ${snapshot.actionName}`);
+    return snapshot.actionName;
+  }
   captureSession(note) {
     const snapshot = this.tabManager.snapshotSession(note);
     this.state.session = snapshot;
@@ -23305,6 +23602,7 @@ ${progress}
     args = {},
     tabId = null,
     dangerous = false,
+    undoable,
     executor
   }) {
     const action = this.startAction({
@@ -23358,8 +23656,13 @@ ${progress}
       streamId: transcriptStreamId,
       mode: "replace"
     });
+    const shouldCaptureUndo = undoable ?? isUndoableAction(name);
+    const undoSnapshot = shouldCaptureUndo ? this.createUndoSnapshot(name) : null;
     try {
       const result = await executor();
+      if (undoSnapshot && isUndoableResult(result)) {
+        this.pushUndoSnapshot(undoSnapshot);
+      }
       this.finishAction(action.id, "completed", summarizeText(result));
       this.publishTranscript({
         source,
@@ -23386,6 +23689,21 @@ ${progress}
       throw error;
     }
   }
+  createUndoSnapshot(name) {
+    return {
+      id: crypto$2.randomUUID(),
+      actionName: name,
+      snapshot: this.tabManager.snapshotSession(
+        `Auto-checkpoint before ${name}`
+      ),
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  pushUndoSnapshot(snapshot) {
+    this.undoSnapshots = [...this.undoSnapshots, snapshot].slice(
+      -10
+    );
+  }
   resolveApproval(approvalId, approved) {
     const approval = this.state.supervisor.pendingApprovals.find(
       (item) => item.id === approvalId