@lotargo/memory_plugin 1.6.5 → 1.6.7

package/mcp-server/cli_boot.js

@@ -32,6 +32,9 @@ if (major < MIN_MAJOR || (major === MIN_MAJOR && minor < MIN_MINOR)) {
 // Version is OK — hand off to the real CLI.
 import("./cli.js").then(m => {
   if (process.argv[1] && process.argv[1].includes("cli_boot.js")) {
-    m.runCli().catch((err) => console.error("CLI error:", err));
+    m.runCli().catch((err) => {
+      console.error("CLI error:", err);
+      process.exitCode = 1;
+    });
   }
 });

package/mcp-server/client_cli.js

@@ -0,0 +1,73 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, extname, join } from "node:path";
+
+function envValue(env, name) {
+  if (Object.prototype.hasOwnProperty.call(env || {}, name)) return env[name];
+  const key = Object.keys(env || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
+}
+
+export function resolveClientExecutable(name, {
+  env = process.env,
+  platform = process.platform,
+} = {}) {
+  if (String(env.MEMORY_PLUGIN_DISABLE_NATIVE_CLI || "") === "1") return null;
+  const pathValue = envValue(env, "PATH") || "";
+  const directories = pathValue.split(delimiter).filter(Boolean);
+  const extensions = platform === "win32"
+    ? (envValue(env, "PATHEXT") || ".EXE;.COM;.CMD;.BAT").split(";").filter(Boolean)
+    : [""];
+
+  for (const directory of directories) {
+    const base = join(directory, name);
+    const candidates = platform === "win32" && extname(base)
+      ? [base]
+      : extensions.map((extension) => `${base}${extension.toLowerCase()}`)
+        .concat(extensions.map((extension) => `${base}${extension.toUpperCase()}`));
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+export function runClientCli(name, args, {
+  cwd = process.cwd(),
+  env = process.env,
+  platform = process.platform,
+  timeout = 20_000,
+} = {}) {
+  const executable = resolveClientExecutable(name, { env, platform });
+  if (!executable) {
+    return { available: false, ok: false, status: null, executable: null, stdout: "", stderr: "" };
+  }
+
+  const isWindowsShim = platform === "win32" && /\.(?:cmd|bat)$/i.test(executable);
+  const command = isWindowsShim ? (envValue(env, "ComSpec") || "cmd.exe") : executable;
+  const commandArgs = isWindowsShim ? ["/d", "/s", "/c", executable, ...args] : args;
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    env,
+    encoding: "utf-8",
+    timeout,
+    windowsHide: true,
+    shell: false,
+  });
+  return {
+    available: true,
+    ok: result.status === 0 && !result.error,
+    status: result.status,
+    executable,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error || null,
+  };
+}
+
+export function cliFailureMessage(result) {
+  if (!result?.available) return "client CLI is not installed or not available on PATH";
+  if (result.error) return result.error.message;
+  const detail = String(result.stderr || result.stdout || "").trim().split(/\r?\n/).pop();
+  return detail || `client CLI exited with status ${result.status}`;
+}

package/mcp-server/client_paths.js

@@ -0,0 +1,44 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function resolveClientPaths({
+  home = homedir(),
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const configHome = env.XDG_CONFIG_HOME || join(home, ".config");
+  const cacheHome = env.XDG_CACHE_HOME || join(home, ".cache");
+  const opencodeDir = env.OPENCODE_CONFIG_DIR || join(configHome, "opencode");
+  const agentConfigDir = join(configHome, "memory-agent");
+  const geminiDir = join(home, ".gemini");
+  const antigravityConfigDir = join(geminiDir, "config");
+
+  return {
+    home,
+    cwd,
+    configHome,
+    cacheHome,
+    opencodeDir,
+    opencodeConfigPath: join(opencodeDir, "opencode.json"),
+    opencodeCachePackages: join(cacheHome, "opencode", "packages"),
+    claudeConfigPath: join(home, ".claude.json"),
+    geminiDir,
+    geminiSettingsPath: join(geminiDir, "settings.json"),
+    geminiPromptPath: join(geminiDir, "GEMINI.md"),
+    geminiSkillsDir: join(geminiDir, "skills"),
+    // Antigravity intentionally uses its own legacy layout. Keep these paths
+    // separate from the real Gemini CLI settings above.
+    antigravityConfigDir,
+    antigravityMcpConfigPath: join(antigravityConfigDir, "mcp_config.json"),
+    geminiConfigDir: antigravityConfigDir,
+    geminiMcpConfigPath: join(antigravityConfigDir, "mcp_config.json"),
+    localAgentsDir: join(cwd, ".agents"),
+    localAgentsMcpConfigPath: join(cwd, ".agents", "mcp_config.json"),
+    codexDir: join(home, ".codex"),
+    codexConfigPath: join(home, ".codex", "config.toml"),
+    agentConfigDir,
+    promptFile: join(agentConfigDir, "prompt.md"),
+    promptStateFile: join(agentConfigDir, "prompt-state.json"),
+    promptBackupDir: join(agentConfigDir, "backups"),
+  };
+}

package/mcp-server/client_registration.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { isMemoryPluginSpec } from "./dev_link.js";
+
+export const MEMORY_MCP_ENTRY = Object.freeze({
+  command: "npx",
+  args: Object.freeze(["-y", "@lotargo/memory_plugin"]),
+});
+
+export function isMemoryPluginEntry(entry) {
+  const spec = Array.isArray(entry)
+    ? entry[0]
+    : entry && typeof entry === "object"
+      ? entry.package
+      : entry;
+  return isMemoryPluginSpec(spec);
+}
+
+export function isMemoryMcpServerEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const command = String(entry.command || "").replace(/\\/g, "/").toLowerCase();
+  const args = Array.isArray(entry.args)
+    ? entry.args.map((value) => String(value).replace(/\\/g, "/").toLowerCase())
+    : [];
+  return args.some((arg) => /^@lotargo\/memory_plugin(?:@[^/]+)?$/i.test(arg) || /^opencode-memory-plugin(?:@[^/]+)?$/i.test(arg))
+    || args.some((arg) => arg.endsWith("/mcp-server/boot.js") && arg.includes("memory"))
+    || /(?:^|\/)(?:memory_plugin|memory-agent)(?:\.(?:cmd|exe|ps1|bat))?$/i.test(command);
+}
+
+export async function readJsonConfig(filePath) {
+  if (!existsSync(filePath)) return {};
+  const raw = (await readFile(filePath, "utf-8")).replace(/^\uFEFF/, "");
+  const value = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Expected a JSON object in ${filePath}`);
+  }
+  return value;
+}

package/mcp-server/codex_config.js

@@ -102,6 +102,44 @@ function sectionRanges(lines) {
   }));
 }
 
+function validateOwnedMemoryAgentTargets(lines, ranges) {
+  const targets = ranges.filter((range) => isMemoryAgentHeader(range.name));
+  if (targets.length === 0) return { targets, exactTargets: [], conflict: null };
+
+  const exactTargets = targets.filter((range) => isMemoryAgentHeader(range.name, { exact: true }));
+  const unowned = exactTargets.filter((range) => {
+    const text = lines.slice(range.start, range.end).join("\n");
+    return !isMemoryPluginOwnedSection(text);
+  });
+  if (unowned.length > 0 || exactTargets.length === 0) {
+    return {
+      targets,
+      exactTargets,
+      conflict: "Existing memory-agent TOML section is not recognized as owned by @lotargo/memory_plugin",
+    };
+  }
+
+  let activeOwnedRoot = false;
+  for (const range of ranges) {
+    if (isMemoryAgentHeader(range.name, { exact: true })) {
+      const text = lines.slice(range.start, range.end).join("\n");
+      activeOwnedRoot = isMemoryPluginOwnedSection(text);
+    } else if (isMemoryAgentHeader(range.name)) {
+      if (!activeOwnedRoot) {
+        return {
+          targets,
+          exactTargets,
+          conflict: "A memory-agent child TOML section is not attached to an owned plugin section",
+        };
+      }
+    } else {
+      activeOwnedRoot = false;
+    }
+  }
+
+  return { targets, exactTargets, conflict: null };
+}
+
 export function getCodexMemoryAgentSections(content) {
   const lines = String(content || "").split(/\r?\n/);
   return sectionRanges(lines)
@@ -113,25 +151,65 @@ export function getCodexMemoryAgentSections(content) {
     }));
 }
 
+export function removeCodexMemoryAgentConfig(content) {
+  const source = String(content || "");
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const ranges = sectionRanges(lines);
+  const { targets, conflict } = validateOwnedMemoryAgentTargets(lines, ranges);
+
+  if (targets.length === 0) {
+    return { content: source, changed: false, status: "not_found", removed: 0 };
+  }
+
+  if (conflict) {
+    return {
+      content: source,
+      changed: false,
+      status: "conflict",
+      reason: conflict,
+      removed: 0,
+    };
+  }
+
+  const targetLineIndexes = new Set();
+  for (const target of targets) {
+    let contentEnd = target.end;
+    while (contentEnd > target.start + 1 && lines[contentEnd - 1] === "") contentEnd--;
+    for (let i = target.start; i < contentEnd; i++) targetLineIndexes.add(i);
+  }
+
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (targetLineIndexes.has(i)) continue;
+    result.push(lines[i]);
+  }
+
+  let updated = result.join(eol);
+  if (updated.trim() === "") updated = "";
+
+  return {
+    content: updated,
+    changed: updated !== source,
+    status: updated !== source ? "removed" : "unchanged",
+    removed: targets.length,
+  };
+}
+
 export function updateCodexMemoryAgentConfig(content, options) {
   const source = String(content || "");
   const eol = source.includes("\r\n") ? "\r\n" : "\n";
   const lines = source.split(/\r?\n/);
   const desired = buildCodexMemoryAgentSection(options).split("\n");
   const ranges = sectionRanges(lines);
-  const targets = ranges.filter((range) => isMemoryAgentHeader(range.name));
-  const exactTargets = targets.filter((range) => isMemoryAgentHeader(range.name, { exact: true }));
+  const { targets, conflict } = validateOwnedMemoryAgentTargets(lines, ranges);
 
-  const unowned = exactTargets.filter((range) => {
-    const text = lines.slice(range.start, range.end).join("\n");
-    return !isMemoryPluginOwnedSection(text);
-  });
-  if (unowned.length > 0) {
+  if (conflict) {
     return {
       content: source,
       changed: false,
       status: "conflict",
-      reason: "Existing [mcp_servers.memory-agent] section is not recognized as owned by @lotargo/memory_plugin",
+      reason: conflict,
     };
   }
 

package/mcp-server/db/database.js

@@ -10,7 +10,7 @@ import { createClient } from "@libsql/client";
 let dbInstance = null;
 let dbInitPromise = null;
 let dbLastFailAt = 0;
-const DB_FAIL_COOLDOWN_MS = 5_000;  // don't retry cloud init within 5s of a failure
+const DB_FAIL_COOLDOWN_MS = 5_000;
 
 export const STORAGE_DIR = join(MEMORY_DIR, "storage");
 export const BLOBS_DIR = join(STORAGE_DIR, "blobs");
@@ -34,8 +34,6 @@ class DatabaseWrapper {
 
     while (attempts < maxAttempts) {
       attempts++;
-      // A plain timer is enough here; an AbortController per attempt leaked its
-      // "abort" listener because it was never removed.
       let timeoutId = null;
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(
@@ -48,7 +46,6 @@ class DatabaseWrapper {
         const client = (this.usingFailover && this.failoverClient) ? this.failoverClient : this.cloudClient;
         const result = await Promise.race([fn(client), timeoutPromise]);
         clearTimeout(timeoutId);
-        // Successful operation, reset consecutive failures
         this.consecutiveFailures = 0;
         return result;
       } catch (err) {
@@ -58,12 +55,10 @@ class DatabaseWrapper {
           if (this.consecutiveFailures >= 3 && this.failoverClient && !this.usingFailover) {
             console.warn("[WARN] Turso is temporarily unreachable. Switching to LiteFS failover replica...");
             this.usingFailover = true;
-            // Retry the operation on the failover client
             return this.runWithRetry(fn);
           }
           throw err;
         }
-        // Small delay before retrying (exponential backoff / fixed delay)
         await new Promise((resolve) => setTimeout(resolve, 200));
       }
     }
@@ -156,16 +151,12 @@ async function openDatabase(customPath, mode) {
     localDb = new DatabaseSync(dbPath);
     localDb.exec("PRAGMA foreign_keys = ON;");
     localDb.exec("PRAGMA journal_mode = WAL;");
-    // Default busy_timeout is 0 => an immediate SQLITE_BUSY ("database is
-    // locked") whenever background sync, ingestion and MCP calls overlap.
     localDb.exec("PRAGMA busy_timeout = 5000;");
   }
 
   let cloudClient = null;
   let failoverClient = null;
   if (mode === "only-cloud" || mode === "hybrid-sync") {
-    // Resolve working cloud credentials. An env TURSO_API_TOKEN (which can only
-    // call the Platform API) is lazily minted into a per-database JWT here.
     const secrets = await resolveCloudSecrets();
     const tursoUrl = customPath && customPath.startsWith("libsql:") ? customPath : (secrets?.dbUrl || config.tursoUrl);
     const failoverUrl = config.failoverUrl || "";
@@ -182,8 +173,6 @@ async function openDatabase(customPath, mode) {
           authToken: token || undefined,
         });
       }
-      // In hybrid-sync mode, ensure remote schema is also fully migrated and up to date.
-      // Use a dedicated short-lived client so closing it doesn't kill the shared one.
       if (mode === "hybrid-sync") {
         const remoteClient = createClient({
           url: tursoUrl,
@@ -199,13 +188,22 @@ async function openDatabase(customPath, mode) {
   }
 
   const wrappedDb = new DatabaseWrapper(localDb, cloudClient, mode, failoverClient);
-
-  // Initialize/run migrations
   await runMigrations(wrappedDb);
 
+  // Upgrade path for RAG content ingested before portable cloud blobs existed.
+  // The backfill is content-addressed and uploads only hashes absent in Turso.
+  // Missing local files are simply reported/skipped; database availability must
+  // never depend on a legacy raw blob still being present on this machine.
+  if ((mode === "only-cloud" || mode === "hybrid-sync") && cloudClient) {
+    try {
+      const { backfillCloudBlobsFromLocal } = await import("./rag_blob_transport.js");
+      await backfillCloudBlobsFromLocal(wrappedDb);
+    } catch (err) {
+      console.warn("[WARN] RAG cloud blob backfill skipped:", err.message);
+    }
+  }
+
   if (!customPath) {
-    // Closing the previous instance before replacing it: otherwise a mode switch
-    // leaked the old DatabaseSync handle and Turso client.
     if (dbInstance && dbInstance !== wrappedDb) {
       try {
         dbInstance.close();
@@ -225,15 +223,10 @@ export async function getDatabase(customPath = null, forceMode = null) {
     if (dbInstance && dbInstance.mode === mode) {
       return dbInstance;
     }
-    // After a failed init, wait before retrying to avoid hammering cloud auth.
-    // Only cloud modes are throttled — reopening a local SQLite file is cheap
-    // and must never be blocked by an unrelated cloud failure.
     const isCloudMode = mode === "only-cloud" || mode === "hybrid-sync";
     if (isCloudMode && !dbInitPromise && dbLastFailAt && (Date.now() - dbLastFailAt) < DB_FAIL_COOLDOWN_MS) {
       throw new Error("Database initialization failed recently. Retrying in a few seconds...");
     }
-    // Deduplicate concurrent default-DB initialization so migrations never run
-    // on multiple connections at once (avoids "database is locked" crashes).
     if (!dbInitPromise) {
       dbInitPromise = openDatabase(null, mode).then((result) => {
         dbLastFailAt = 0;

package/mcp-server/db/migrations.js

@@ -3,7 +3,6 @@ const MIGRATIONS = [
     version: 1,
     name: "001_initial_rag_schema",
     up: async (db) => {
-      // 1. Documents Table
       await db.exec(`
         CREATE TABLE IF NOT EXISTS documents (
             id TEXT PRIMARY KEY,
@@ -17,8 +16,6 @@ const MIGRATIONS = [
             updated_at INTEGER NOT NULL
         );
       `);
-
-      // 2. Sections Table
       await db.exec(`
         CREATE TABLE IF NOT EXISTS sections (
             id TEXT PRIMARY KEY,
@@ -29,8 +26,6 @@ const MIGRATIONS = [
             token_count INTEGER NOT NULL
         );
       `);
-
-      // 3. Micro-Chunks Table
       await db.exec(`
         CREATE TABLE IF NOT EXISTS micro_chunks (
             id TEXT PRIMARY KEY,
@@ -41,8 +36,6 @@ const MIGRATIONS = [
             token_count INTEGER NOT NULL
         );
       `);
-
-      // 4. Full-Text Search (BM25 Index via SQLite FTS5)
       await db.exec(`
         CREATE VIRTUAL TABLE IF NOT EXISTS micro_chunks_fts USING fts5(
             id UNINDEXED,
@@ -50,8 +43,6 @@ const MIGRATIONS = [
             breadcrumbs
         );
       `);
-
-      // 5. GraphRAG Lite Edges Table
       await db.exec(`
         CREATE TABLE IF NOT EXISTS graph_edges (
             source_id TEXT NOT NULL,
@@ -66,13 +57,8 @@ const MIGRATIONS = [
     version: 2,
     name: "002_agent_knowledge_graph",
     up: async (db) => {
-      try {
-        await db.exec(`ALTER TABLE graph_edges ADD COLUMN metadata_json TEXT;`);
-      } catch (e) {}
-      try {
-        await db.exec(`ALTER TABLE graph_edges ADD COLUMN created_at INTEGER;`);
-      } catch (e) {}
-
+      try { await db.exec(`ALTER TABLE graph_edges ADD COLUMN metadata_json TEXT;`); } catch (e) {}
+      try { await db.exec(`ALTER TABLE graph_edges ADD COLUMN created_at INTEGER;`); } catch (e) {}
       await db.exec(`
         CREATE TABLE IF NOT EXISTS knowledge_links (
             id TEXT PRIMARY KEY,
@@ -104,10 +90,7 @@ const MIGRATIONS = [
             created_at INTEGER
         );
       `);
-
-      try {
-        await db.exec(`ALTER TABLE micro_chunks ADD COLUMN medium_id TEXT REFERENCES medium_chunks(id) ON DELETE CASCADE;`);
-      } catch (e) {}
+      try { await db.exec(`ALTER TABLE micro_chunks ADD COLUMN medium_id TEXT REFERENCES medium_chunks(id) ON DELETE CASCADE;`); } catch (e) {}
     },
   },
   {
@@ -116,65 +99,81 @@ const MIGRATIONS = [
     up: async (db) => {
       await db.exec(`
         CREATE TABLE IF NOT EXISTS project_identities (
-          key           TEXT PRIMARY KEY,
-          name          TEXT NOT NULL,
+          key TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
           primary_remote TEXT,
-          created_at    INTEGER NOT NULL,
-          updated_at    INTEGER NOT NULL
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
         );
       `);
-
       await db.exec(`
         CREATE TABLE IF NOT EXISTS project_aliases (
-          alias        TEXT PRIMARY KEY,
+          alias TEXT PRIMARY KEY,
           identity_key TEXT NOT NULL REFERENCES project_identities(key) ON DELETE CASCADE,
-          kind         TEXT NOT NULL,
-          created_at   INTEGER NOT NULL
+          kind TEXT NOT NULL,
+          created_at INTEGER NOT NULL
         );
       `);
-
+      await db.exec(`CREATE INDEX IF NOT EXISTS idx_project_aliases_identity ON project_aliases(identity_key);`);
+    },
+  },
+  {
+    version: 5,
+    name: "005_retrieval_policy",
+    up: async (db) => {
+      try { await db.exec(`ALTER TABLE micro_chunks ADD COLUMN retrieval_policy TEXT DEFAULT 'micro_chunk';`); } catch (e) {}
+      try { await db.exec(`ALTER TABLE micro_chunks ADD COLUMN policy_source_id TEXT;`); } catch (e) {}
+      await db.exec(`CREATE INDEX IF NOT EXISTS idx_micro_chunks_retrieval_policy ON micro_chunks(retrieval_policy);`);
+    },
+  },
+  {
+    version: 6,
+    name: "006_project_scoped_rag",
+    up: async (db) => {
       await db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_project_aliases_identity ON project_aliases(identity_key);
+        CREATE TABLE IF NOT EXISTS document_scopes (
+          doc_id TEXT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+          scope_key TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          PRIMARY KEY (doc_id, scope_key)
+        );
+      `);
+      await db.exec(`CREATE INDEX IF NOT EXISTS idx_document_scopes_scope ON document_scopes(scope_key, doc_id);`);
+      await db.exec(`
+        INSERT OR IGNORE INTO document_scopes (doc_id, scope_key, created_at)
+        SELECT id, 'global', created_at FROM documents;
       `);
     },
   },
-  {
-    version: 5,
-    name: "005_retrieval_policy",
+  {
+    version: 7,
+    name: "007_rag_blob_transport",
     up: async (db) => {
-      try {
-        await db.exec(`ALTER TABLE micro_chunks ADD COLUMN retrieval_policy TEXT DEFAULT 'micro_chunk';`);
-      } catch (e) {}
-      try {
-        await db.exec(`ALTER TABLE micro_chunks ADD COLUMN policy_source_id TEXT;`);
-      } catch (e) {}
       await db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_micro_chunks_retrieval_policy ON micro_chunks(retrieval_policy);
+        CREATE TABLE IF NOT EXISTS rag_blobs (
+          hash TEXT PRIMARY KEY,
+          gzip_base64 TEXT NOT NULL,
+          raw_size INTEGER NOT NULL DEFAULT 0,
+          created_at INTEGER NOT NULL
+        );
       `);
-    },
-  },
-  {
-    version: 6,
-    name: "006_project_scoped_rag",
-    up: async (db) => {
-      await db.exec(`
-        CREATE TABLE IF NOT EXISTS document_scopes (
-          doc_id     TEXT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
-          scope_key  TEXT NOT NULL,
-          created_at INTEGER NOT NULL,
-          PRIMARY KEY (doc_id, scope_key)
-        );
-      `);
-      await db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_document_scopes_scope ON document_scopes(scope_key, doc_id);
-      `);
-      await db.exec(`
-        INSERT OR IGNORE INTO document_scopes (doc_id, scope_key, created_at)
-        SELECT id, 'global', created_at FROM documents;
-      `);
-    },
-  },
-];
+    },
+  },
+  {
+    version: 8,
+    name: "008_rag_document_tombstones",
+    up: async (db) => {
+      await db.exec(`
+        CREATE TABLE IF NOT EXISTS rag_document_tombstones (
+          doc_id TEXT PRIMARY KEY,
+          path TEXT,
+          deleted_at INTEGER NOT NULL
+        );
+      `);
+      await db.exec(`CREATE INDEX IF NOT EXISTS idx_rag_tombstones_path ON rag_document_tombstones(path);`);
+    },
+  },
+];
 
 export async function runMigrations(db) {
   let currentVersion = 0;
@@ -188,12 +187,7 @@ export async function runMigrations(db) {
     } catch (e2) {}
   }
 
-  // Ensure schema_migrations table exists for future
-  try {
-    await db.exec(`CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY);`);
-  } catch (e) {}
-
-  // Create notebooks table if not exists
+  try { await db.exec(`CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY);`); } catch (e) {}
   try {
     await db.exec(`
       CREATE TABLE IF NOT EXISTS notebooks (
@@ -211,19 +205,14 @@ export async function runMigrations(db) {
         await migration.up(db);
         await db.prepare("INSERT INTO schema_migrations (version) VALUES (?);").run(migration.version);
         await db.exec("COMMIT;");
-        try {
-          await db.exec(`PRAGMA user_version = ${migration.version};`);
-        } catch (e) {}
+        try { await db.exec(`PRAGMA user_version = ${migration.version};`); } catch (e) {}
       } catch (err) {
-        try {
-          await db.exec("ROLLBACK;");
-        } catch (e) {}
+        try { await db.exec("ROLLBACK;"); } catch (e) {}
         throw new Error(`Migration ${migration.name} failed: ${err.message}`);
       }
     }
   }
 
-  // Defensive table & column check for medium_chunks hierarchy
   try {
     await db.exec(`
       CREATE TABLE IF NOT EXISTS medium_chunks (