mnemosyne-core 2.0.0 → 2.0.2

package/dist/cli/index.js

@@ -3548,9 +3548,22 @@ function loadConfig() {
     return defaultConfig();
   }
 }
+function getVersion() {
+  try {
+    const pkg = JSON.parse((0, import_fs.readFileSync)((0, import_path.resolve)(__dirname, "../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    try {
+      const pkg = JSON.parse((0, import_fs.readFileSync)((0, import_path.resolve)(process.cwd(), "package.json"), "utf-8"));
+      return pkg.version;
+    } catch {
+      return "2.0.1";
+    }
+  }
+}
 function defaultConfig() {
   return {
-    server: { port: 7321, host: "localhost", version: "2.0.0" },
+    server: { port: 7321, host: "localhost", version: getVersion() },
     database: { path: "data/nexus.db", wal_mode: true, vec_extension_path: "data/vec0" },
     storage: { files_dir: "data/files", max_file_size_mb: 50, backups_dir: "data/backups", backup_interval_hours: 24, max_backups: 7 },
     limits: { max_atoms_per_project: 1e4, rate_limit_requests: 100, rate_limit_window_ms: 6e4 },
@@ -4351,7 +4364,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync9 = (path) => {
+    var readFileSync7 = (path) => {
       const fd = fs.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -4376,7 +4389,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync9,
+      readFileSync: readFileSync7,
       readFile
     };
   }
@@ -4425,7 +4438,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync9 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync7 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -4517,7 +4530,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync9(LDD_PATH);
+        const lddContent = readFileSync7(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -4542,7 +4555,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync9(SELF_PATH);
+        const selfContent = readFileSync7(SELF_PATH);
         const path = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path);
       } catch (e) {
@@ -4606,7 +4619,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync9(LDD_PATH);
+        const lddContent = readFileSync7(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -13103,7 +13116,6 @@ var import_path9 = require("path");
 
 // src/core/Mnemosyne.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-var import_fs5 = require("fs");
 var import_path5 = require("path");
 
 // src/core/types.ts
@@ -14327,9 +14339,26 @@ function parseYaml2(text) {
   }
   return root;
 }
+function getVersion2() {
+  try {
+    const { readFileSync: readFileSync7 } = require("fs");
+    const { resolve: resolve13 } = require("path");
+    const pkg = JSON.parse(readFileSync7(resolve13(__dirname, "../../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    try {
+      const { readFileSync: readFileSync7 } = require("fs");
+      const { resolve: resolve13 } = require("path");
+      const pkg = JSON.parse(readFileSync7(resolve13(process.cwd(), "package.json"), "utf-8"));
+      return pkg.version;
+    } catch {
+      return "2.0.1";
+    }
+  }
+}
 function defaultConfig2() {
   return {
-    server: { port: 7321, host: "localhost", version: "2.0.0" },
+    server: { port: 7321, host: "localhost", version: getVersion2() },
     database: { path: "data/nexus.db", wal_mode: true, vec_extension_path: "data/vec0" },
     storage: { files_dir: "data/files", max_file_size_mb: 50, backups_dir: "data/backups", backup_interval_hours: 24, max_backups: 7 },
     limits: { max_atoms_per_project: 1e4, rate_limit_requests: 100, rate_limit_window_ms: 6e4 },
@@ -14352,8 +14381,8 @@ function mergeDeep2(target, source) {
   }
   return output;
 }
-function loadConfig2(configPath) {
-  const path = configPath ? (0, import_path4.resolve)(configPath) : (0, import_path4.resolve)(process.cwd(), "config.yaml");
+function loadConfig2(configPath, baseDir = process.cwd()) {
+  const path = configPath ? (0, import_path4.resolve)(configPath) : (0, import_path4.resolve)(baseDir, "config.yaml");
   if (!(0, import_fs4.existsSync)(path)) {
     if (!configPath) console.warn("[Config] config.yaml not found, using defaults");
     return defaultConfig2();
@@ -14369,23 +14398,237 @@ function loadConfig2(configPath) {
 }
 var MnemosyneConfig = class {
   config;
+  baseDir;
   constructor(options) {
-    this.config = loadConfig2(options?.configPath);
+    this.baseDir = options?.baseDir || process.cwd();
+    this.config = loadConfig2(options?.configPath, this.baseDir);
     if (options?.overrides) {
       this.config = mergeDeep2(this.config, options.overrides);
     }
   }
   get dbPath() {
-    return (0, import_path4.resolve)(process.cwd(), this.config.database.path);
+    return (0, import_path4.resolve)(this.baseDir, this.config.database.path);
   }
   get filesDir() {
-    return (0, import_path4.resolve)(process.cwd(), this.config.storage.files_dir);
+    return (0, import_path4.resolve)(this.baseDir, this.config.storage.files_dir);
   }
   get backupsDir() {
-    return (0, import_path4.resolve)(process.cwd(), this.config.storage.backups_dir);
+    return (0, import_path4.resolve)(this.baseDir, this.config.storage.backups_dir);
+  }
+  get baseDirPath() {
+    return this.baseDir;
   }
 };
 
+// src/db/schema.ts
+var SCHEMA_SQL = `-- Mnemosyne v1.1 Database Schema
+-- SQLite with sqlite-vec extension for semantic search
+
+-- PROJECTS (Spaces)
+CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    icon TEXT DEFAULT '\u25C9',
+    color TEXT DEFAULT '#6366f1',
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    owner TEXT DEFAULT 'human',
+    metadata TEXT DEFAULT '{}'
+);
+
+-- ATOMS (Ideas/Nodes)
+CREATE TABLE IF NOT EXISTS atoms (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    parent_id TEXT REFERENCES atoms(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    summary TEXT,
+    icon TEXT DEFAULT '\u25CF',
+    color TEXT,
+    x REAL,
+    y REAL,
+    auto_path TEXT,
+    path_overridden INTEGER DEFAULT 0,
+    status TEXT DEFAULT 'draft',
+    status_updated_at INTEGER DEFAULT (unixepoch()),
+    embedding_status TEXT DEFAULT 'pending',
+    embedding_error TEXT,
+    block_count INTEGER DEFAULT 0,
+    bond_count INTEGER DEFAULT 0,
+    template_id TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    version INTEGER DEFAULT 1,
+    locked_by TEXT,
+    locked_at INTEGER,
+    locked_reason TEXT,
+    owner TEXT DEFAULT 'human',
+    metadata TEXT DEFAULT '{}'
+);
+
+-- BLOCKS (Content pieces inside atoms)
+CREATE TABLE IF NOT EXISTS blocks (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'text',
+    content TEXT,
+    order_index INTEGER DEFAULT 0,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}'
+);
+
+-- BONDS (Graph connections between atoms)
+CREATE TABLE IF NOT EXISTS bonds (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    target_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    label TEXT DEFAULT 'connects',
+    color TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    UNIQUE(source_id, target_id)
+);
+
+-- ATTACHMENTS (Files in CAS)
+CREATE TABLE IF NOT EXISTS attachments (
+    id TEXT PRIMARY KEY,
+    block_id TEXT REFERENCES blocks(id) ON DELETE CASCADE,
+    file_name TEXT NOT NULL,
+    file_hash TEXT NOT NULL,
+    file_size INTEGER,
+    mime_type TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    UNIQUE(file_hash)
+);
+
+-- EVENT LOG (Immutable audit trail)
+CREATE TABLE IF NOT EXISTS event_log (
+    id TEXT PRIMARY KEY,
+    timestamp INTEGER DEFAULT (unixepoch()),
+    event_type TEXT NOT NULL,
+    project_id TEXT,
+    atom_id TEXT,
+    block_id TEXT,
+    bond_id TEXT,
+    actor TEXT NOT NULL DEFAULT 'system',
+    actor_type TEXT DEFAULT 'system',
+    diff TEXT,
+    trigger TEXT,
+    metadata TEXT DEFAULT '{}'
+);
+
+-- ASSISTANTS (AI Agents)
+CREATE TABLE IF NOT EXISTS assistants (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    role TEXT DEFAULT 'worker',
+    permissions TEXT DEFAULT '{"read":["*"],"write":[],"delete":false}',
+    status TEXT DEFAULT 'active',
+    provider TEXT,
+    connected_at INTEGER DEFAULT (unixepoch()),
+    last_seen INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}'
+);
+
+-- QUEUE (Agent waitlist for locked atoms)
+CREATE TABLE IF NOT EXISTS queue (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    assistant_id TEXT NOT NULL REFERENCES assistants(id) ON DELETE CASCADE,
+    requested_at INTEGER DEFAULT (unixepoch()),
+    priority INTEGER DEFAULT 5,
+    status TEXT DEFAULT 'waiting',
+    reason TEXT
+);
+
+-- INDICES
+CREATE INDEX IF NOT EXISTS idx_atoms_project ON atoms(project_id);
+CREATE INDEX IF NOT EXISTS idx_atoms_parent ON atoms(parent_id);
+CREATE INDEX IF NOT EXISTS idx_atoms_locked ON atoms(locked_by) WHERE locked_by IS NOT NULL;
+-- idx_atoms_path_project is created by migration after auto_path column is added
+CREATE INDEX IF NOT EXISTS idx_blocks_atom ON blocks(atom_id);
+CREATE INDEX IF NOT EXISTS idx_bonds_source ON bonds(source_id);
+CREATE INDEX IF NOT EXISTS idx_bonds_target ON bonds(target_id);
+CREATE INDEX IF NOT EXISTS idx_event_log_time ON event_log(timestamp);
+CREATE INDEX IF NOT EXISTS idx_event_log_atom ON event_log(atom_id);
+CREATE INDEX IF NOT EXISTS idx_queue_atom ON queue(atom_id);
+CREATE INDEX IF NOT EXISTS idx_attachments_hash ON attachments(file_hash);
+
+-- Auto-update block_count and bond_count triggers
+CREATE TRIGGER IF NOT EXISTS update_block_count_insert AFTER INSERT ON blocks BEGIN
+  UPDATE atoms SET block_count = block_count + 1 WHERE id = NEW.atom_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_block_count_delete AFTER DELETE ON blocks BEGIN
+  UPDATE atoms SET block_count = block_count - 1 WHERE id = OLD.atom_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_bond_count_insert AFTER INSERT ON bonds BEGIN
+  UPDATE atoms SET bond_count = bond_count + 1 WHERE id = NEW.source_id OR id = NEW.target_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_bond_count_delete AFTER DELETE ON bonds BEGIN
+  UPDATE atoms SET bond_count = bond_count - 1 WHERE id = OLD.source_id OR id = OLD.target_id;
+END;
+
+-- FTS5 FULL-TEXT SEARCH
+-- Separate tables to avoid rowid collisions between atoms and blocks
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_atoms USING fts5(
+    title, summary,
+    content='atoms', content_rowid='rowid'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_blocks USING fts5(
+    content,
+    content='blocks', content_rowid='rowid'
+);
+
+-- Triggers to keep search_atoms in sync
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_insert AFTER INSERT ON atoms BEGIN
+    INSERT INTO search_atoms(rowid, title, summary) VALUES (new.rowid, new.title, COALESCE(new.summary, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_update AFTER UPDATE ON atoms BEGIN
+    UPDATE search_atoms SET title = new.title, summary = COALESCE(new.summary, '') WHERE rowid = new.rowid;
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_delete AFTER DELETE ON atoms BEGIN
+    DELETE FROM search_atoms WHERE rowid = old.rowid;
+END;
+
+-- Triggers to keep search_blocks in sync
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_insert AFTER INSERT ON blocks BEGIN
+    INSERT INTO search_blocks(rowid, content) VALUES (new.rowid, COALESCE(new.content, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_update AFTER UPDATE ON blocks BEGIN
+    UPDATE search_blocks SET content = COALESCE(new.content, '') WHERE rowid = new.rowid;
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_delete AFTER DELETE ON blocks BEGIN
+    DELETE FROM search_blocks WHERE rowid = old.rowid;
+END;
+
+
+-- PER-ATOM PERMISSIONS (Granular access control)
+CREATE TABLE IF NOT EXISTS atom_permissions (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    assistant_id TEXT NOT NULL REFERENCES assistants(id) ON DELETE CASCADE,
+    level TEXT NOT NULL DEFAULT 'view',
+    granted_by TEXT,
+    granted_at INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}',
+    UNIQUE(atom_id, assistant_id)
+);
+
+-- sqlite-vec virtual table for semantic embeddings
+-- Created dynamically by connection.ts after loading the extension
+-- CREATE VIRTUAL TABLE IF NOT EXISTS atom_vectors USING vec0(atom_id TEXT PRIMARY KEY, embedding float[384]);
+`;
+
 // src/core/Mnemosyne.ts
 var Mnemosyne = class {
   store;
@@ -14393,7 +14636,7 @@ var Mnemosyne = class {
   vecEnabled;
   db;
   constructor(options = {}) {
-    this.config = new MnemosyneConfig({ configPath: options.configPath });
+    this.config = new MnemosyneConfig({ configPath: options.configPath, baseDir: options.baseDir });
     const cfg = this.config.config;
     const dbPath = options.dbPath || this.config.dbPath;
     this.db = new import_better_sqlite32.default(dbPath);
@@ -14402,17 +14645,21 @@ var Mnemosyne = class {
     this.db.pragma("synchronous = NORMAL");
     this.vecEnabled = false;
     try {
-      const vecPath = (0, import_path5.resolve)(process.cwd(), cfg.database.vec_extension_path);
+      let vecPath;
+      try {
+        const sqliteVec = require("sqlite-vec");
+        vecPath = sqliteVec.getLoadablePath();
+      } catch {
+        vecPath = (0, import_path5.resolve)(this.config.baseDirPath || process.cwd(), cfg.database.vec_extension_path);
+      }
       this.db.loadExtension(vecPath);
       this.vecEnabled = true;
       console.log("[DB] sqlite-vec extension loaded");
     } catch (err) {
       console.warn("[DB] sqlite-vec not available:", err.message);
     }
-    const schemaPath = (0, import_path5.resolve)(process.cwd(), "src", "db", "schema.sql");
     try {
-      const schema = (0, import_fs5.readFileSync)(schemaPath, "utf-8");
-      this.db.exec(schema);
+      this.db.exec(SCHEMA_SQL);
     } catch (err) {
       console.error("[DB] Failed to load schema:", err.message);
     }
@@ -14456,7 +14703,7 @@ var Mnemosyne = class {
 
 // src/server/MnemosyneServer.ts
 var import_http = require("http");
-var import_fs8 = require("fs");
+var import_fs6 = require("fs");
 var import_path8 = require("path");
 
 // node_modules/ws/wrapper.mjs
@@ -15611,21 +15858,21 @@ function handleFiles(store, pathname, method, req, res, maxFileSizeMb) {
 // src/server/export-format.ts
 var import_adm_zip2 = __toESM(require("adm-zip"));
 var import_crypto2 = require("crypto");
-var import_fs6 = require("fs");
+var import_fs5 = require("fs");
 var import_path6 = require("path");
 var DB_PATH = (0, import_path6.resolve)(process.cwd(), "data", "nexus.db");
 var FILES_DIR2 = (0, import_path6.resolve)(process.cwd(), "data", "files");
 function sha256File(path) {
-  return (0, import_crypto2.createHash)("sha256").update((0, import_fs6.readFileSync)(path)).digest("hex");
+  return (0, import_crypto2.createHash)("sha256").update((0, import_fs5.readFileSync)(path)).digest("hex");
 }
 function sha256Dir(dir) {
   const hash = (0, import_crypto2.createHash)("sha256");
   function walk(p) {
-    const stat = (0, import_fs6.statSync)(p);
+    const stat = (0, import_fs5.statSync)(p);
     if (stat.isFile()) {
-      hash.update((0, import_fs6.readFileSync)(p));
+      hash.update((0, import_fs5.readFileSync)(p));
     } else if (stat.isDirectory()) {
-      for (const child of (0, import_fs6.readdirSync)(p).sort()) walk((0, import_path6.resolve)(p, child));
+      for (const child of (0, import_fs5.readdirSync)(p).sort()) walk((0, import_path6.resolve)(p, child));
     }
   }
   walk(dir);
@@ -15634,11 +15881,11 @@ function sha256Dir(dir) {
 function buildMnemosyneExport(projectId, projectName) {
   const zip = new import_adm_zip2.default();
   zip.addLocalFile(DB_PATH, "", "nexus.db");
-  if ((0, import_fs6.existsSync)(FILES_DIR2)) {
+  if ((0, import_fs5.existsSync)(FILES_DIR2)) {
     zip.addLocalFolder(FILES_DIR2, "files");
   }
   const dbChecksum = sha256File(DB_PATH);
-  const filesChecksum = (0, import_fs6.existsSync)(FILES_DIR2) ? sha256Dir(FILES_DIR2) : "";
+  const filesChecksum = (0, import_fs5.existsSync)(FILES_DIR2) ? sha256Dir(FILES_DIR2) : "";
   const manifest = {
     version: "1.1",
     app: "Mnemosyne",
@@ -15764,12 +16011,20 @@ function handleEvents(store, pathname, method, res, searchParams) {
 }
 
 // src/api/routes/health.ts
+var PKG_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(require("fs").readFileSync(require("path").resolve(__dirname, "../../../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "2.0.1";
+  }
+})();
 function handleHealth(store, pathname, method, res) {
-  if (pathname === "/health" && method === "GET") {
+  if ((pathname === "/health" || pathname === "/api/v1/health") && method === "GET") {
     const stats = store.getStats();
     json(res, 200, {
       status: "ok",
-      version: "2.0.0",
+      version: PKG_VERSION,
       storage: "sqlite",
       database: store.config.database.path,
       uptime: process.uptime(),
@@ -15994,7 +16249,6 @@ var WebSocketHandler = class {
 
 // src/db/connection.ts
 var import_better_sqlite33 = __toESM(require("better-sqlite3"));
-var import_fs7 = require("fs");
 var import_path7 = require("path");
 init_config();
 var DB_PATH2 = process.env.MNEMOSYNE_DB_PATH || (0, import_path7.resolve)(process.cwd(), CONFIG.database.path);
@@ -16015,8 +16269,7 @@ function getDb() {
       console.warn("[DB] sqlite-vec not available:", err.message);
       vecEnabled = false;
     }
-    const schema = (0, import_fs7.readFileSync)((0, import_path7.resolve)(process.cwd(), "src", "db", "schema.sql"), "utf-8");
-    db.exec(schema);
+    db.exec(SCHEMA_SQL);
     if (vecEnabled) {
       try {
         db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS atom_vectors USING vec0(atom_id TEXT PRIMARY KEY, embedding float[${CONFIG.embeddings.dimension}])`);
@@ -16048,7 +16301,6 @@ var Store2 = class extends Store {
 };
 
 // src/server/MnemosyneServer.ts
-init_config();
 var MnemosyneServer = class {
   store;
   api;
@@ -16056,8 +16308,9 @@ var MnemosyneServer = class {
   httpServer;
   brain;
   constructor(options = {}, brain) {
-    const port = options.port ?? CONFIG.server.port;
-    const host = options.host ?? CONFIG.server.host;
+    const cfg = brain?.config?.config;
+    const port = options.port ?? cfg?.server?.port ?? 7321;
+    const host = options.host ?? cfg?.server?.host ?? "localhost";
     const enableDashboard = options.dashboard !== false;
     const enableWebsocket = options.websocket !== false;
     process.on("uncaughtException", (err) => {
@@ -16085,8 +16338,9 @@ var MnemosyneServer = class {
       const wss = new import_websocket_server.default({ server: this.httpServer });
       this.wsHandler = new WebSocketHandler(wss, this.store);
     }
+    const version = cfg?.server?.version || "2.0.1";
     this.httpServer.listen(port, () => {
-      console.log(`Mnemosyne v${CONFIG.server.version} \u2014 port ${port}`);
+      console.log(`Mnemosyne v${version} \u2014 port ${port}`);
       console.log(`Dashboard: http://${host}:${port}/dashboard`);
       console.log(`API:       http://${host}:${port}/api/v1`);
       console.log(`MCP:       http://${host}:${port}/mcp/manifest`);
@@ -16111,12 +16365,13 @@ var MnemosyneServer = class {
     };
     const dirs = [
       (0, import_path8.resolve)(process.cwd(), "src/dashboard"),
-      (0, import_path8.resolve)(process.cwd(), "dashboard")
+      (0, import_path8.resolve)(process.cwd(), "dashboard"),
+      (0, import_path8.resolve)(__dirname, "../dashboard")
     ];
     for (const dir of dirs) {
       const filePath = (0, import_path8.resolve)(dir, urlPath);
-      if ((0, import_fs8.existsSync)(filePath)) {
-        const data = (0, import_fs8.readFileSync)(filePath);
+      if ((0, import_fs6.existsSync)(filePath)) {
+        const data = (0, import_fs6.readFileSync)(filePath);
         res.writeHead(200, { "Content-Type": mime[ext] || "application/octet-stream" });
         res.end(data);
         return;
@@ -16138,7 +16393,7 @@ var MnemosyneServer = class {
 async function startCommand(options) {
   const dataDir = (0, import_path9.resolve)(options.dataDir);
   const dbPath = (0, import_path9.resolve)(dataDir, "nexus.db");
-  const brain = new Mnemosyne({ dbPath, configPath: options.config });
+  const brain = new Mnemosyne({ dbPath, configPath: options.config, baseDir: dataDir });
   await brain.init();
   if (options.mcpTransport === "stdio" && options.mcp) {
     if (options.verbose) {
@@ -16182,7 +16437,7 @@ ${signal} received. Shutting down...`);
 
 // src/cli/commands/init.ts
 var import_path10 = require("path");
-var import_fs9 = require("fs");
+var import_fs7 = require("fs");
 var DEFAULT_CONFIG = `database:
   path: ./data/nexus.db
   wal: true
@@ -16207,28 +16462,28 @@ server:
 async function initCommand(options) {
   const dataDir = (0, import_path10.resolve)(options.dataDir);
   const configPath = options.config ? (0, import_path10.resolve)(options.config) : (0, import_path10.resolve)(dataDir, "config.yaml");
-  if ((0, import_fs9.existsSync)(dataDir)) {
+  if ((0, import_fs7.existsSync)(dataDir)) {
     console.log(`\u{1F4C1} Data directory already exists: ${dataDir}`);
   } else {
-    (0, import_fs9.mkdirSync)(dataDir, { recursive: true });
+    (0, import_fs7.mkdirSync)(dataDir, { recursive: true });
     console.log(`\u2705 Created data directory: ${dataDir}`);
   }
   for (const sub of ["backups", "files", "exports"]) {
     const dir = (0, import_path10.resolve)(dataDir, sub);
-    if (!(0, import_fs9.existsSync)(dir)) {
-      (0, import_fs9.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_fs7.existsSync)(dir)) {
+      (0, import_fs7.mkdirSync)(dir, { recursive: true });
       console.log(`\u2705 Created ${sub}/`);
     }
   }
-  if (!(0, import_fs9.existsSync)(configPath)) {
-    (0, import_fs9.writeFileSync)(configPath, DEFAULT_CONFIG, "utf-8");
+  if (!(0, import_fs7.existsSync)(configPath)) {
+    (0, import_fs7.writeFileSync)(configPath, DEFAULT_CONFIG, "utf-8");
     console.log(`\u2705 Created config: ${configPath}`);
   } else {
     console.log(`\u{1F4C4} Config already exists: ${configPath}`);
   }
   const dbPath = (0, import_path10.resolve)(dataDir, "nexus.db");
-  if (!(0, import_fs9.existsSync)(dbPath)) {
-    const brain = new Mnemosyne({ dbPath, configPath });
+  if (!(0, import_fs7.existsSync)(dbPath)) {
+    const brain = new Mnemosyne({ dbPath, configPath, baseDir: dataDir });
     await brain.init();
     await brain.close();
     console.log(`\u2705 Initialized database: ${dbPath}`);
@@ -16242,14 +16497,14 @@ async function initCommand(options) {
 
 // src/cli/commands/migrate.ts
 var import_path11 = require("path");
-var import_fs10 = require("fs");
+var import_fs8 = require("fs");
 async function migrateCommand(options) {
   const fromPath = (0, import_path11.resolve)(options.from);
   const toPath = (0, import_path11.resolve)(options.to);
   console.log(`\u{1F504} Migrating v1.0 JSON \u2192 v2.0 SQLite`);
   console.log(`   From: ${fromPath}`);
   console.log(`   To:   ${toPath}`);
-  const raw = (0, import_fs10.readFileSync)(fromPath, "utf-8");
+  const raw = (0, import_fs8.readFileSync)(fromPath, "utf-8");
   const v1 = JSON.parse(raw);
   const brain = new Mnemosyne({ dbPath: toPath });
   await brain.init();
@@ -16300,7 +16555,7 @@ async function migrateCommand(options) {
 
 // src/cli/commands/export.ts
 var import_path12 = require("path");
-var import_fs11 = require("fs");
+var import_fs9 = require("fs");
 async function exportCommand(options) {
   const dataDir = (0, import_path12.resolve)(options.dataDir || "./data");
   const format = options.format || "mnemosyne";
@@ -16316,12 +16571,12 @@ async function exportCommand(options) {
   if (format === "mnemosyne") {
     const buffer = buildMnemosyneExport(project.id, project.name);
     const outPath = output || (0, import_path12.resolve)(`${project.name}.mnemosyne`);
-    (0, import_fs11.writeFileSync)(outPath, buffer);
+    (0, import_fs9.writeFileSync)(outPath, buffer);
     console.log(`\u2705 Exported to ${outPath} (${buffer.length} bytes)`);
   } else if (format === "markdown") {
     const md = exportMarkdown(brain.store, project.id);
     const outPath = output || (0, import_path12.resolve)(`${project.name}.md`);
-    (0, import_fs11.writeFileSync)(outPath, md, "utf-8");
+    (0, import_fs9.writeFileSync)(outPath, md, "utf-8");
     console.log(`\u2705 Exported to ${outPath} (${md.length} chars)`);
   } else {
     console.error(`\u274C Unsupported format: ${format}`);