@quanta-intellect/vessel-browser 0.1.136 → 0.1.137

package/out/main/index.js

@@ -22147,492 +22147,135 @@ 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.");
-  }
-  if (path$1.isAbsolute(raw)) {
-    throw new Error("Note paths must be relative to the vault root.");
+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);
   }
-  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 = "";
-      }
-    }
-  }
-  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",
-    {
-      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)")
-      }
-    },
-    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);
-        }
-      );
-    }
-  );
-  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)")
+  );
+  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 }) => {
@@ -22788,154 +22431,529 @@ function registerDevTools(server, tabManager, runtime2) {
         }
       );
     }
-  );
-  server.registerTool(
-    "vessel_devtools_execute_js",
-    {
-      title: "DevTools: Execute JavaScript",
-      description: "Execute a JavaScript expression in the context of the active tab's page via the Runtime.evaluate CDP method. Supports async/await. This is a dangerous action — it can modify page state.",
-      inputSchema: {
-        expression: zod.z.string().describe("JavaScript expression to evaluate in the page context")
+  );
+  server.registerTool(
+    "vessel_devtools_execute_js",
+    {
+      title: "DevTools: Execute JavaScript",
+      description: "Execute a JavaScript expression in the context of the active tab's page via the Runtime.evaluate CDP method. Supports async/await. This is a dangerous action — it can modify page state.",
+      inputSchema: {
+        expression: zod.z.string().describe("JavaScript expression to evaluate in the page context")
+      }
+    },
+    async ({ expression }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_execute_js",
+        { expression: expression.slice(0, 200) },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          const result = await session.executeJs(expression);
+          const parts = [`[${result.type}] ${result.result}`];
+          if (result.exceptionDetails) {
+            parts.push(`
+Exception: ${result.exceptionDetails}`);
+          }
+          return parts.join("");
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "vessel_devtools_get_storage",
+    {
+      title: "DevTools: Get Storage",
+      description: "Read browser storage for the active tab's origin. Supports localStorage, sessionStorage, cookies, and IndexedDB database listing.",
+      inputSchema: {
+        type: zod.z.enum(["localStorage", "sessionStorage", "cookie", "indexedDB"]).describe("Storage type to read")
+      }
+    },
+    async ({ type }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_get_storage",
+        { type },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          const data = await session.getStorage(type);
+          const count = Object.keys(data.entries).length;
+          if (count === 0) {
+            return `No ${type} entries found for ${data.origin}`;
+          }
+          return JSON.stringify(data, null, 2);
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "vessel_devtools_set_storage",
+    {
+      title: "DevTools: Set Storage",
+      description: "Set or remove a key in localStorage or sessionStorage for the active tab. This is a dangerous action that modifies page state.",
+      inputSchema: {
+        type: zod.z.enum(["localStorage", "sessionStorage"]).describe("Storage type to modify"),
+        key: zod.z.string().describe("Storage key"),
+        value: zod.z.string().nullable().describe("Value to set, or null to remove the key")
+      }
+    },
+    async ({ type, key: key2, value }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_set_storage",
+        { type, key: key2, value: value ? value.slice(0, 100) : null },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          return session.setStorage(type, key2, value);
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "vessel_devtools_performance",
+    {
+      title: "DevTools: Performance Snapshot",
+      description: "Get a performance snapshot for the active tab including navigation timing, paint metrics, memory usage, and resource loading statistics."
+    },
+    async () => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_performance",
+        {},
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          const snapshot2 = await session.getPerformanceSnapshot();
+          return JSON.stringify(snapshot2, null, 2);
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "vessel_devtools_get_errors",
+    {
+      title: "DevTools: Get Errors",
+      description: "Get captured JavaScript errors and unhandled promise rejections from the active tab. Automatically starts capturing on first use.",
+      inputSchema: {
+        type: zod.z.enum(["exception", "unhandled-rejection"]).optional().describe("Filter by error type"),
+        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)")
+      }
+    },
+    async ({ type, limit }) => {
+      return withDevToolsAction(
+        runtime2,
+        tabManager,
+        "devtools_get_errors",
+        { type, limit },
+        async () => {
+          const session = getOrCreateSession(tabManager);
+          await session.ensureErrorCapture();
+          const entries = session.getErrors({ type, limit });
+          if (entries.length === 0) {
+            return "No errors captured yet. Error monitoring is now active — exceptions and unhandled rejections will be captured as they occur.";
+          }
+          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 = "";
       }
-    },
-    async ({ expression }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_execute_js",
-        { expression: expression.slice(0, 200) },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          const result = await session.executeJs(expression);
-          const parts = [`[${result.type}] ${result.result}`];
-          if (result.exceptionDetails) {
-            parts.push(`
-Exception: ${result.exceptionDetails}`);
-          }
-          return parts.join("");
-        }
-      );
     }
-  );
-  server.registerTool(
-    "vessel_devtools_get_storage",
-    {
-      title: "DevTools: Get Storage",
-      description: "Read browser storage for the active tab's origin. Supports localStorage, sessionStorage, cookies, and IndexedDB database listing.",
-      inputSchema: {
-        type: zod.z.enum(["localStorage", "sessionStorage", "cookie", "indexedDB"]).describe("Storage type to read")
+  }
+  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);
       }
-    },
-    async ({ type }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_get_storage",
-        { type },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          const data = await session.getStorage(type);
-          const count = Object.keys(data.entries).length;
-          if (count === 0) {
-            return `No ${type} entries found for ${data.origin}`;
-          }
-          return JSON.stringify(data, null, 2);
-        }
-      );
-    }
-  );
-  server.registerTool(
-    "vessel_devtools_set_storage",
-    {
-      title: "DevTools: Set Storage",
-      description: "Set or remove a key in localStorage or sessionStorage for the active tab. This is a dangerous action that modifies page state.",
-      inputSchema: {
-        type: zod.z.enum(["localStorage", "sessionStorage"]).describe("Storage type to modify"),
-        key: zod.z.string().describe("Storage key"),
-        value: zod.z.string().nullable().describe("Value to set, or null to remove the key")
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+        return [absolutePath];
       }
-    },
-    async ({ type, key: key2, value }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_set_storage",
-        { type, key: key2, value: value ? value.slice(0, 100) : null },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          return session.setStorage(type, key2, value);
-        }
-      );
-    }
+      return [];
+    })
   );
-  server.registerTool(
-    "vessel_devtools_performance",
-    {
-      title: "DevTools: Performance Snapshot",
-      description: "Get a performance snapshot for the active tab including navigation timing, paint metrics, memory usage, and resource loading statistics."
-    },
-    async () => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_performance",
-        {},
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          const snapshot2 = await session.getPerformanceSnapshot();
-          return JSON.stringify(snapshot2, null, 2);
-        }
-      );
-    }
+  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
   );
-  server.registerTool(
-    "vessel_devtools_get_errors",
-    {
-      title: "DevTools: Get Errors",
-      description: "Get captured JavaScript errors and unhandled promise rejections from the active tab. Automatically starts capturing on first use.",
-      inputSchema: {
-        type: zod.z.enum(["exception", "unhandled-rejection"]).optional().describe("Filter by error type"),
-        limit: zod.z.number().optional().describe("Maximum number of entries to return (default: all)")
-      }
-    },
-    async ({ type, limit }) => {
-      return withDevToolsAction(
-        runtime2,
-        tabManager,
-        "devtools_get_errors",
-        { type, limit },
-        async () => {
-          const session = getOrCreateSession(tabManager);
-          await session.ensureErrorCapture();
-          const entries = session.getErrors({ type, limit });
-          if (entries.length === 0) {
-            return "No errors captured yet. Error monitoring is now active — exceptions and unhandled rejections will be captured as they occur.";
-          }
-          return JSON.stringify(entries, null, 2);
-        }
+  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) {
@@ -23641,106 +23659,257 @@ function registerBookmarkTools(server, tabManager, runtime2) {
     }
   );
   server.registerTool(
-    "folder_remove",
+    "folder_remove",
+    {
+      title: "Remove Bookmark Folder",
+      description: "Remove a folder. By default bookmarks in it are moved to Unsorted. Set delete_contents to true to delete them with the folder.",
+      inputSchema: {
+        folder_id: zod.z.string().describe("ID of the folder to remove"),
+        delete_contents: zod.z.boolean().optional().default(false).describe(
+          "If true, delete all bookmarks in the folder. If false (default), move them to Unsorted."
+        )
+      }
+    },
+    async ({ folder_id, delete_contents }) => {
+      return withAction(
+        runtime2,
+        tabManager,
+        "remove_bookmark_folder",
+        { folder_id, delete_contents },
+        async () => {
+          const removed = removeFolder(
+            folder_id,
+            delete_contents
+          );
+          if (!removed) return `Folder ${folder_id} not found`;
+          return composeFolderAwareResponse$1(
+            delete_contents ? `Removed folder ${folder_id} and deleted its bookmarks.` : `Removed folder ${folder_id}. Bookmarks moved to Unsorted.`
+          );
+        }
+      );
+    }
+  );
+  server.registerTool(
+    "folder_rename",
+    {
+      title: "Rename Bookmark Folder",
+      description: "Rename an existing bookmark folder.",
+      inputSchema: {
+        folder_id: zod.z.string().describe("ID of the folder to rename"),
+        new_name: zod.z.string().describe("New name for the folder"),
+        summary: zod.z.string().optional().describe("Optional one-sentence summary for the folder")
+      }
+    },
+    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: "Remove Bookmark Folder",
-      description: "Remove a folder. By default bookmarks in it are moved to Unsorted. Set delete_contents to true to delete them with the folder.",
+      title: "List Memory Notes",
+      description: "List recent markdown notes in the configured Obsidian vault.",
       inputSchema: {
-        folder_id: zod.z.string().describe("ID of the folder to remove"),
-        delete_contents: zod.z.boolean().optional().default(false).describe(
-          "If true, delete all bookmarks in the folder. If false (default), move them to Unsorted."
-        )
+        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_id, delete_contents }) => {
+    async ({ folder, limit }) => {
       return withAction(
         runtime2,
         tabManager,
-        "remove_bookmark_folder",
-        { folder_id, delete_contents },
+        "memory_note_list",
+        { folder, limit },
         async () => {
-          const removed = removeFolder(
-            folder_id,
-            delete_contents
-          );
-          if (!removed) return `Folder ${folder_id} not found`;
-          return composeFolderAwareResponse$1(
-            delete_contents ? `Removed folder ${folder_id} and deleted its bookmarks.` : `Removed folder ${folder_id}. Bookmarks moved to Unsorted.`
-          );
+          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(
-    "folder_rename",
+    "memory_search",
     {
-      title: "Rename Bookmark Folder",
-      description: "Rename an existing bookmark folder.",
+      title: "Search Memory Notes",
+      description: "Search markdown notes in the configured Obsidian vault by title, path, body, and optional tags.",
       inputSchema: {
-        folder_id: zod.z.string().describe("ID of the folder to rename"),
-        new_name: zod.z.string().describe("New name for the folder"),
-        summary: zod.z.string().optional().describe("Optional one-sentence summary for the folder")
+        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 ({ folder_id, new_name, summary }) => {
+    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$1(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}`;
         }
       );
     }
@@ -25805,155 +25974,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",
     {
@@ -27632,15 +27653,21 @@ 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 +27679,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,7 +27692,7 @@ 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);
@@ -27689,7 +27716,7 @@ 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);
     return errorResult("Could not read the selected file.");
@@ -27711,20 +27738,20 @@ async function installKitFromFile() {
       `Kit id "${parsed.id}" conflicts with a built-in kit and cannot be overwritten.`
     );
   }
-  ensureKitsDir();
+  await ensureKitsDir();
   const dest = getKitFilePath(parsed.id);
   if (!dest) {
     return errorResult("Kit id contains unsupported characters.");
   }
   try {
-    fs$1.writeFileSync(dest, JSON.stringify(parsed, null, 2), "utf-8");
+    await writeFile(dest, 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.");
   }
   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.");
   }
@@ -27733,16 +27760,16 @@ function uninstallKit(id, scheduledKitIds) {
       "This kit 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.");
   }
-  if (!fs$1.existsSync(target)) {
+  if (!await pathExists(target)) {
     return errorResult("Kit not found.");
   }
   try {
-    fs$1.unlinkSync(target);
+    await unlink(target);
     return okResult();
   } catch (err) {
     logger$9.warn("Failed to remove kit file:", err);
@@ -28078,17 +28105,20 @@ 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();
+    return await getInstalledKits();
   });
   electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
     assertTrustedIpcSender(event);
     return await installKitFromFile();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (event, id) => {
+  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, async (event, id) => {
     assertTrustedIpcSender(event);
-    return uninstallKit(parseIpc(KitIdSchema, id, "id"), getScheduledKitIds());
+    return await uninstallKit(
+      parseIpc(KitIdSchema, id, "id"),
+      getScheduledKitIds()
+    );
   });
   electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (event, options) => {
     assertTrustedIpcSender(event);