@quanta-intellect/vessel-browser 0.1.136 → 0.1.138

package/out/main/index.js

@@ -10,6 +10,8 @@ const OpenAI = require("openai");
 const crypto$2 = require("node:crypto");
 const http = require("http");
 const path$1 = require("node:path");
+const readability = require("@mozilla/readability");
+const linkedom = require("linkedom");
 const node_module = require("node:module");
 const http$1 = require("node:http");
 const os = require("node:os");
@@ -494,6 +496,10 @@ function assertSafeURL(url) {
 }
 function assertPermittedNavigationURL(url) {
   assertSafeURL(url);
+  const airGapError = getAirGapBlockReason(url);
+  if (airGapError) {
+    throw new Error(airGapError);
+  }
   const policyError = checkDomainPolicy(url);
   if (policyError) {
     throw new Error(policyError);
@@ -589,11 +595,11 @@ class Tab {
       return null;
     }
     try {
-      assertSafeURL(url);
+      assertPermittedNavigationURL(url);
     } catch (error) {
       return error instanceof Error ? error.message : "Blocked unsafe navigation";
     }
-    return checkDomainPolicy(url);
+    return null;
   }
   guardedLoadURL(url, options) {
     const blockReason = this.getNavigationBlockReason(url);
@@ -3705,6 +3711,8 @@ const AutofillChannels = {
 const AutomationChannels = {
   AUTOMATION_GET_INSTALLED: "automation:get-installed",
   AUTOMATION_INSTALL_FROM_FILE: "automation:install-from-file",
+  AUTOMATION_CREATE_FROM_TEXT: "automation:create-from-text",
+  AUTOMATION_UPDATE_FROM_TEXT: "automation:update-from-text",
   AUTOMATION_UNINSTALL: "automation:uninstall",
   AUTOMATION_ACTIVITY_START: "automation:activity-start",
   AUTOMATION_ACTIVITY_CHUNK: "automation:activity-chunk",
@@ -4251,10 +4259,28 @@ function buildPageSnapshotKey(rawUrl) {
     return normalizePageUrl(rawUrl);
   }
 }
+function isDocumentViewerUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    const pathname = decodeURIComponent(url.pathname).toLowerCase();
+    if (/\.(pdf|epub|mobi|cbz|cbr)(?:$|[?#])/.test(pathname)) {
+      return true;
+    }
+    const host = url.hostname.toLowerCase().replace(/^www\./, "");
+    if (host === "archive.org") {
+      return /^\/(details|stream|download)\//.test(pathname);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function isTrackablePageUrl(rawUrl) {
   try {
     const url = new URL(rawUrl);
-    return url.protocol === "http:" || url.protocol === "https:";
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    return !isDocumentViewerUrl(rawUrl);
   } catch {
     return false;
   }
@@ -4951,6 +4977,11 @@ const PREMIUM_TOOLS = /* @__PURE__ */ new Set([
   "human_vault_list",
   "human_vault_fill",
   "human_vault_remove",
+  "memory_note_create",
+  "memory_note_append",
+  "memory_note_list",
+  "memory_note_search",
+  "memory_page_capture",
   "research_confirm_brief",
   "research_approve_objectives",
   "research_export_report"
@@ -6663,7 +6694,7 @@ async function extractContentInner(webContents) {
     webContents
   );
 }
-async function extractContent$1(webContents) {
+async function extractContent(webContents) {
   const cacheKey = `${webContents.id}:${webContents.getURL() || ""}`;
   const cached = extractionCache.get(cacheKey);
   if (cached) {
@@ -6881,7 +6912,7 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
     if (!shouldTrackSnapshotUrl(url)) return;
     const key2 = normalizeUrl(url);
     const oldSnap = getSnapshot(key2);
-    const content = await extractContent$1(wc);
+    const content = await extractContent(wc);
     const textContent = content.content || "";
     const title = content.title || "";
     const headings = content.headings || [];
@@ -12113,7 +12144,7 @@ async function resolveSelector(wc, index, selector) {
   if (typeof fallbackSelector === "string" && fallbackSelector) {
     return fallbackSelector;
   }
-  const page = await extractContent$1(wc);
+  const page = await extractContent(wc);
   const extractedSelector = findSelectorByIndex(page, index);
   if (extractedSelector) return extractedSelector;
   return null;
@@ -12186,6 +12217,15 @@ async function validateLinkDestination(url, timeoutMs = 3500) {
       detail: "Non-HTTP URL"
     };
   }
+  try {
+    assertPermittedNavigationURL(url);
+  } catch (error) {
+    return {
+      status: "unknown",
+      checkedUrl: url,
+      detail: error instanceof Error ? error.message : "Navigation policy blocked URL"
+    };
+  }
   try {
     const headResponse = await requestUrl(url, "HEAD", timeoutMs);
     if (!HEAD_FALLBACK_STATUS_CODES.has(headResponse.status)) {
@@ -14849,6 +14889,22 @@ function getGlanceExtractScript() {
     };
   })()`;
 }
+function cleanArticleText(value) {
+  return value.replace(/\u00a0/g, " ").replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/(\n\s*){3,}/g, "\n\n").trim();
+}
+function articleTextResultToOutput(result, mode, source, elapsedMs) {
+  const sections = [
+    `# ${result.title || "(untitled)"}`,
+    `URL: ${result.url}`,
+    "",
+    `[read_page mode=${mode} — ${source}, ${elapsedMs}ms]`
+  ];
+  if (result.headings.length > 0) {
+    sections.push("", "## Headings", ...result.headings);
+  }
+  sections.push("", "## Article Text", "", result.text);
+  return sections.join("\n");
+}
 async function glanceExtract(wc) {
   const startMs = Date.now();
   const result = await executePageScript(wc, getGlanceExtractScript(), { timeoutMs: 2500, label: "glance-extract" });
@@ -14896,6 +14952,168 @@ async function glanceExtract(wc) {
   }
   return sections.join("\n");
 }
+async function fastArticleTextExtract(wc, mode) {
+  const startMs = Date.now();
+  const result = await executePageScript(
+    wc,
+    `(function() {
+      function clean(value) {
+        return String(value || '').replace(/[ \\t]+/g, ' ').replace(/(\\n\\s*){3,}/g, '\\n\\n').trim();
+      }
+
+      var rootSelectors = [
+        '#mw-content-text .mw-parser-output',
+        '#mw-content-text',
+        'main article',
+        'article',
+        'main',
+        '[role="main"]',
+        '#content'
+      ];
+      var root = null;
+      for (var i = 0; i < rootSelectors.length; i++) {
+        var candidate = document.querySelector(rootSelectors[i]);
+        if (candidate && clean(candidate.textContent).length > 300) {
+          root = candidate;
+          break;
+        }
+      }
+      if (!root) return null;
+
+      var unwantedSelector = [
+        'script',
+        'style',
+        'noscript',
+        'nav',
+        'header',
+        'footer',
+        'aside',
+        '.mw-editsection',
+        '.reference',
+        '.reflist',
+        '.navbox',
+        '.infobox',
+        '.metadata',
+        '.ambox',
+        '.toc',
+        '#toc'
+      ].join(',');
+
+      var headings = [];
+      var parts = [];
+      var nodes = root.querySelectorAll('h1, h2, h3, p, li');
+      for (var j = 0; j < nodes.length && parts.length < 180; j++) {
+        var node = nodes[j];
+        if (node.closest && node.closest(unwantedSelector)) continue;
+        var tag = String(node.tagName || '').toLowerCase();
+        var text = clean(node.textContent);
+        if (!text) continue;
+        if (/^h[1-3]$/.test(tag)) {
+          if (text.length < 180) headings.push(tag + ': ' + text);
+          parts.push('\\n## ' + text);
+          continue;
+        }
+        if (text.length < 40) continue;
+        parts.push(text);
+      }
+
+      var articleText = clean(parts.join('\\n\\n'));
+      if (articleText.length < 300) {
+        articleText = clean(root.textContent).slice(0, 12000);
+      }
+      if (articleText.length < 300) return null;
+
+      return {
+        title: document.title || '',
+        url: location.href,
+        headings: headings.slice(0, 18),
+        text: articleText.slice(0, ${mode === "summary" ? 9e3 : 14e3}),
+      };
+    })()`,
+    {
+      timeoutMs: 1800,
+      label: "fast article text"
+    }
+  );
+  if (!result || result === PAGE_SCRIPT_TIMEOUT || !result.text.trim()) {
+    return null;
+  }
+  return articleTextResultToOutput(
+    {
+      title: result.title || wc.getTitle() || "(untitled)",
+      url: result.url || wc.getURL(),
+      headings: result.headings,
+      text: result.text
+    },
+    mode,
+    "fast article text",
+    Date.now() - startMs
+  );
+}
+async function fetchArticleTextExtract(wc, mode) {
+  const startMs = Date.now();
+  const url = wc.getURL();
+  try {
+    assertSafeURL(url);
+  } catch {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 4500);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "text/html,application/xhtml+xml",
+        "User-Agent": "VesselBrowser/0.1 read-page-fallback"
+      }
+    });
+    if (!response.ok) return null;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType && !/text\/html|application\/xhtml\+xml/i.test(contentType)) {
+      return null;
+    }
+    const contentLength = Number(response.headers.get("content-length") || "0");
+    if (contentLength > 5e6) return null;
+    const html = await response.text();
+    if (html.trim().length < 300) return null;
+    const { document } = linkedom.parseHTML(html);
+    const readable = new readability.Readability(document, {
+      charThreshold: 300
+    }).parse();
+    const title = cleanArticleText(readable?.title || document.title || wc.getTitle()) || wc.getTitle() || "(untitled)";
+    const headings = Array.from(document.querySelectorAll("h1, h2, h3")).map((node) => {
+      const tag = String(node.tagName || "").toLowerCase();
+      const text2 = cleanArticleText(node.textContent || "");
+      return text2.length > 0 && text2.length < 180 ? `${tag}: ${text2}` : "";
+    }).filter(Boolean).slice(0, 18);
+    const fallbackRoot = document.querySelector("article") || document.querySelector("main") || document.querySelector('[role="main"]') || document.body;
+    const text = cleanArticleText(
+      readable?.textContent || fallbackRoot?.textContent || ""
+    );
+    if (text.length < 300) return null;
+    return articleTextResultToOutput(
+      {
+        title,
+        url,
+        headings,
+        text: text.slice(0, mode === "summary" ? 9e3 : 14e3)
+      },
+      mode,
+      "network article fallback",
+      Date.now() - startMs
+    );
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      logger$k.warn("Network article fallback timed out:", url);
+    } else {
+      logger$k.warn("Network article fallback failed:", err);
+    }
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 function normalizeReadPageMode(mode, pageContent) {
   if (typeof mode === "string") {
     const normalized = mode.trim().toLowerCase();
@@ -14967,7 +15185,7 @@ async function getPostSearchSummary(wc) {
   await waitForLoad(wc, 2e3);
   try {
     const content = await Promise.race([
-      extractContent$1(wc),
+      extractContent(wc),
       new Promise((resolve) => setTimeout(() => resolve(null), 2500))
     ]);
     if (content && content.content.length > 0) {
@@ -14989,7 +15207,7 @@ Search results snapshot unavailable. Use read_page(mode="results_only") if neede
 async function getPostClickNavSummary(wc, toolProfile) {
   try {
     const content = await Promise.race([
-      extractContent$1(wc),
+      extractContent(wc),
       new Promise((resolve) => setTimeout(() => resolve(null), 3e3))
     ]);
     if (content && content.content.length > 0) {
@@ -16715,8 +16933,11 @@ async function tryAcceptCookiesQuickly(wc) {
   const dismissed = await executePageScript(
     wc,
     `
-      (function() {
-        var selectors = [
+      (async function() {
+        var delay = function(ms) {
+          return new Promise(function(resolve) { setTimeout(resolve, ms); });
+        };
+        var selectorTargets = [
           '#onetrust-accept-btn-handler',
           '#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll',
           '[data-cookiefirst-action="accept"]',
@@ -16736,60 +16957,237 @@ async function tryAcceptCookiesQuickly(wc) {
           '.message-component.message-button.no-children.focusable.sp_choice_type_11',
           '[class*="truste"] [class*="accept"]',
           '[id*="consent-accept"]',
-          '[class*="cmp-accept"]',
+          '[class*="cmp-accept"]'
         ];
-        var textPatterns = [
-          'accept all',
-          'accept cookies',
-          'allow all',
-          'allow cookies',
-          'agree',
-          'got it',
-          'ok',
-          'i agree',
-          'i accept',
-          'consent',
-          'continue',
-          'accept and continue',
-          'accept & continue'
+        var surfaceSelectors = [
+          '#onetrust-consent-sdk',
+          '#CybotCookiebotDialog',
+          '[id*="cookie" i]',
+          '[id*="consent" i]',
+          '[id*="cmp" i]',
+          '[id*="sp_message" i]',
+          '[class*="cookie" i]',
+          '[class*="consent" i]',
+          '[class*="cmp" i]',
+          '[class*="sp_message" i]',
+          '[class*="truste" i]',
+          '[class*="didomi" i]',
+          '[data-testid*="cookie" i]',
+          '[data-testid*="consent" i]',
+          '[aria-label*="cookie" i]',
+          '[aria-label*="consent" i]',
+          '.fc-consent-root'
         ];
-        for (var i = 0; i < selectors.length; i++) {
-          var el = document.querySelector(selectors[i]);
-          if (el && el instanceof HTMLElement) {
-            el.click();
-            return "Dismissed cookie banner via: " + selectors[i];
+        var actionSelector = [
+          'button',
+          '[role="button"]',
+          'a[role="button"]',
+          'a.message-component',
+          'input[type="button"]',
+          'input[type="submit"]'
+        ].join(',');
+        var seen = [];
+
+        function normalize(text) {
+          return String(text || '').replace(/\\s+/g, ' ').trim();
+        }
+
+        function lower(text) {
+          return normalize(text).toLowerCase();
+        }
+
+        function isElementVisible(el) {
+          if (!(el instanceof HTMLElement)) return false;
+          var style = window.getComputedStyle(el);
+          if (style.display === 'none' || style.visibility === 'hidden') return false;
+          if (Number(style.opacity || '1') < 0.05) return false;
+          var rect = el.getBoundingClientRect();
+          return rect.width > 2 &&
+            rect.height > 2 &&
+            rect.bottom > 0 &&
+            rect.right > 0 &&
+            rect.top < window.innerHeight &&
+            rect.left < window.innerWidth;
+        }
+
+        function elementText(el) {
+          if (!(el instanceof HTMLElement)) return '';
+          return normalize([
+            el.getAttribute('aria-label'),
+            el.getAttribute('title'),
+            el.getAttribute('value'),
+            el.textContent
+          ].filter(Boolean).join(' '));
+        }
+
+        function looksLikeCookieSurface(el) {
+          if (!isElementVisible(el)) return false;
+          var text = lower([
+            el.getAttribute('aria-label'),
+            el.getAttribute('id'),
+            el.getAttribute('class'),
+            el.textContent
+          ].filter(Boolean).join(' ')).slice(0, 1600);
+          if (!/(cookie|consent|privacy|tracking|personalise|personalize|advertis|data choices|your choices|cmp|onetrust|truste|didomi)/.test(text)) {
+            return false;
           }
+
+          var rect = el.getBoundingClientRect();
+          var style = window.getComputedStyle(el);
+          var fixedLike = style.position === 'fixed' || style.position === 'sticky';
+          var sizeable = rect.width >= Math.min(window.innerWidth * 0.35, 360) && rect.height >= 48;
+          var bottomBanner = fixedLike && rect.bottom > window.innerHeight * 0.58 && rect.height >= 64;
+          var dialog = el.getAttribute('role') === 'dialog' || el.getAttribute('aria-modal') === 'true';
+          var namedSurface = /(cookie|consent|cmp|onetrust|truste|didomi|sp_message)/.test(lower([
+            el.getAttribute('id'),
+            el.getAttribute('class'),
+            el.getAttribute('data-testid')
+          ].filter(Boolean).join(' ')));
+
+          return sizeable && (namedSurface || bottomBanner || dialog);
         }
-        var buttons = document.querySelectorAll('button, a[role="button"], [type="submit"]');
-        for (var j = 0; j < buttons.length; j++) {
-          var btn = buttons[j];
-          var text = (btn.textContent || '').trim().toLowerCase();
-          for (var k = 0; k < textPatterns.length; k++) {
-            if (text === textPatterns[k] || text.startsWith(textPatterns[k])) {
-              btn.click();
-              return "Dismissed cookie banner via text match: " + text;
+
+        function cookieSurfaces() {
+          var surfaces = [];
+          function addSurface(el) {
+            if (surfaces.indexOf(el) === -1 && looksLikeCookieSurface(el)) {
+              surfaces.push(el);
+            }
+          }
+
+          for (var i = 0; i < surfaceSelectors.length; i++) {
+            try {
+              document.querySelectorAll(surfaceSelectors[i]).forEach(addSurface);
+            } catch {
+              // Ignore unsupported selectors in older page engines.
+            }
+          }
+
+          document.querySelectorAll('div, section, aside, footer, form, [role="dialog"]').forEach(function(el) {
+            if (!(el instanceof HTMLElement)) return;
+            var style = window.getComputedStyle(el);
+            if (style.position === 'fixed' || style.position === 'sticky' || el.getAttribute('role') === 'dialog') {
+              addSurface(el);
             }
+          });
+
+          return surfaces;
+        }
+
+        function hasCookieSurface() {
+          return cookieSurfaces().length > 0;
+        }
+
+        function labelScore(label) {
+          var text = lower(label);
+          if (!text) return 0;
+          if (/^(accept all|accept cookies|allow all|allow cookies|accept and continue|accept & continue|agree and continue)$/.test(text)) {
+            return 220;
+          }
+          if (/^(i agree|i accept|agree|accept|allow|ok|okay|got it|continue|yes)$/.test(text)) {
+            return 190;
+          }
+          if (/^(reject all|decline|deny|necessary only|essential only|save preferences|confirm choices|submit preferences)$/.test(text)) {
+            return 170;
+          }
+          if (/\\b(accept all|allow all|accept cookies|allow cookies|accept and continue|accept & continue|agree and continue)\\b/.test(text)) {
+            return 160;
+          }
+          if (/\\b(reject all|save preferences|confirm choices|necessary only|essential only)\\b/.test(text)) {
+            return 145;
+          }
+          if (/^(consent|cookie consent|cookies|privacy|privacy policy|cookie policy|learn more|more information|settings|preferences|manage options|customize|customise)$/.test(text)) {
+            return 0;
+          }
+          return 0;
+        }
+
+        function addCandidate(el, source, baseScore) {
+          if (!(el instanceof HTMLElement) || seen.indexOf(el) !== -1 || !isElementVisible(el)) return;
+          var label = elementText(el);
+          var score = labelScore(label);
+          if (score <= 0 && baseScore < 160) return;
+          seen.push(el);
+          candidates.push({
+            el: el,
+            label: label || source,
+            source: source,
+            score: baseScore + score
+          });
+        }
+
+        var beforeHadSurface = hasCookieSurface();
+        var candidates = [];
+
+        for (var i = 0; i < selectorTargets.length; i++) {
+          try {
+            document.querySelectorAll(selectorTargets[i]).forEach(function(el) {
+              addCandidate(el, selectorTargets[i], 160);
+            });
+          } catch {
+            // Ignore unsupported selectors in older page engines.
+          }
+        }
+
+        var surfaces = cookieSurfaces();
+        surfaces.forEach(function(surface) {
+          surface.querySelectorAll(actionSelector).forEach(function(el) {
+            addCandidate(el, 'cookie surface', 120);
+          });
+        });
+
+        if (beforeHadSurface) {
+          document.querySelectorAll(actionSelector).forEach(function(el) {
+            addCandidate(el, 'page action', 40);
+          });
+        }
+
+        candidates.sort(function(a, b) { return b.score - a.score; });
+
+        var tried = 0;
+        for (var j = 0; j < Math.min(candidates.length, 8); j++) {
+          var candidate = candidates[j];
+          tried += 1;
+          candidate.el.click();
+          await delay(220);
+          if (!hasCookieSurface()) {
+            return {
+              status: 'dismissed',
+              message: 'Dismissed cookie banner via: ' + candidate.label.slice(0, 80)
+            };
           }
         }
+
+        if (beforeHadSurface || tried > 0) {
+          return {
+            status: 'still_visible',
+            message: tried > 0
+              ? 'Cookie consent banner is still visible after trying ' + tried + ' candidate control(s). Try clear_overlays or dismiss_popup.'
+              : 'Cookie consent banner appears visible, but no reliable accept/reject button was found. Try clear_overlays or dismiss_popup.'
+          };
+        }
+
         return null;
       })()
     `,
     {
       label: "accept cookies",
-      timeoutMs: 1200
+      timeoutMs: 2200,
+      userGesture: true
     }
   );
   if (dismissed) return dismissed;
-  return tryDismissConsentIframe(wc);
+  const iframeDismissed = await tryDismissConsentIframe(wc);
+  return iframeDismissed ? { status: "dismissed", message: iframeDismissed } : null;
 }
 async function clearOverlays(wc, strategy = "auto") {
   const quickCookieResult = await tryAcceptCookiesQuickly(wc);
   if (quickCookieResult === PAGE_SCRIPT_TIMEOUT) {
     return pageBusyError("clear_overlays");
   }
-  if (quickCookieResult) {
+  if (quickCookieResult?.status === "dismissed") {
     return [
-      quickCookieResult,
+      quickCookieResult.message,
       "Stopped after a lightweight consent pass to keep the page responsive. Re-run only if the banner is still blocking the page."
     ].join("\n");
   }
@@ -17738,6 +18136,94 @@ async function locateSearchTarget(wc, explicitSelector) {
     }
   );
 }
+async function locateImplicitTextTarget(wc) {
+  return executePageScript(
+    wc,
+    `
+      (function() {
+        function normalize(value) {
+          return value == null ? "" : String(value).trim().toLowerCase();
+        }
+
+        function isVisible(el) {
+          if (!(el instanceof HTMLElement)) return true;
+          const style = window.getComputedStyle(el);
+          if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+          if (el.hasAttribute("hidden") || el.getAttribute("aria-hidden") === "true") return false;
+          const rect = el.getBoundingClientRect();
+          return rect.width > 0 && rect.height > 0;
+        }
+
+        function inViewport(el) {
+          if (!(el instanceof HTMLElement)) return true;
+          const rect = el.getBoundingClientRect();
+          const vw = window.innerWidth || document.documentElement?.clientWidth || 0;
+          const vh = window.innerHeight || document.documentElement?.clientHeight || 0;
+          return rect.bottom > 0 && rect.right > 0 && rect.top < vh && rect.left < vw;
+        }
+
+        function isFillable(el) {
+          if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return false;
+          if (el.disabled || el.readOnly || el.getAttribute("aria-disabled") === "true") return false;
+          const type = el instanceof HTMLTextAreaElement ? "text" : normalize(el.getAttribute("type") || el.type || "text");
+          return ["", "search", "text", "email", "url", "tel", "number", "password"].includes(type);
+        }
+
+        function nearestSearchScope(input) {
+          return input.closest('[role="search"], form, header, nav, [class*="search" i], [id*="search" i]');
+        }
+
+        ${selectorHelpersJS(["data-testid", "name", "form", "aria-label", "placeholder"])}
+
+        const active = document.activeElement;
+        if (active && isFillable(active) && isVisible(active) && inViewport(active)) {
+          return selectorFor(active);
+        }
+
+        const candidates = Array.from(
+          document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="image"]), textarea')
+        ).filter((el) => isFillable(el) && isVisible(el));
+
+        let best = null;
+        let bestScore = -1;
+        for (const el of candidates) {
+          let score = 0;
+          if (inViewport(el)) score += 100;
+          const rect = el.getBoundingClientRect();
+          score += Math.max(0, 36 - Math.min(36, Math.floor(Math.max(0, rect.top) / 22)));
+
+          const type = el instanceof HTMLTextAreaElement ? "text" : normalize(el.getAttribute("type") || el.type);
+          const name = normalize(el.getAttribute("name"));
+          const placeholder = normalize(el.getAttribute("placeholder"));
+          const aria = normalize(el.getAttribute("aria-label"));
+          const role = normalize(el.getAttribute("role"));
+          const id = normalize(el.getAttribute("id"));
+
+          if (type === "search") score += 80;
+          if (role === "searchbox") score += 70;
+          if (name === "q" || name === "query" || name === "search") score += 65;
+          if (placeholder.includes("search")) score += 55;
+          if (aria.includes("search")) score += 55;
+          if (id.includes("search")) score += 35;
+
+          const scope = nearestSearchScope(el);
+          if (scope) score += 35;
+
+          if (score > bestScore) {
+            best = el;
+            bestScore = score;
+          }
+        }
+
+        return best ? selectorFor(best) : null;
+      })()
+    `,
+    {
+      timeoutMs: 2200,
+      label: "find implicit text input"
+    }
+  );
+}
 async function searchPage(wc, args) {
   const query = String(args.query || "");
   if (!query) return "Error: No search query provided.";
@@ -18227,8 +18713,19 @@ async function executeAction(name, args, ctx) {
         }
         case "type_text": {
           if (!wc) return "Error: No active tab";
-          const selector = await resolveSelector(wc, args.index, args.selector);
-          if (!selector) return "Error: No element index or selector provided";
+          let selector = await resolveSelector(wc, args.index, args.selector);
+          if (selector === PAGE_SCRIPT_TIMEOUT) {
+            return pageBusyError("type_text");
+          }
+          if (!selector) {
+            selector = await locateImplicitTextTarget(wc);
+          }
+          if (selector === PAGE_SCRIPT_TIMEOUT) {
+            return pageBusyError("type_text");
+          }
+          if (!selector) {
+            return "Error: No element index or selector provided, and no focused or visible text input could be found.";
+          }
           const mode = typeof args.mode === "string" ? args.mode : "default";
           if (mode === "keystroke") {
             return typeKeystroke(wc, selector, String(args.text || ""));
@@ -18324,6 +18821,23 @@ async function executeAction(name, args, ctx) {
           if (requestedGlance) {
             return glanceExtract(wc);
           }
+          const requestedTextMode = typeof args.mode === "string" ? args.mode.trim().toLowerCase() : "";
+          if (requestedTextMode === "summary" || requestedTextMode === "text_only") {
+            const fastArticleText = await fastArticleTextExtract(
+              wc,
+              requestedTextMode
+            );
+            if (fastArticleText) {
+              return fastArticleText;
+            }
+            const fetchedArticleText = await fetchArticleTextExtract(
+              wc,
+              requestedTextMode
+            );
+            if (fetchedArticleText) {
+              return fetchedArticleText;
+            }
+          }
           let content = null;
           try {
             content = await Promise.race([
@@ -19020,7 +19534,7 @@ ${steps.join("\n")}`;
           if (dismissed === PAGE_SCRIPT_TIMEOUT) {
             return pageBusyError("accept_cookies");
           }
-          if (dismissed) return dismissed;
+          if (dismissed) return dismissed.message;
           return "No cookie consent banner detected. Try dismiss_popup for other overlays.";
         }
         case "extract_table": {
@@ -20272,13 +20786,31 @@ async function showDownloadInFolder(id) {
 }
 const defaultDownloadViews = /* @__PURE__ */ new Set();
 let defaultDownloadHandlerInstalled = false;
+function sanitizeDownloadFilename(filename) {
+  const normalized = filename.replace(/\\/g, "/");
+  const basename = path.posix.basename(normalized).trim();
+  const safeName = basename.replace(/[\0-\x1f\x7f]/g, "_");
+  if (!safeName || safeName === "." || safeName === "..") {
+    return "download";
+  }
+  return safeName;
+}
+function isPathInside(parentDir, candidatePath) {
+  const relative = path.relative(parentDir, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 function resolveDownloadPath(downloadDir, filename) {
   fs$1.mkdirSync(downloadDir, { recursive: true });
-  const parsed = path.parse(filename);
+  const rootDir = path.resolve(downloadDir);
+  const safeFilename = sanitizeDownloadFilename(filename);
+  const parsed = path.parse(safeFilename);
   let attempt = 0;
   while (true) {
-    const candidateName = attempt === 0 ? filename : `${parsed.name} (${attempt})${parsed.ext}`;
-    const candidatePath = path.join(downloadDir, candidateName);
+    const candidateName = attempt === 0 ? safeFilename : `${parsed.name} (${attempt})${parsed.ext}`;
+    const candidatePath = path.resolve(rootDir, candidateName);
+    if (!isPathInside(rootDir, candidatePath)) {
+      throw new Error("Blocked unsafe download filename");
+    }
     if (!fs$1.existsSync(candidatePath)) {
       return candidatePath;
     }
@@ -21455,7 +21987,7 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
   const isSummarize = lowerQuery.startsWith("summarize") || lowerQuery.startsWith("tldr") || lowerQuery === "summary";
   if (provider.streamAgentQuery && tabManager && activeWebContents && runtime2) {
     try {
-      const pageContent = await extractContent$1(activeWebContents);
+      const pageContent = await extractContent(activeWebContents);
       const pageType = detectPageType(pageContent);
       const defaultReadMode = chooseAgentReadMode(pageContent);
       if (provider.agentToolProfile === "compact") {
@@ -21556,7 +22088,7 @@ ${trackerCtx}`;
   let prompt;
   if (activeWebContents) {
     try {
-      const pageContent = await extractContent$1(activeWebContents);
+      const pageContent = await extractContent(activeWebContents);
       if (isSummarize) {
         prompt = buildSummarizePrompt(pageContent);
       } else {
@@ -21837,7 +22369,7 @@ function registerContentHandlers(windowState2) {
     assertTrustedIpcSender(event);
     const activeTab = tabManager.getActiveTab();
     if (!activeTab) return null;
-    return extractContent$1(activeTab.view.webContents);
+    return extractContent(activeTab.view.webContents);
   });
   electron.ipcMain.handle(Channels.READER_MODE_TOGGLE, async (event) => {
     assertTrustedIpcSender(event);
@@ -21851,7 +22383,7 @@ function registerContentHandlers(windowState2) {
       }
     } else {
       const originalUrl = activeTab.state.url;
-      const content = await extractContent$1(activeTab.view.webContents);
+      const content = await extractContent(activeTab.view.webContents);
       const html = generateReaderHTML(content);
       activeTab.setReaderMode(true, originalUrl);
       void loadInternalDataURL(
@@ -22147,532 +22679,182 @@ function registerAgentRuntimeHandlers(runtime2, chromeView, sidebarView, sendToR
     }
   );
 }
-const DEFAULT_PAGE_FOLDER = "Vessel/Pages";
-const DEFAULT_NOTE_FOLDER = "Vessel/Research";
-const DEFAULT_BOOKMARK_FOLDER = "Vessel/Bookmarks";
-const PAGE_CONTENT_LIMIT = 6e3;
-const DEFAULT_LIST_LIMIT = 50;
-const DEFAULT_SEARCH_LIMIT = 20;
-function getVaultRoot() {
-  const configured = loadSettings().obsidianVaultPath.trim();
-  if (!configured) {
-    throw new Error(
-      "Obsidian not configured. Set vault path in Vessel settings to use memory capture."
-    );
-  }
-  return path$1.resolve(configured);
+function asTextResponse$1(text) {
+  return { content: [{ type: "text", text }] };
 }
-function assertInsideVault(targetPath, vaultRoot) {
-  const resolved = path$1.resolve(targetPath);
-  const relative = path$1.relative(vaultRoot, resolved);
-  if (relative.startsWith("..") || path$1.isAbsolute(relative)) {
-    throw new Error("Resolved note path is outside the configured vault.");
-  }
-  return resolved;
+const DANGEROUS_DEVTOOLS_ACTIONS = /* @__PURE__ */ new Set([
+  "devtools_execute_js",
+  "devtools_modify_dom",
+  "devtools_set_storage"
+]);
+let stateListener = null;
+const activityLog = [];
+const MAX_ACTIVITY_ENTRIES = 100;
+let activityCounter = 0;
+function setDevToolsPanelListener(listener) {
+  stateListener = listener;
 }
-function normalizeFolder(folder, fallback) {
-  const raw = (folder?.trim() || fallback).replace(/\\/g, "/");
-  if (!raw) return fallback;
-  if (path$1.isAbsolute(raw)) {
-    throw new Error("Vault note folders must be relative to the vault root.");
-  }
-  const segments = raw.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === "." || segment === "..")) {
-    throw new Error("Vault note folders cannot traverse outside the vault.");
-  }
-  return segments.join(path$1.sep);
+function getDevToolsPanelState(tabId) {
+  const session = tabId ? getSession(tabId) : void 0;
+  return {
+    console: session?.getConsoleLogs() ?? [],
+    network: session?.getNetworkLog() ?? [],
+    errors: session?.getErrors() ?? [],
+    activity: activityLog
+  };
 }
-function normalizeNotePath(notePath) {
-  const raw = notePath.trim().replace(/\\/g, "/");
-  if (!raw) {
-    throw new Error("A note path is required.");
+function broadcastState(tabManager) {
+  if (!stateListener) return;
+  const tabId = tabManager.getActiveTabId();
+  stateListener(getDevToolsPanelState(tabId));
+}
+async function withDevToolsAction(runtime2, tabManager, name, args, executor) {
+  try {
+    assertFeatureUnlocked("devtools", "DevTools");
+  } catch (error) {
+    return asTextResponse$1(
+      `Error: ${error instanceof Error ? error.message : "DevTools require Vessel Premium."}`
+    );
   }
-  if (path$1.isAbsolute(raw)) {
-    throw new Error("Note paths must be relative to the vault root.");
+  const activityEntry = {
+    id: ++activityCounter,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: name,
+    args: JSON.stringify(args).slice(0, 200),
+    result: "",
+    durationMs: 0,
+    status: "running"
+  };
+  activityLog.push(activityEntry);
+  if (activityLog.length > MAX_ACTIVITY_ENTRIES) {
+    activityLog.splice(0, activityLog.length - MAX_ACTIVITY_ENTRIES);
   }
-  const segments = raw.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === "." || segment === "..")) {
-    throw new Error("Note paths cannot traverse outside the vault.");
+  broadcastState(tabManager);
+  const startTime = Date.now();
+  try {
+    const result = await runtime2.runControlledAction({
+      source: "mcp",
+      name,
+      args,
+      tabId: tabManager.getActiveTabId(),
+      dangerous: DANGEROUS_DEVTOOLS_ACTIONS.has(name),
+      executor
+    });
+    activityEntry.status = "completed";
+    activityEntry.result = result.slice(0, 200);
+    activityEntry.durationMs = Date.now() - startTime;
+    broadcastState(tabManager);
+    return asTextResponse$1(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    activityEntry.status = "failed";
+    activityEntry.result = message.slice(0, 200);
+    activityEntry.durationMs = Date.now() - startTime;
+    broadcastState(tabManager);
+    return asTextResponse$1(`Error: ${message}`);
   }
-  const normalized = segments.join(path$1.sep);
-  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
-}
-function escapeYaml(value) {
-  return JSON.stringify(value);
 }
-function renderFrontmatter(data) {
-  const lines = ["---"];
-  for (const [key2, value] of Object.entries(data)) {
-    if (value == null) continue;
-    if (Array.isArray(value)) {
-      if (value.length === 0) continue;
-      lines.push(`${key2}:`);
-      for (const item of value) {
-        lines.push(`  - ${escapeYaml(item)}`);
+function registerDevTools(server, tabManager, runtime2) {
+  server.registerTool(
+    "vessel_devtools_console_logs",
+    {
+      title: "DevTools: Get Console Logs",
+      description: "Get console log entries captured from the active tab. Returns a rolling buffer of recent console.log, console.warn, console.error, etc. calls. Automatically starts capturing on first use.",
+      inputSchema: {
+        level: zod.z.enum(["log", "warning", "error", "info", "debug", "verbose"]).optional().describe("Filter by log level"),
+        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)"),
+        search: zod.z.string().optional().describe("Filter entries containing this text (case-insensitive)")
       }
-      continue;
+    },
+    async ({ level, limit, search: search2 }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_console_logs",
+        { level, limit, search: search2 },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          await session.ensureConsoleDomain();
+          const entries = session.getConsoleLogs({ level, limit, search: search2 });
+          if (entries.length === 0) {
+            return "No console entries captured yet. Console monitoring is now active — new entries will be captured as they occur.";
+          }
+          return JSON.stringify(entries, null, 2);
+        }
+      );
     }
-    lines.push(`${key2}: ${escapeYaml(value)}`);
-  }
-  lines.push("---", "");
-  return lines.join("\n");
-}
-function slugify(value) {
-  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized || "note";
-}
-function buildUniqueNotePath(dir, title) {
-  const datePrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const slug = slugify(title);
-  const base = `${datePrefix}-${slug}`;
-  let candidate = `${base}.md`;
-  let counter = 2;
-  while (fs$1.existsSync(path$1.join(dir, candidate))) {
-    candidate = `${base}-${counter}.md`;
-    counter += 1;
-  }
-  return path$1.join(dir, candidate);
-}
-function trimContent(content, limit = PAGE_CONTENT_LIMIT) {
-  const cleaned = content.trim();
-  if (cleaned.length <= limit) return cleaned;
-  return `${cleaned.slice(0, limit)}
-
-[Truncated]`;
-}
-function parseFrontmatter(content) {
-  if (!content.startsWith("---\n")) {
-    return { body: content, tags: [] };
-  }
-  const closingIndex = content.indexOf("\n---\n", 4);
-  if (closingIndex === -1) {
-    return { body: content, tags: [] };
-  }
-  const raw = content.slice(4, closingIndex);
-  const body = content.slice(closingIndex + 5);
-  const lines = raw.split("\n");
-  const result = { tags: [] };
-  let activeArrayKey = "";
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("- ") && activeArrayKey === "tags") {
-      result.tags.push(
-        trimmed.slice(2).trim().replace(/^["']|["']$/g, "")
+  );
+  server.registerTool(
+    "vessel_devtools_console_clear",
+    {
+      title: "DevTools: Clear Console Logs",
+      description: "Clear the captured console log buffer for the active tab."
+    },
+    async () => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_console_clear",
+        {},
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          const count = session.clearConsoleLogs();
+          return `Cleared ${count} console entries.`;
+        }
       );
-      continue;
     }
-    activeArrayKey = "";
-    const separatorIndex = trimmed.indexOf(":");
-    if (separatorIndex === -1) continue;
-    const key2 = trimmed.slice(0, separatorIndex).trim();
-    const value = trimmed.slice(separatorIndex + 1).trim();
-    if (key2 === "title" && value) {
-      result.title = value.replace(/^["']|["']$/g, "");
-    } else if (key2 === "tags") {
-      activeArrayKey = "tags";
-      if (value.startsWith("[") && value.endsWith("]")) {
-        const inline = value.slice(1, -1).split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
-        result.tags.push(...inline);
-        activeArrayKey = "";
+  );
+  server.registerTool(
+    "vessel_devtools_network_log",
+    {
+      title: "DevTools: Get Network Log",
+      description: "Get captured network requests/responses from the active tab. Returns method, URL, status, timing, headers, and size. Automatically starts capturing on first use.",
+      inputSchema: {
+        url_pattern: zod.z.string().optional().describe("Filter by URL pattern (regex or substring match)"),
+        method: zod.z.string().optional().describe("Filter by HTTP method (GET, POST, etc.)"),
+        status_min: zod.z.number().optional().describe("Minimum HTTP status code (e.g., 400 for errors)"),
+        status_max: zod.z.number().optional().describe("Maximum HTTP status code"),
+        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)")
       }
+    },
+    async ({ url_pattern, method, status_min, status_max, limit }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_network_log",
+        { url_pattern, method, status_min, status_max, limit },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          await session.ensureNetworkDomain();
+          const entries = session.getNetworkLog({
+            urlPattern: url_pattern,
+            method,
+            statusRange: status_min != null || status_max != null ? { min: status_min, max: status_max } : void 0,
+            limit
+          });
+          if (entries.length === 0) {
+            return "No network requests captured yet. Network monitoring is now active — new requests will be captured as they occur.";
+          }
+          return JSON.stringify(entries, null, 2);
+        }
+      );
     }
-  }
-  return { body, title: result.title, tags: result.tags };
-}
-function collectMarkdownFiles(dir) {
-  const entries = fs$1.readdirSync(dir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const absolutePath = path$1.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectMarkdownFiles(absolutePath));
-      continue;
-    }
-    if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-      files.push(absolutePath);
-    }
-  }
-  return files;
-}
-function toSummary(absolutePath, vaultRoot) {
-  const stats = fs$1.statSync(absolutePath);
-  const relativePath = path$1.relative(vaultRoot, absolutePath).split(path$1.sep).join("/");
-  const raw = fs$1.readFileSync(absolutePath, "utf-8");
-  const parsed = parseFrontmatter(raw);
-  const headingMatch = parsed.body.match(/^#\s+(.+)$/m);
-  const title = parsed.title || headingMatch?.[1]?.trim() || path$1.basename(absolutePath, ".md");
-  return {
-    title,
-    absolutePath,
-    relativePath,
-    modifiedAt: stats.mtime.toISOString(),
-    tags: parsed.tags
-  };
-}
-function renderBookmarkLinkBlock(bookmark, note) {
-  const lines = [
-    "## Linked Bookmark",
-    "",
-    `- Bookmark ID: \`${bookmark.id}\``,
-    `- Title: ${bookmark.title || bookmark.url}`,
-    `- URL: [${bookmark.url}](${bookmark.url})`,
-    `- Saved At: ${bookmark.savedAt}`
-  ];
-  if (note?.trim()) {
-    lines.push("", "### Context", "", note.trim());
-  }
-  return `${lines.join("\n")}
-`;
-}
-function writeMemoryNote({
-  title,
-  body,
-  folder,
-  tags = [],
-  frontmatter = {}
-}) {
-  const vaultRoot = getVaultRoot();
-  const relativeFolder = normalizeFolder(folder, DEFAULT_NOTE_FOLDER);
-  const targetDir = path$1.join(vaultRoot, relativeFolder);
-  fs$1.mkdirSync(targetDir, { recursive: true });
-  const absolutePath = buildUniqueNotePath(targetDir, title);
-  const relativePath = path$1.relative(vaultRoot, absolutePath);
-  const content = [
-    renderFrontmatter({
-      title,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      tags,
-      ...frontmatter
-    }),
-    body.trim(),
-    ""
-  ].join("\n");
-  fs$1.writeFileSync(absolutePath, content, "utf-8");
-  return {
-    title,
-    absolutePath,
-    relativePath: relativePath.split(path$1.sep).join("/")
-  };
-}
-function appendToMemoryNote({
-  notePath,
-  content,
-  heading
-}) {
-  const vaultRoot = getVaultRoot();
-  const relativePath = normalizeNotePath(notePath);
-  const absolutePath = assertInsideVault(
-    path$1.join(vaultRoot, relativePath),
-    vaultRoot
   );
-  if (!fs$1.existsSync(absolutePath)) {
-    throw new Error(
-      `Memory note not found: ${relativePath.split(path$1.sep).join("/")}`
-    );
-  }
-  const current = fs$1.readFileSync(absolutePath, "utf-8").trimEnd();
-  const nextParts = [current, ""];
-  if (heading?.trim()) {
-    nextParts.push(`## ${heading.trim()}`, "");
-  }
-  nextParts.push(content.trim(), "");
-  fs$1.writeFileSync(absolutePath, nextParts.join("\n"), "utf-8");
-  return {
-    title: path$1.basename(absolutePath, ".md"),
-    absolutePath,
-    relativePath: relativePath.split(path$1.sep).join("/")
-  };
-}
-function listMemoryNotes({
-  folder,
-  limit = DEFAULT_LIST_LIMIT
-} = {}) {
-  const vaultRoot = getVaultRoot();
-  const relativeFolder = normalizeFolder(folder, "");
-  const targetDir = relativeFolder ? path$1.join(vaultRoot, relativeFolder) : vaultRoot;
-  if (!fs$1.existsSync(targetDir)) {
-    return [];
-  }
-  return collectMarkdownFiles(targetDir).map((absolutePath) => toSummary(absolutePath, vaultRoot)).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt)).slice(0, Math.max(1, limit));
-}
-function searchMemoryNotes({
-  query,
-  folder,
-  tags = [],
-  limit = DEFAULT_SEARCH_LIMIT
-}) {
-  const loweredQuery = query.trim().toLowerCase();
-  if (!loweredQuery) {
-    throw new Error("A non-empty memory search query is required.");
-  }
-  const vaultRoot = getVaultRoot();
-  const relativeFolder = normalizeFolder(folder, "");
-  const targetDir = relativeFolder ? path$1.join(vaultRoot, relativeFolder) : vaultRoot;
-  if (!fs$1.existsSync(targetDir)) {
-    return [];
-  }
-  const loweredTags = tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean);
-  return collectMarkdownFiles(targetDir).map((absolutePath) => {
-    const raw = fs$1.readFileSync(absolutePath, "utf-8");
-    const parsed = parseFrontmatter(raw);
-    const summary = toSummary(absolutePath, vaultRoot);
-    const haystack = `${summary.title}
-${summary.relativePath}
-${parsed.body}`.toLowerCase();
-    const hasQuery = haystack.includes(loweredQuery);
-    const hasTags = loweredTags.length === 0 || loweredTags.every(
-      (tag) => summary.tags.some((noteTag) => noteTag.toLowerCase() === tag)
-    );
-    return hasQuery && hasTags ? summary : null;
-  }).filter((item) => item !== null).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt)).slice(0, Math.max(1, limit));
-}
-function capturePageToVault({
-  page,
-  title,
-  folder,
-  summary,
-  note,
-  tags = []
-}) {
-  const noteTitle = title?.trim() || page.title.trim() || page.url;
-  const bodyLines = [
-    `# ${noteTitle}`,
-    "",
-    `Source: [${page.title || page.url}](${page.url})`,
-    `Captured: ${(/* @__PURE__ */ new Date()).toISOString()}`
-  ];
-  if (page.byline) {
-    bodyLines.push(`Byline: ${page.byline}`);
-  }
-  bodyLines.push("");
-  if (summary?.trim()) {
-    bodyLines.push("## Summary", "", summary.trim(), "");
-  }
-  if (note?.trim()) {
-    bodyLines.push("## Research Note", "", note.trim(), "");
-  }
-  if (page.excerpt.trim()) {
-    bodyLines.push("## Excerpt", "", page.excerpt.trim(), "");
-  }
-  const snapshot2 = trimContent(page.content);
-  if (snapshot2) {
-    bodyLines.push("## Page Snapshot", "", snapshot2, "");
-  }
-  return writeMemoryNote({
-    title: noteTitle,
-    body: bodyLines.join("\n"),
-    folder: folder || DEFAULT_PAGE_FOLDER,
-    tags,
-    frontmatter: {
-      source_url: page.url,
-      source_title: page.title || page.url
-    }
-  });
-}
-function linkBookmarkToMemory({
-  bookmark,
-  notePath,
-  title,
-  folder,
-  note,
-  tags = []
-}) {
-  if (notePath?.trim()) {
-    return appendToMemoryNote({
-      notePath,
-      heading: "Linked Bookmark",
-      content: [
-        `- Bookmark ID: \`${bookmark.id}\``,
-        `- Title: ${bookmark.title || bookmark.url}`,
-        `- URL: [${bookmark.url}](${bookmark.url})`,
-        `- Saved At: ${bookmark.savedAt}`,
-        note?.trim() ? `- Note: ${note.trim()}` : ""
-      ].filter(Boolean).join("\n")
-    });
-  }
-  const noteTitle = title?.trim() || bookmark.title || bookmark.url;
-  return writeMemoryNote({
-    title: noteTitle,
-    body: renderBookmarkLinkBlock(bookmark, note),
-    folder: folder || DEFAULT_BOOKMARK_FOLDER,
-    tags,
-    frontmatter: {
-      bookmark_id: bookmark.id,
-      source_url: bookmark.url,
-      source_title: bookmark.title || bookmark.url
-    }
-  });
-}
-function asTextResponse$1(text) {
-  return { content: [{ type: "text", text }] };
-}
-const DANGEROUS_DEVTOOLS_ACTIONS = /* @__PURE__ */ new Set([
-  "devtools_execute_js",
-  "devtools_modify_dom",
-  "devtools_set_storage"
-]);
-let stateListener = null;
-const activityLog = [];
-const MAX_ACTIVITY_ENTRIES = 100;
-let activityCounter = 0;
-function setDevToolsPanelListener(listener) {
-  stateListener = listener;
-}
-function getDevToolsPanelState(tabId) {
-  const session = tabId ? getSession(tabId) : void 0;
-  return {
-    console: session?.getConsoleLogs() ?? [],
-    network: session?.getNetworkLog() ?? [],
-    errors: session?.getErrors() ?? [],
-    activity: activityLog
-  };
-}
-function broadcastState(tabManager) {
-  if (!stateListener) return;
-  const tabId = tabManager.getActiveTabId();
-  stateListener(getDevToolsPanelState(tabId));
-}
-async function withDevToolsAction(runtime2, tabManager, name, args, executor) {
-  const activityEntry = {
-    id: ++activityCounter,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    tool: name,
-    args: JSON.stringify(args).slice(0, 200),
-    result: "",
-    durationMs: 0,
-    status: "running"
-  };
-  activityLog.push(activityEntry);
-  if (activityLog.length > MAX_ACTIVITY_ENTRIES) {
-    activityLog.splice(0, activityLog.length - MAX_ACTIVITY_ENTRIES);
-  }
-  broadcastState(tabManager);
-  const startTime = Date.now();
-  try {
-    const result = await runtime2.runControlledAction({
-      source: "mcp",
-      name,
-      args,
-      tabId: tabManager.getActiveTabId(),
-      dangerous: DANGEROUS_DEVTOOLS_ACTIONS.has(name),
-      executor
-    });
-    activityEntry.status = "completed";
-    activityEntry.result = result.slice(0, 200);
-    activityEntry.durationMs = Date.now() - startTime;
-    broadcastState(tabManager);
-    return asTextResponse$1(result);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    activityEntry.status = "failed";
-    activityEntry.result = message.slice(0, 200);
-    activityEntry.durationMs = Date.now() - startTime;
-    broadcastState(tabManager);
-    return asTextResponse$1(`Error: ${message}`);
-  }
-}
-function registerDevTools(server, tabManager, runtime2) {
   server.registerTool(
-    "vessel_devtools_console_logs",
+    "vessel_devtools_network_response_body",
     {
-      title: "DevTools: Get Console Logs",
-      description: "Get console log entries captured from the active tab. Returns a rolling buffer of recent console.log, console.warn, console.error, etc. calls. Automatically starts capturing on first use.",
+      title: "DevTools: Get Network Response Body",
+      description: "Get the response body for a specific network request by its request ID. Use vessel_devtools_network_log first to find the request ID.",
       inputSchema: {
-        level: zod.z.enum(["log", "warning", "error", "info", "debug", "verbose"]).optional().describe("Filter by log level"),
-        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)"),
-        search: zod.z.string().optional().describe("Filter entries containing this text (case-insensitive)")
+        request_id: zod.z.string().describe("The requestId from a network log entry")
       }
     },
-    async ({ level, limit, search: search2 }) => {
+    async ({ request_id }) => {
       return withDevToolsAction(
         runtime2,
         tabManager,
-        "devtools_console_logs",
-        { level, limit, search: search2 },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          await session.ensureConsoleDomain();
-          const entries = session.getConsoleLogs({ level, limit, search: search2 });
-          if (entries.length === 0) {
-            return "No console entries captured yet. Console monitoring is now active — new entries will be captured as they occur.";
-          }
-          return JSON.stringify(entries, null, 2);
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "vessel_devtools_console_clear",
-    {
-      title: "DevTools: Clear Console Logs",
-      description: "Clear the captured console log buffer for the active tab."
-    },
-    async () => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_console_clear",
-        {},
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          const count = session.clearConsoleLogs();
-          return `Cleared ${count} console entries.`;
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "vessel_devtools_network_log",
-    {
-      title: "DevTools: Get Network Log",
-      description: "Get captured network requests/responses from the active tab. Returns method, URL, status, timing, headers, and size. Automatically starts capturing on first use.",
-      inputSchema: {
-        url_pattern: zod.z.string().optional().describe("Filter by URL pattern (regex or substring match)"),
-        method: zod.z.string().optional().describe("Filter by HTTP method (GET, POST, etc.)"),
-        status_min: zod.z.number().optional().describe("Minimum HTTP status code (e.g., 400 for errors)"),
-        status_max: zod.z.number().optional().describe("Maximum HTTP status code"),
-        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)")
-      }
-    },
-    async ({ url_pattern, method, status_min, status_max, limit }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_network_log",
-        { url_pattern, method, status_min, status_max, limit },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          await session.ensureNetworkDomain();
-          const entries = session.getNetworkLog({
-            urlPattern: url_pattern,
-            method,
-            statusRange: status_min != null || status_max != null ? { min: status_min, max: status_max } : void 0,
-            limit
-          });
-          if (entries.length === 0) {
-            return "No network requests captured yet. Network monitoring is now active — new requests will be captured as they occur.";
-          }
-          return JSON.stringify(entries, null, 2);
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "vessel_devtools_network_response_body",
-    {
-      title: "DevTools: Get Network Response Body",
-      description: "Get the response body for a specific network request by its request ID. Use vessel_devtools_network_log first to find the request ID.",
-      inputSchema: {
-        request_id: zod.z.string().describe("The requestId from a network log entry")
-      }
-    },
-    async ({ request_id }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_network_response_body",
-        { request_id },
+        "devtools_network_response_body",
+        { request_id },
         async () => {
           const session = getOrCreateSession(tabManager);
           const result = await session.getNetworkResponseBody(request_id);
@@ -22914,28 +23096,403 @@ Exception: ${result.exceptionDetails}`);
           return JSON.stringify(entries, null, 2);
         }
       );
-    }
+    }
+  );
+  server.registerTool(
+    "vessel_devtools_clear_errors",
+    {
+      title: "DevTools: Clear Errors",
+      description: "Clear the captured error buffer for the active tab."
+    },
+    async () => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_clear_errors",
+        {},
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          const count = session.clearErrors();
+          return `Cleared ${count} error entries.`;
+        }
+      );
+    }
+  );
+}
+const DEFAULT_PAGE_FOLDER = "Vessel/Pages";
+const DEFAULT_NOTE_FOLDER = "Vessel/Research";
+const DEFAULT_BOOKMARK_FOLDER = "Vessel/Bookmarks";
+const PAGE_CONTENT_LIMIT = 6e3;
+const DEFAULT_LIST_LIMIT = 50;
+const DEFAULT_SEARCH_LIMIT = 20;
+const { access: access$1, mkdir: mkdir$1, readFile: readFile$1, readdir: readdir$1, stat, writeFile: writeFile$1 } = fs$1.promises;
+function getVaultRoot() {
+  const configured = loadSettings().obsidianVaultPath.trim();
+  if (!configured) {
+    throw new Error(
+      "Obsidian not configured. Set vault path in Vessel settings to use memory capture."
+    );
+  }
+  return path$1.resolve(configured);
+}
+function assertInsideVault(targetPath, vaultRoot) {
+  const resolved = path$1.resolve(targetPath);
+  const relative = path$1.relative(vaultRoot, resolved);
+  if (relative.startsWith("..") || path$1.isAbsolute(relative)) {
+    throw new Error("Resolved note path is outside the configured vault.");
+  }
+  return resolved;
+}
+function normalizeFolder(folder, fallback) {
+  const raw = (folder?.trim() || fallback).replace(/\\/g, "/");
+  if (!raw) return fallback;
+  if (path$1.isAbsolute(raw)) {
+    throw new Error("Vault note folders must be relative to the vault root.");
+  }
+  const segments = raw.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error("Vault note folders cannot traverse outside the vault.");
+  }
+  return segments.join(path$1.sep);
+}
+function normalizeNotePath(notePath) {
+  const raw = notePath.trim().replace(/\\/g, "/");
+  if (!raw) {
+    throw new Error("A note path is required.");
+  }
+  if (path$1.isAbsolute(raw)) {
+    throw new Error("Note paths must be relative to the vault root.");
+  }
+  const segments = raw.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error("Note paths cannot traverse outside the vault.");
+  }
+  const normalized = segments.join(path$1.sep);
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+function escapeYaml(value) {
+  return JSON.stringify(value);
+}
+function renderFrontmatter(data) {
+  const lines = ["---"];
+  for (const [key2, value] of Object.entries(data)) {
+    if (value == null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      lines.push(`${key2}:`);
+      for (const item of value) {
+        lines.push(`  - ${escapeYaml(item)}`);
+      }
+      continue;
+    }
+    lines.push(`${key2}: ${escapeYaml(value)}`);
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+function slugify(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "note";
+}
+async function pathExists$1(filePath2) {
+  try {
+    await access$1(filePath2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildUniqueNotePath(dir, title) {
+  const datePrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = slugify(title);
+  const base = `${datePrefix}-${slug}`;
+  let candidate = `${base}.md`;
+  let counter = 2;
+  while (await pathExists$1(path$1.join(dir, candidate))) {
+    candidate = `${base}-${counter}.md`;
+    counter += 1;
+  }
+  return path$1.join(dir, candidate);
+}
+function trimContent(content, limit = PAGE_CONTENT_LIMIT) {
+  const cleaned = content.trim();
+  if (cleaned.length <= limit) return cleaned;
+  return `${cleaned.slice(0, limit)}
+
+[Truncated]`;
+}
+function parseFrontmatter(content) {
+  if (!content.startsWith("---\n")) {
+    return { body: content, tags: [] };
+  }
+  const closingIndex = content.indexOf("\n---\n", 4);
+  if (closingIndex === -1) {
+    return { body: content, tags: [] };
+  }
+  const raw = content.slice(4, closingIndex);
+  const body = content.slice(closingIndex + 5);
+  const lines = raw.split("\n");
+  const result = { tags: [] };
+  let activeArrayKey = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("- ") && activeArrayKey === "tags") {
+      result.tags.push(
+        trimmed.slice(2).trim().replace(/^["']|["']$/g, "")
+      );
+      continue;
+    }
+    activeArrayKey = "";
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex === -1) continue;
+    const key2 = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    if (key2 === "title" && value) {
+      result.title = value.replace(/^["']|["']$/g, "");
+    } else if (key2 === "tags") {
+      activeArrayKey = "tags";
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const inline = value.slice(1, -1).split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+        result.tags.push(...inline);
+        activeArrayKey = "";
+      }
+    }
+  }
+  return { body, title: result.title, tags: result.tags };
+}
+async function collectMarkdownFiles(dir) {
+  const entries = await readdir$1(dir, { withFileTypes: true });
+  const nestedFiles = await Promise.all(
+    entries.map(async (entry) => {
+      const absolutePath = path$1.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        return collectMarkdownFiles(absolutePath);
+      }
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+        return [absolutePath];
+      }
+      return [];
+    })
+  );
+  return nestedFiles.flat();
+}
+async function toSummary(absolutePath, vaultRoot, raw) {
+  const stats = await stat(absolutePath);
+  const relativePath = path$1.relative(vaultRoot, absolutePath).split(path$1.sep).join("/");
+  const noteContent = raw ?? await readFile$1(absolutePath, "utf-8");
+  const parsed = parseFrontmatter(noteContent);
+  const headingMatch = parsed.body.match(/^#\s+(.+)$/m);
+  const title = parsed.title || headingMatch?.[1]?.trim() || path$1.basename(absolutePath, ".md");
+  return {
+    title,
+    absolutePath,
+    relativePath,
+    modifiedAt: stats.mtime.toISOString(),
+    tags: parsed.tags
+  };
+}
+function renderBookmarkLinkBlock(bookmark, note) {
+  const lines = [
+    "## Linked Bookmark",
+    "",
+    `- Bookmark ID: \`${bookmark.id}\``,
+    `- Title: ${bookmark.title || bookmark.url}`,
+    `- URL: [${bookmark.url}](${bookmark.url})`,
+    `- Saved At: ${bookmark.savedAt}`
+  ];
+  if (note?.trim()) {
+    lines.push("", "### Context", "", note.trim());
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function writeMemoryNote({
+  title,
+  body,
+  folder,
+  tags = [],
+  frontmatter = {}
+}) {
+  const vaultRoot = getVaultRoot();
+  const relativeFolder = normalizeFolder(folder, DEFAULT_NOTE_FOLDER);
+  const targetDir = path$1.join(vaultRoot, relativeFolder);
+  await mkdir$1(targetDir, { recursive: true });
+  const absolutePath = await buildUniqueNotePath(targetDir, title);
+  const relativePath = path$1.relative(vaultRoot, absolutePath);
+  const content = [
+    renderFrontmatter({
+      title,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      tags,
+      ...frontmatter
+    }),
+    body.trim(),
+    ""
+  ].join("\n");
+  await writeFile$1(absolutePath, content, "utf-8");
+  return {
+    title,
+    absolutePath,
+    relativePath: relativePath.split(path$1.sep).join("/")
+  };
+}
+async function appendToMemoryNote({
+  notePath,
+  content,
+  heading
+}) {
+  const vaultRoot = getVaultRoot();
+  const relativePath = normalizeNotePath(notePath);
+  const absolutePath = assertInsideVault(
+    path$1.join(vaultRoot, relativePath),
+    vaultRoot
+  );
+  if (!await pathExists$1(absolutePath)) {
+    throw new Error(
+      `Memory note not found: ${relativePath.split(path$1.sep).join("/")}`
+    );
+  }
+  const current = (await readFile$1(absolutePath, "utf-8")).trimEnd();
+  const nextParts = [current, ""];
+  if (heading?.trim()) {
+    nextParts.push(`## ${heading.trim()}`, "");
+  }
+  nextParts.push(content.trim(), "");
+  await writeFile$1(absolutePath, nextParts.join("\n"), "utf-8");
+  return {
+    title: path$1.basename(absolutePath, ".md"),
+    absolutePath,
+    relativePath: relativePath.split(path$1.sep).join("/")
+  };
+}
+async function listMemoryNotes({
+  folder,
+  limit = DEFAULT_LIST_LIMIT
+} = {}) {
+  const vaultRoot = getVaultRoot();
+  const relativeFolder = normalizeFolder(folder, "");
+  const targetDir = relativeFolder ? path$1.join(vaultRoot, relativeFolder) : vaultRoot;
+  if (!await pathExists$1(targetDir)) {
+    return [];
+  }
+  const notes = await Promise.all(
+    (await collectMarkdownFiles(targetDir)).map(
+      (absolutePath) => toSummary(absolutePath, vaultRoot)
+    )
+  );
+  return notes.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt)).slice(0, Math.max(1, limit));
+}
+async function searchMemoryNotes({
+  query,
+  folder,
+  tags = [],
+  limit = DEFAULT_SEARCH_LIMIT
+}) {
+  const loweredQuery = query.trim().toLowerCase();
+  if (!loweredQuery) {
+    throw new Error("A non-empty memory search query is required.");
+  }
+  const vaultRoot = getVaultRoot();
+  const relativeFolder = normalizeFolder(folder, "");
+  const targetDir = relativeFolder ? path$1.join(vaultRoot, relativeFolder) : vaultRoot;
+  if (!await pathExists$1(targetDir)) {
+    return [];
+  }
+  const loweredTags = tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+  const matches = await Promise.all(
+    (await collectMarkdownFiles(targetDir)).map(async (absolutePath) => {
+      const raw = await readFile$1(absolutePath, "utf-8");
+      const parsed = parseFrontmatter(raw);
+      const summary = await toSummary(absolutePath, vaultRoot, raw);
+      const haystack = `${summary.title}
+${summary.relativePath}
+${parsed.body}`.toLowerCase();
+      const hasQuery = haystack.includes(loweredQuery);
+      const hasTags = loweredTags.length === 0 || loweredTags.every(
+        (tag) => summary.tags.some((noteTag) => noteTag.toLowerCase() === tag)
+      );
+      return hasQuery && hasTags ? summary : null;
+    })
   );
-  server.registerTool(
-    "vessel_devtools_clear_errors",
-    {
-      title: "DevTools: Clear Errors",
-      description: "Clear the captured error buffer for the active tab."
-    },
-    async () => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_clear_errors",
-        {},
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          const count = session.clearErrors();
-          return `Cleared ${count} error entries.`;
-        }
-      );
+  return matches.filter((item) => item !== null).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt)).slice(0, Math.max(1, limit));
+}
+async function capturePageToVault({
+  page,
+  title,
+  folder,
+  summary,
+  note,
+  tags = []
+}) {
+  const noteTitle = title?.trim() || page.title.trim() || page.url;
+  const bodyLines = [
+    `# ${noteTitle}`,
+    "",
+    `Source: [${page.title || page.url}](${page.url})`,
+    `Captured: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  ];
+  if (page.byline) {
+    bodyLines.push(`Byline: ${page.byline}`);
+  }
+  bodyLines.push("");
+  if (summary?.trim()) {
+    bodyLines.push("## Summary", "", summary.trim(), "");
+  }
+  if (note?.trim()) {
+    bodyLines.push("## Research Note", "", note.trim(), "");
+  }
+  if (page.excerpt.trim()) {
+    bodyLines.push("## Excerpt", "", page.excerpt.trim(), "");
+  }
+  const snapshot2 = trimContent(page.content);
+  if (snapshot2) {
+    bodyLines.push("## Page Snapshot", "", snapshot2, "");
+  }
+  return await writeMemoryNote({
+    title: noteTitle,
+    body: bodyLines.join("\n"),
+    folder: folder || DEFAULT_PAGE_FOLDER,
+    tags,
+    frontmatter: {
+      source_url: page.url,
+      source_title: page.title || page.url
     }
-  );
+  });
+}
+async function linkBookmarkToMemory({
+  bookmark,
+  notePath,
+  title,
+  folder,
+  note,
+  tags = []
+}) {
+  if (notePath?.trim()) {
+    return await appendToMemoryNote({
+      notePath,
+      heading: "Linked Bookmark",
+      content: [
+        `- Bookmark ID: \`${bookmark.id}\``,
+        `- Title: ${bookmark.title || bookmark.url}`,
+        `- URL: [${bookmark.url}](${bookmark.url})`,
+        `- Saved At: ${bookmark.savedAt}`,
+        note?.trim() ? `- Note: ${note.trim()}` : ""
+      ].filter(Boolean).join("\n")
+    });
+  }
+  const noteTitle = title?.trim() || bookmark.title || bookmark.url;
+  return await writeMemoryNote({
+    title: noteTitle,
+    body: renderBookmarkLinkBlock(bookmark, note),
+    folder: folder || DEFAULT_BOOKMARK_FOLDER,
+    tags,
+    frontmatter: {
+      bookmark_id: bookmark.id,
+      source_url: bookmark.url,
+      source_title: bookmark.title || bookmark.url
+    }
+  });
 }
 const logger$f = createLogger("MCP");
 function asTextResponse(text) {
@@ -23016,7 +23573,7 @@ async function getPostActionState(tabManager, name) {
   if (navActions.includes(name)) {
     let warning = "";
     try {
-      const page = await extractContent$1(wc);
+      const page = await extractContent(wc);
       const issue = getRecoverableAccessIssue(page);
       if (issue) {
         const blockedUrl = wc.getURL();
@@ -23682,65 +24239,216 @@ function registerBookmarkTools(server, tabManager, runtime2) {
         summary: zod.z.string().optional().describe("Optional one-sentence summary for the folder")
       }
     },
-    async ({ folder_id, new_name, summary }) => {
+    async ({ folder_id, new_name, summary }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "rename_bookmark_folder",
+        { folder_id, new_name, summary },
+        async () => {
+          const existing = findFolderByName(new_name);
+          if (existing && existing.id !== folder_id) {
+            return composeFolderAwareResponse$1(
+              `Folder "${existing.name}" already exists (id=${existing.id})`
+            );
+          }
+          const folder = renameFolder(
+            folder_id,
+            new_name,
+            summary
+          );
+          return folder ? composeFolderAwareResponse$1(`Renamed folder to "${folder.name}"`) : `Folder ${folder_id} not found`;
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "memory_link_bookmark",
+    {
+      title: "Link Bookmark To Memory",
+      description: "Create a note for a bookmark or append bookmark details into an existing memory note.",
+      inputSchema: {
+        bookmark_id: zod.z.string().describe("Bookmark ID to link"),
+        note_path: zod.z.string().optional().describe("Existing relative note path to append into"),
+        title: zod.z.string().optional().describe("Optional title when creating a new note"),
+        folder: zod.z.string().optional().describe("Relative folder when creating a new note"),
+        note: zod.z.string().optional().describe(
+          "Optional rationale or breadcrumb to store with the bookmark"
+        ),
+        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags when creating a new note")
+      }
+    },
+    async ({ bookmark_id, note_path, title, folder, note, tags }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "memory_link_bookmark",
+        { bookmark_id, note_path, title, folder, tags },
+        async () => {
+          const bookmark = getBookmark(bookmark_id);
+          if (!bookmark) {
+            return `Bookmark ${bookmark_id} not found`;
+          }
+          const saved = await linkBookmarkToMemory({
+            bookmark,
+            notePath: note_path,
+            title,
+            folder,
+            note,
+            tags
+          });
+          return `Linked bookmark "${bookmark.title}" to memory note ${saved.relativePath}`;
+        }
+      );
+    }
+  );
+}
+function registerMemoryTools(server, tabManager, runtime2) {
+  server.registerTool(
+    "memory_note_create",
+    {
+      title: "Create Memory Note",
+      description: "Write a markdown note into the configured Obsidian vault for research notes, breadcrumbs, or synthesis.",
+      inputSchema: {
+        title: zod.z.string().describe("Title of the note"),
+        body: zod.z.string().describe("Markdown body for the note"),
+        folder: zod.z.string().optional().describe(
+          "Relative folder inside the vault (default: Vessel/Research)"
+        ),
+        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags to store in frontmatter")
+      }
+    },
+    async ({ title, body, folder, tags }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "memory_note_create",
+        { title, folder, tags },
+        async () => {
+          const saved = await writeMemoryNote({ title, body, folder, tags });
+          return `Saved memory note "${saved.title}" to ${saved.relativePath}`;
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "memory_append",
+    {
+      title: "Append Memory Note",
+      description: "Append markdown content to an existing note in the configured Obsidian vault.",
+      inputSchema: {
+        note_path: zod.z.string().describe("Relative path to an existing note inside the vault"),
+        content: zod.z.string().describe("Markdown content to append"),
+        heading: zod.z.string().optional().describe("Optional section heading to add before the content")
+      }
+    },
+    async ({ note_path, content, heading }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "memory_note_append",
+        { note_path, heading },
+        async () => {
+          const saved = await appendToMemoryNote({
+            notePath: note_path,
+            content,
+            heading
+          });
+          return `Appended memory note at ${saved.relativePath}`;
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "memory_list",
+    {
+      title: "List Memory Notes",
+      description: "List recent markdown notes in the configured Obsidian vault.",
+      inputSchema: {
+        folder: zod.z.string().optional().describe("Optional relative folder inside the vault"),
+        limit: zod.z.number().int().positive().max(200).optional().describe("Maximum number of notes to return")
+      }
+    },
+    async ({ folder, limit }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "memory_note_list",
+        { folder, limit },
+        async () => {
+          const notes = await listMemoryNotes({ folder, limit });
+          if (notes.length === 0) {
+            return "No memory notes found.";
+          }
+          return notes.map(
+            (note) => `- ${note.title} | path=${note.relativePath} | modified=${note.modifiedAt}${note.tags.length ? ` | tags=${note.tags.join(",")}` : ""}`
+          ).join("\n");
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "memory_search",
+    {
+      title: "Search Memory Notes",
+      description: "Search markdown notes in the configured Obsidian vault by title, path, body, and optional tags.",
+      inputSchema: {
+        query: zod.z.string().describe("Search query"),
+        folder: zod.z.string().optional().describe("Optional relative folder inside the vault"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags that matching notes must contain"),
+        limit: zod.z.number().int().positive().max(100).optional().describe("Maximum number of matching notes to return")
+      }
+    },
+    async ({ query, folder, tags, limit }) => {
       return withAction(
         runtime2,
         tabManager,
-        "rename_bookmark_folder",
-        { folder_id, new_name, summary },
+        "memory_note_search",
+        { query, folder, tags, limit },
         async () => {
-          const existing = findFolderByName(new_name);
-          if (existing && existing.id !== folder_id) {
-            return composeFolderAwareResponse$1(
-              `Folder "${existing.name}" already exists (id=${existing.id})`
-            );
+          const notes = await searchMemoryNotes({ query, folder, tags, limit });
+          if (notes.length === 0) {
+            return `No memory notes matched "${query}".`;
           }
-          const folder = renameFolder(
-            folder_id,
-            new_name,
-            summary
-          );
-          return folder ? composeFolderAwareResponse$1(`Renamed folder to "${folder.name}"`) : `Folder ${folder_id} not found`;
+          return notes.map(
+            (note) => `- ${note.title} | path=${note.relativePath} | modified=${note.modifiedAt}${note.tags.length ? ` | tags=${note.tags.join(",")}` : ""}`
+          ).join("\n");
         }
       );
     }
   );
   server.registerTool(
-    "memory_link_bookmark",
+    "memory_page_capture",
     {
-      title: "Link Bookmark To Memory",
-      description: "Create a note for a bookmark or append bookmark details into an existing memory note.",
+      title: "Capture Page To Memory",
+      description: "Capture the current page into the configured Obsidian vault as a markdown note with URL, excerpt, and content snapshot.",
       inputSchema: {
-        bookmark_id: zod.z.string().describe("Bookmark ID to link"),
-        note_path: zod.z.string().optional().describe("Existing relative note path to append into"),
-        title: zod.z.string().optional().describe("Optional title when creating a new note"),
-        folder: zod.z.string().optional().describe("Relative folder when creating a new note"),
-        note: zod.z.string().optional().describe(
-          "Optional rationale or breadcrumb to store with the bookmark"
-        ),
-        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags when creating a new note")
+        title: zod.z.string().optional().describe("Optional note title override"),
+        folder: zod.z.string().optional().describe("Relative folder inside the vault (default: Vessel/Pages)"),
+        summary: zod.z.string().optional().describe("Optional summary written into the note"),
+        note: zod.z.string().optional().describe("Optional research note or breadcrumb"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags to store in frontmatter")
       }
     },
-    async ({ bookmark_id, note_path, title, folder, note, tags }) => {
+    async ({ title, folder, summary, note, tags }) => {
+      const tab = tabManager.getActiveTab();
+      if (!tab) return asNoActiveTabResponse();
       return withAction(
         runtime2,
         tabManager,
-        "memory_link_bookmark",
-        { bookmark_id, note_path, title, folder, tags },
+        "memory_page_capture",
+        { title, folder, tags },
         async () => {
-          const bookmark = getBookmark(bookmark_id);
-          if (!bookmark) {
-            return `Bookmark ${bookmark_id} not found`;
-          }
-          const saved = linkBookmarkToMemory({
-            bookmark,
-            notePath: note_path,
+          const page = await extractContent(tab.view.webContents);
+          const saved = await capturePageToVault({
+            page,
             title,
             folder,
+            summary,
             note,
             tags
           });
-          return `Linked bookmark "${bookmark.title}" to memory note ${saved.relativePath}`;
+          return `Captured page "${saved.title}" to ${saved.relativePath}`;
         }
       );
     }
@@ -24498,7 +25206,7 @@ function registerTools(server, tabManager, runtime2) {
           const wc = activeTab.view.webContents;
           pageUrl = wc.getURL();
           pageTitle = wc.getTitle();
-          const page = await extractContent$1(wc);
+          const page = await extractContent(wc);
           pageType = detectPageType(page);
         } catch (err) {
           logger$b.warn("Failed to detect page type for tool scoring, falling back to GENERAL:", err);
@@ -24664,7 +25372,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const effectiveMode = mode || "full";
         return asTextResponse(
           await buildExtractResponse(
@@ -24696,7 +25404,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const effectiveMode = mode || "full";
         return asTextResponse(
           await buildExtractResponse(
@@ -24831,7 +25539,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const requestedType = typeof type === "string" && type.trim() ? type.trim().toLowerCase() : "";
         const entities = (pageContent.structuredData ?? []).filter(
           (entity) => requestedType ? entity.types.some(
@@ -25805,155 +26513,7 @@ ${JSON.stringify(otherHighlights, null, 2)}`
   );
   registerBookmarkTools(server, tabManager, runtime2);
   registerSessionTools(server, tabManager, runtime2);
-  server.registerTool(
-    "memory_note_create",
-    {
-      title: "Create Memory Note",
-      description: "Write a markdown note into the configured Obsidian vault for research notes, breadcrumbs, or synthesis.",
-      inputSchema: {
-        title: zod.z.string().describe("Title of the note"),
-        body: zod.z.string().describe("Markdown body for the note"),
-        folder: zod.z.string().optional().describe(
-          "Relative folder inside the vault (default: Vessel/Research)"
-        ),
-        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags to store in frontmatter")
-      }
-    },
-    async ({ title, body, folder, tags }) => {
-      return withAction(
-        runtime2,
-        tabManager,
-        "memory_note_create",
-        { title, folder, tags },
-        async () => {
-          const saved = writeMemoryNote({ title, body, folder, tags });
-          return `Saved memory note "${saved.title}" to ${saved.relativePath}`;
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "memory_append",
-    {
-      title: "Append Memory Note",
-      description: "Append markdown content to an existing note in the configured Obsidian vault.",
-      inputSchema: {
-        note_path: zod.z.string().describe("Relative path to an existing note inside the vault"),
-        content: zod.z.string().describe("Markdown content to append"),
-        heading: zod.z.string().optional().describe("Optional section heading to add before the content")
-      }
-    },
-    async ({ note_path, content, heading }) => {
-      return withAction(
-        runtime2,
-        tabManager,
-        "memory_note_append",
-        { note_path, heading },
-        async () => {
-          const saved = appendToMemoryNote({
-            notePath: note_path,
-            content,
-            heading
-          });
-          return `Appended memory note at ${saved.relativePath}`;
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "memory_list",
-    {
-      title: "List Memory Notes",
-      description: "List recent markdown notes in the configured Obsidian vault.",
-      inputSchema: {
-        folder: zod.z.string().optional().describe("Optional relative folder inside the vault"),
-        limit: zod.z.number().int().positive().max(200).optional().describe("Maximum number of notes to return")
-      }
-    },
-    async ({ folder, limit }) => {
-      return withAction(
-        runtime2,
-        tabManager,
-        "memory_note_list",
-        { folder, limit },
-        async () => {
-          const notes = listMemoryNotes({ folder, limit });
-          if (notes.length === 0) {
-            return "No memory notes found.";
-          }
-          return notes.map(
-            (note) => `- ${note.title} | path=${note.relativePath} | modified=${note.modifiedAt}${note.tags.length ? ` | tags=${note.tags.join(",")}` : ""}`
-          ).join("\n");
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "memory_search",
-    {
-      title: "Search Memory Notes",
-      description: "Search markdown notes in the configured Obsidian vault by title, path, body, and optional tags.",
-      inputSchema: {
-        query: zod.z.string().describe("Search query"),
-        folder: zod.z.string().optional().describe("Optional relative folder inside the vault"),
-        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags that matching notes must contain"),
-        limit: zod.z.number().int().positive().max(100).optional().describe("Maximum number of matching notes to return")
-      }
-    },
-    async ({ query, folder, tags, limit }) => {
-      return withAction(
-        runtime2,
-        tabManager,
-        "memory_note_search",
-        { query, folder, tags, limit },
-        async () => {
-          const notes = searchMemoryNotes({ query, folder, tags, limit });
-          if (notes.length === 0) {
-            return `No memory notes matched "${query}".`;
-          }
-          return notes.map(
-            (note) => `- ${note.title} | path=${note.relativePath} | modified=${note.modifiedAt}${note.tags.length ? ` | tags=${note.tags.join(",")}` : ""}`
-          ).join("\n");
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "memory_page_capture",
-    {
-      title: "Capture Page To Memory",
-      description: "Capture the current page into the configured Obsidian vault as a markdown note with URL, excerpt, and content snapshot.",
-      inputSchema: {
-        title: zod.z.string().optional().describe("Optional note title override"),
-        folder: zod.z.string().optional().describe("Relative folder inside the vault (default: Vessel/Pages)"),
-        summary: zod.z.string().optional().describe("Optional summary written into the note"),
-        note: zod.z.string().optional().describe("Optional research note or breadcrumb"),
-        tags: zod.z.array(zod.z.string()).optional().describe("Optional tags to store in frontmatter")
-      }
-    },
-    async ({ title, folder, summary, note, tags }) => {
-      const tab = tabManager.getActiveTab();
-      if (!tab) return asNoActiveTabResponse();
-      return withAction(
-        runtime2,
-        tabManager,
-        "memory_page_capture",
-        { title, folder, tags },
-        async () => {
-          const page = await extractContent$1(tab.view.webContents);
-          const saved = capturePageToVault({
-            page,
-            title,
-            folder,
-            summary,
-            note,
-            tags
-          });
-          return `Captured page "${saved.title}" to ${saved.relativePath}`;
-        }
-      );
-    }
-  );
+  registerMemoryTools(server, tabManager, runtime2);
   server.registerTool(
     "flow_start",
     {
@@ -26061,7 +26621,7 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
       const wc = tab.view.webContents;
       let page;
       try {
-        page = await extractContent$1(wc);
+        page = await extractContent(wc);
       } catch (err) {
         logger$b.warn("Failed to extract page while generating suggestions:", err);
         return asTextResponse(
@@ -27622,25 +28182,27 @@ const VALID_KIT_CATEGORIES = /* @__PURE__ */ new Set([
   "productivity",
   "forms"
 ]);
-const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set([
-  "research-collect",
-  "price-scout",
-  "form-filler"
-]);
+const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set();
 const KIT_ID_UNSAFE_CHAR_PATTERN = /[/\\\0]/;
 function isSafeAutomationKitId(id) {
   return id.length > 0 && !KIT_ID_UNSAFE_CHAR_PATTERN.test(id);
 }
 const logger$9 = createLogger("KitRegistry");
+const { access, mkdir, readFile, readdir, unlink, writeFile } = fs$1.promises;
 function getUserKitsDir() {
   return path$1.join(electron.app.getPath("userData"), "kits");
 }
-function ensureKitsDir() {
-  const dir = getUserKitsDir();
-  if (!fs$1.existsSync(dir)) {
-    fs$1.mkdirSync(dir, { recursive: true });
+async function pathExists(filePath2) {
+  try {
+    await access(filePath2);
+    return true;
+  } catch {
+    return false;
   }
 }
+async function ensureKitsDir() {
+  await mkdir(getUserKitsDir(), { recursive: true });
+}
 function getKitFilePath(id) {
   if (!isSafeAutomationKitId(id)) return null;
   const kitsDir = path$1.resolve(getUserKitsDir());
@@ -27652,12 +28214,12 @@ function isValidKit(value) {
   const k = value;
   return typeof k.id === "string" && isSafeAutomationKitId(k.id) && typeof k.name === "string" && k.name.length > 0 && typeof k.description === "string" && typeof k.category === "string" && VALID_KIT_CATEGORIES.has(k.category) && typeof k.icon === "string" && typeof k.promptTemplate === "string" && k.promptTemplate.length > 0 && Array.isArray(k.inputs);
 }
-function getInstalledKits() {
-  ensureKitsDir();
+async function getInstalledKits() {
+  await ensureKitsDir();
   const dir = getUserKitsDir();
   let files;
   try {
-    files = fs$1.readdirSync(dir).filter((f) => f.endsWith(".kit.json"));
+    files = (await readdir(dir)).filter((f) => f.endsWith(".kit.json"));
   } catch (err) {
     logger$9.warn("Failed to read kit directory:", err);
     return [];
@@ -27665,23 +28227,23 @@ function getInstalledKits() {
   const kits = [];
   for (const file of files) {
     try {
-      const raw = fs$1.readFileSync(path$1.join(dir, file), "utf-8");
+      const raw = await readFile(path$1.join(dir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (isValidKit(parsed)) {
         kits.push(parsed);
       } else {
-        logger$9.warn(`Skipping invalid kit file: ${file}`);
+        logger$9.warn(`Skipping invalid skill file: ${file}`);
       }
     } catch (err) {
-      logger$9.warn(`Failed to read kit file: ${file}`, err);
+      logger$9.warn(`Failed to read skill file: ${file}`, err);
     }
   }
   return kits;
 }
 async function installKitFromFile() {
   const { canceled, filePaths } = await electron.dialog.showOpenDialog({
-    title: "Install Automation Kit",
-    filters: [{ name: "Automation Kit", extensions: ["kit.json", "json"] }],
+    title: "Import Skill",
+    filters: [{ name: "Skills", extensions: ["skill.json", "json"] }],
     properties: ["openFile"]
   });
   if (canceled || filePaths.length === 0) {
@@ -27689,64 +28251,130 @@ async function installKitFromFile() {
   }
   let raw;
   try {
-    raw = fs$1.readFileSync(filePaths[0], "utf-8");
+    raw = await readFile(filePaths[0], "utf-8");
   } catch (err) {
-    logger$9.warn("Failed to read selected kit file:", err);
+    logger$9.warn("Failed to read selected skill file:", err);
     return errorResult("Could not read the selected file.");
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    logger$9.warn("Selected kit file is not valid JSON:", err);
+    logger$9.warn("Selected skill file is not valid JSON:", err);
     return errorResult("File is not valid JSON.");
   }
   if (!isValidKit(parsed)) {
     return errorResult(
-      "File is not a valid automation kit. Required fields: id, name, description, icon, inputs, promptTemplate."
+      "File is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
+    );
+  }
+  if (BUNDLED_KIT_IDS.has(parsed.id)) {
+    return errorResult(
+      `Skill id "${parsed.id}" conflicts with a built-in skill and cannot be overwritten.`
+    );
+  }
+  await ensureKitsDir();
+  const dest = getKitFilePath(parsed.id);
+  if (!dest) {
+    return errorResult("Skill id contains unsupported characters.");
+  }
+  try {
+    await writeFile(dest, JSON.stringify(parsed, null, 2), "utf-8");
+  } catch (err) {
+    logger$9.warn("Failed to save skill file:", err);
+    return errorResult("Failed to save the skill file.");
+  }
+  return okResult({ kit: parsed });
+}
+async function createKitFromText(source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    logger$9.warn("Created skill text is not valid JSON:", err);
+    return errorResult("Skill text is not valid JSON.");
+  }
+  if (!isValidKit(parsed)) {
+    return errorResult(
+      "Text is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
     );
   }
   if (BUNDLED_KIT_IDS.has(parsed.id)) {
     return errorResult(
-      `Kit id "${parsed.id}" conflicts with a built-in kit and cannot be overwritten.`
+      `Skill id "${parsed.id}" conflicts with a built-in skill and cannot be overwritten.`
     );
   }
-  ensureKitsDir();
+  await ensureKitsDir();
   const dest = getKitFilePath(parsed.id);
   if (!dest) {
-    return errorResult("Kit id contains unsupported characters.");
+    return errorResult("Skill id contains unsupported characters.");
+  }
+  try {
+    await writeFile(dest, JSON.stringify(parsed, null, 2), "utf-8");
+  } catch (err) {
+    logger$9.warn("Failed to save created skill:", err);
+    return errorResult("Failed to save the skill.");
+  }
+  return okResult({ kit: parsed });
+}
+async function updateKitFromText(id, source) {
+  if (BUNDLED_KIT_IDS.has(id)) {
+    return errorResult("Built-in skills cannot be edited.");
+  }
+  const target = getKitFilePath(id);
+  if (!target) {
+    return errorResult("Skill id contains unsupported characters.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    logger$9.warn("Updated skill text is not valid JSON:", err);
+    return errorResult("Skill text is not valid JSON.");
+  }
+  if (!isValidKit(parsed)) {
+    return errorResult(
+      "Text is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
+    );
+  }
+  if (parsed.id !== id) {
+    return errorResult("Skill id cannot be changed while editing.");
+  }
+  await ensureKitsDir();
+  if (!await pathExists(target)) {
+    return errorResult("Skill not found.");
   }
   try {
-    fs$1.writeFileSync(dest, JSON.stringify(parsed, null, 2), "utf-8");
+    await writeFile(target, JSON.stringify(parsed, null, 2), "utf-8");
   } catch (err) {
-    logger$9.warn("Failed to save kit file:", err);
-    return errorResult("Failed to save the kit file.");
+    logger$9.warn("Failed to update skill:", err);
+    return errorResult("Failed to update the skill.");
   }
   return okResult({ kit: parsed });
 }
-function uninstallKit(id, scheduledKitIds) {
+async function uninstallKit(id, scheduledKitIds) {
   if (BUNDLED_KIT_IDS.has(id)) {
-    return errorResult("Built-in kits cannot be removed.");
+    return errorResult("Built-in skills cannot be removed.");
   }
   if (scheduledKitIds?.has(id)) {
     return errorResult(
-      "This kit has active scheduled jobs. Delete or reassign them first."
+      "This skill has active scheduled jobs. Delete or reassign them first."
     );
   }
-  ensureKitsDir();
+  await ensureKitsDir();
   const target = getKitFilePath(id);
   if (!target) {
-    return errorResult("Kit id contains unsupported characters.");
+    return errorResult("Skill id contains unsupported characters.");
   }
-  if (!fs$1.existsSync(target)) {
-    return errorResult("Kit not found.");
+  if (!await pathExists(target)) {
+    return errorResult("Skill not found.");
   }
   try {
-    fs$1.unlinkSync(target);
+    await unlink(target);
     return okResult();
   } catch (err) {
-    logger$9.warn("Failed to remove kit file:", err);
-    return errorResult("Failed to remove the kit file.");
+    logger$9.warn("Failed to remove skill file:", err);
+    return errorResult("Failed to remove the skill file.");
   }
 }
 const logger$8 = createLogger("Scheduler");
@@ -27931,7 +28559,7 @@ async function fireJob(job, windowState2, runtime2) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : "Unknown error";
     appendActivity(`
-[Scheduled Kit Error: ${msg}]`);
+[Scheduled Skill Error: ${msg}]`);
     finishActivity("failed");
   }
 }
@@ -27989,10 +28617,12 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   }, msToNextMinute);
   electron.ipcMain.handle(Channels.SCHEDULE_GET_ALL, (event) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return jobs;
   });
   electron.ipcMain.handle(Channels.SCHEDULE_CREATE, (event, rawJob) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (!isValidJobData(rawJob)) {
       throw new Error(
         "Invalid job data. Required: kitId, kitName, kitIcon, renderedPrompt, schedule, enabled."
@@ -28011,6 +28641,7 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   });
   electron.ipcMain.handle(Channels.SCHEDULE_UPDATE, (event, id, updates) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (typeof id !== "string") throw new Error("id must be a string");
     const job = jobs.find((j) => j.id === id);
     if (!job) return null;
@@ -28038,6 +28669,7 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   });
   electron.ipcMain.handle(Channels.SCHEDULE_DELETE, (event, id) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (typeof id !== "string") throw new Error("id must be a string");
     const before = jobs.length;
     jobs = jobs.filter((j) => j.id !== id);
@@ -28062,6 +28694,7 @@ function stopScheduler() {
   }
 }
 const KitIdSchema = zod.z.string().min(1);
+const SkillSourceSchema = zod.z.string().min(1).max(1e5);
 const OriginSchema = zod.z.string().min(1);
 function registerSystemHandlers(windowState2, sendToRendererViews) {
   const { tabManager } = windowState2;
@@ -28078,17 +28711,38 @@ function registerSystemHandlers(windowState2, sendToRendererViews) {
     layoutViews(windowState2);
     return clamped;
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, (event) => {
+  electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, async (event) => {
     assertTrustedIpcSender(event);
-    return getInstalledKits();
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await getInstalledKits();
   });
   electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return await installKitFromFile();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (event, id) => {
+  electron.ipcMain.handle(Channels.AUTOMATION_CREATE_FROM_TEXT, async (event, source) => {
+    assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await createKitFromText(
+      parseIpc(SkillSourceSchema, source, "source")
+    );
+  });
+  electron.ipcMain.handle(Channels.AUTOMATION_UPDATE_FROM_TEXT, async (event, id, source) => {
     assertTrustedIpcSender(event);
-    return uninstallKit(parseIpc(KitIdSchema, id, "id"), getScheduledKitIds());
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await updateKitFromText(
+      parseIpc(KitIdSchema, id, "id"),
+      parseIpc(SkillSourceSchema, source, "source")
+    );
+  });
+  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, async (event, id) => {
+    assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await uninstallKit(
+      parseIpc(KitIdSchema, id, "id"),
+      getScheduledKitIds()
+    );
   });
   electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (event, options) => {
     assertTrustedIpcSender(event);
@@ -29547,7 +30201,7 @@ function registerAutofillHandlers(windowState2) {
     const activeTab = windowState2.tabManager.getActiveTab();
     const wc = activeTab?.view.webContents;
     if (!wc) throw new Error("No active tab");
-    const content = await extractContent$1(wc);
+    const content = await extractContent(wc);
     const elements = content.interactiveElements || [];
     const matches = matchFields(elements, profile);
     if (matches.length === 0) {