mnemosyne-core 2.0.0 → 2.0.2

package/dist/server/index.d.mts

@@ -1,111 +1,8 @@
-import * as node_events from 'node:events';
-import * as node_stream_promises from 'node:stream/promises';
-import * as node_stream from 'node:stream';
-import * as node_stream_web from 'node:stream/web';
-import * as node_http from 'node:http';
-import { C as Config, S as Store, P as Project, A as Atom } from '../Store-N3j0Vaj6.mjs';
+export { c as MnemosyneServer, S as ServerOptions } from '../index-B8PTQKy9.mjs';
+import 'node:events';
+import 'node:stream/promises';
+import 'node:stream';
+import 'node:stream/web';
+import 'node:http';
+import '../Store-BtdYuiUx.mjs';
 import 'better-sqlite3';
-
-/**
- * Mnemosyne Configuration
- * Loads config.yaml with a minimal parser. Supports env overrides.
- */
-
-declare class MnemosyneConfig {
-    readonly config: Config;
-    constructor(options?: {
-        configPath?: string;
-        overrides?: Partial<Config>;
-    });
-    get dbPath(): string;
-    get filesDir(): string;
-    get backupsDir(): string;
-}
-
-/**
- * Mnemosyne Core Engine
- * Main orchestrator class. Owns lifecycle (init, close).
- * Store owns SQLite operations. Config owns settings.
- */
-
-interface MnemosyneOptions {
-    dbPath?: string;
-    configPath?: string;
-    autoBackup?: boolean;
-}
-declare class Mnemosyne {
-    store: Store;
-    config: MnemosyneConfig;
-    vecEnabled: boolean;
-    private db;
-    constructor(options?: MnemosyneOptions);
-    init(): Promise<void>;
-    close(): Promise<void>;
-    createProject(name: string, description?: string): Project;
-    createAtom(projectId: string, title: string, type: string, createdBy: string, opts?: Parameters<Store["createAtom"]>[4]): Atom;
-}
-
-interface ServerOptions {
-    port?: number;
-    host?: string;
-    dashboard?: boolean;
-    mcp?: boolean;
-    websocket?: boolean;
-}
-declare class MnemosyneServer {
-    store: Store;
-    private api;
-    private wsHandler?;
-    private httpServer;
-    private brain?;
-    constructor(options?: ServerOptions, brain?: Mnemosyne);
-    private serveDashboard;
-    getHandler(): node_http.Server<typeof node_http.IncomingMessage, {
-        new (req: node_http.IncomingMessage): node_http.ServerResponse<node_http.IncomingMessage>;
-        fromWeb(writableStream: node_stream_web.WritableStream, options?: Pick<node_stream.WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">): node_stream.Writable;
-        toWeb(streamWritable: NodeJS.WritableStream): node_stream_web.WritableStream;
-        promises: typeof node_stream_promises;
-        Stream: typeof node_stream;
-        duplexPair(options?: node_stream.DuplexOptions): [node_stream.Duplex, node_stream.Duplex];
-        addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream>(signal: AbortSignal, stream: T): T;
-        getDefaultHighWaterMark(objectMode: boolean): number;
-        setDefaultHighWaterMark(objectMode: boolean, value: number): void;
-        finished: typeof node_stream.finished;
-        pipeline: typeof node_stream.pipeline;
-        compose(stream: node_stream.ComposeSource<any> | node_stream.ComposeDestination<any>): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, D extends node_stream.ComposeTransform<S, any> | node_stream.ComposeDestination<S>>(source: S, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T extends node_stream.ComposeTransform<S, any>, D extends node_stream.ComposeTransform<T, any> | node_stream.ComposeDestination<T>>(source: S, transform: T, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, D extends node_stream.ComposeTransform<T2, any> | node_stream.ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, D extends node_stream.ComposeTransform<T3, any> | node_stream.ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, T4 extends node_stream.ComposeTransform<T3, any>, D extends node_stream.ComposeTransform<T4, any> | node_stream.ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): node_stream.Duplex;
-        compose(...streams: [node_stream.ComposeSource<any>, ...node_stream.ComposeTransform<any, any>[], node_stream.ComposeDestination<any>]): node_stream.Duplex;
-        isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream): boolean;
-        isReadable(stream: NodeJS.ReadableStream | node_stream_web.ReadableStream): boolean | null;
-        isWritable(stream: NodeJS.WritableStream | node_stream_web.WritableStream): boolean | null;
-        Readable: typeof node_stream.Readable;
-        Writable: typeof node_stream.Writable;
-        Duplex: typeof node_stream.Duplex;
-        Transform: typeof node_stream.Transform;
-        PassThrough: typeof node_stream.PassThrough;
-        EventEmitter: typeof node_events;
-        addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
-        getEventListeners(emitter: node_events, name: string | symbol): ((...args: any[]) => void)[];
-        getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
-        getMaxListeners(emitter: node_events | EventTarget): number;
-        listenerCount(emitter: node_events, eventName: string | symbol): number;
-        listenerCount(emitter: EventTarget, eventName: string): number;
-        on(emitter: node_events, eventName: string | symbol, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
-        on(emitter: EventTarget, eventName: string, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
-        once(emitter: node_events, eventName: string | symbol, options?: node_events.OnceOptions): Promise<any[]>;
-        once(emitter: EventTarget, eventName: string, options?: node_events.OnceOptions): Promise<any[]>;
-        setMaxListeners(n: number, ...eventTargets: ReadonlyArray<node_events | EventTarget>): void;
-        readonly captureRejectionSymbol: typeof node_events.captureRejectionSymbol;
-        captureRejections: boolean;
-        defaultMaxListeners: number;
-        readonly errorMonitor: typeof node_events.errorMonitor;
-        EventEmitterAsyncResource: typeof node_events.EventEmitterAsyncResource;
-    }>;
-    close(): Promise<void>;
-}
-
-export { MnemosyneServer, type ServerOptions };

package/dist/server/index.d.ts

@@ -1,111 +1,8 @@
-import * as node_events from 'node:events';
-import * as node_stream_promises from 'node:stream/promises';
-import * as node_stream from 'node:stream';
-import * as node_stream_web from 'node:stream/web';
-import * as node_http from 'node:http';
-import { C as Config, S as Store, P as Project, A as Atom } from '../Store-N3j0Vaj6.js';
+export { c as MnemosyneServer, S as ServerOptions } from '../index-B2oTMNlL.js';
+import 'node:events';
+import 'node:stream/promises';
+import 'node:stream';
+import 'node:stream/web';
+import 'node:http';
+import '../Store-BtdYuiUx.js';
 import 'better-sqlite3';
-
-/**
- * Mnemosyne Configuration
- * Loads config.yaml with a minimal parser. Supports env overrides.
- */
-
-declare class MnemosyneConfig {
-    readonly config: Config;
-    constructor(options?: {
-        configPath?: string;
-        overrides?: Partial<Config>;
-    });
-    get dbPath(): string;
-    get filesDir(): string;
-    get backupsDir(): string;
-}
-
-/**
- * Mnemosyne Core Engine
- * Main orchestrator class. Owns lifecycle (init, close).
- * Store owns SQLite operations. Config owns settings.
- */
-
-interface MnemosyneOptions {
-    dbPath?: string;
-    configPath?: string;
-    autoBackup?: boolean;
-}
-declare class Mnemosyne {
-    store: Store;
-    config: MnemosyneConfig;
-    vecEnabled: boolean;
-    private db;
-    constructor(options?: MnemosyneOptions);
-    init(): Promise<void>;
-    close(): Promise<void>;
-    createProject(name: string, description?: string): Project;
-    createAtom(projectId: string, title: string, type: string, createdBy: string, opts?: Parameters<Store["createAtom"]>[4]): Atom;
-}
-
-interface ServerOptions {
-    port?: number;
-    host?: string;
-    dashboard?: boolean;
-    mcp?: boolean;
-    websocket?: boolean;
-}
-declare class MnemosyneServer {
-    store: Store;
-    private api;
-    private wsHandler?;
-    private httpServer;
-    private brain?;
-    constructor(options?: ServerOptions, brain?: Mnemosyne);
-    private serveDashboard;
-    getHandler(): node_http.Server<typeof node_http.IncomingMessage, {
-        new (req: node_http.IncomingMessage): node_http.ServerResponse<node_http.IncomingMessage>;
-        fromWeb(writableStream: node_stream_web.WritableStream, options?: Pick<node_stream.WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">): node_stream.Writable;
-        toWeb(streamWritable: NodeJS.WritableStream): node_stream_web.WritableStream;
-        promises: typeof node_stream_promises;
-        Stream: typeof node_stream;
-        duplexPair(options?: node_stream.DuplexOptions): [node_stream.Duplex, node_stream.Duplex];
-        addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream>(signal: AbortSignal, stream: T): T;
-        getDefaultHighWaterMark(objectMode: boolean): number;
-        setDefaultHighWaterMark(objectMode: boolean, value: number): void;
-        finished: typeof node_stream.finished;
-        pipeline: typeof node_stream.pipeline;
-        compose(stream: node_stream.ComposeSource<any> | node_stream.ComposeDestination<any>): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, D extends node_stream.ComposeTransform<S, any> | node_stream.ComposeDestination<S>>(source: S, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T extends node_stream.ComposeTransform<S, any>, D extends node_stream.ComposeTransform<T, any> | node_stream.ComposeDestination<T>>(source: S, transform: T, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, D extends node_stream.ComposeTransform<T2, any> | node_stream.ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, D extends node_stream.ComposeTransform<T3, any> | node_stream.ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): node_stream.Duplex;
-        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, T4 extends node_stream.ComposeTransform<T3, any>, D extends node_stream.ComposeTransform<T4, any> | node_stream.ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): node_stream.Duplex;
-        compose(...streams: [node_stream.ComposeSource<any>, ...node_stream.ComposeTransform<any, any>[], node_stream.ComposeDestination<any>]): node_stream.Duplex;
-        isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream): boolean;
-        isReadable(stream: NodeJS.ReadableStream | node_stream_web.ReadableStream): boolean | null;
-        isWritable(stream: NodeJS.WritableStream | node_stream_web.WritableStream): boolean | null;
-        Readable: typeof node_stream.Readable;
-        Writable: typeof node_stream.Writable;
-        Duplex: typeof node_stream.Duplex;
-        Transform: typeof node_stream.Transform;
-        PassThrough: typeof node_stream.PassThrough;
-        EventEmitter: typeof node_events;
-        addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
-        getEventListeners(emitter: node_events, name: string | symbol): ((...args: any[]) => void)[];
-        getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
-        getMaxListeners(emitter: node_events | EventTarget): number;
-        listenerCount(emitter: node_events, eventName: string | symbol): number;
-        listenerCount(emitter: EventTarget, eventName: string): number;
-        on(emitter: node_events, eventName: string | symbol, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
-        on(emitter: EventTarget, eventName: string, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
-        once(emitter: node_events, eventName: string | symbol, options?: node_events.OnceOptions): Promise<any[]>;
-        once(emitter: EventTarget, eventName: string, options?: node_events.OnceOptions): Promise<any[]>;
-        setMaxListeners(n: number, ...eventTargets: ReadonlyArray<node_events | EventTarget>): void;
-        readonly captureRejectionSymbol: typeof node_events.captureRejectionSymbol;
-        captureRejections: boolean;
-        defaultMaxListeners: number;
-        readonly errorMonitor: typeof node_events.errorMonitor;
-        EventEmitterAsyncResource: typeof node_events.EventEmitterAsyncResource;
-    }>;
-    close(): Promise<void>;
-}
-
-export { MnemosyneServer, type ServerOptions };

package/dist/server/index.js

@@ -3730,9 +3730,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 },
@@ -4533,7 +4546,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync6 = (path) => {
+    var readFileSync5 = (path) => {
       const fd = fs.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -4558,7 +4571,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync6,
+      readFileSync: readFileSync5,
       readFile
     };
   }
@@ -4607,7 +4620,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: readFileSync6 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync5 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -4699,7 +4712,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync6(LDD_PATH);
+        const lddContent = readFileSync5(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -4724,7 +4737,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync6(SELF_PATH);
+        const selfContent = readFileSync5(SELF_PATH);
         const path = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path);
       } catch (e) {
@@ -4788,7 +4801,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync6(LDD_PATH);
+        const lddContent = readFileSync5(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -9605,7 +9618,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/server/MnemosyneServer.ts
 var import_http = require("http");
-var import_fs6 = require("fs");
+var import_fs5 = require("fs");
 var import_path6 = require("path");
 
 // node_modules/ws/wrapper.mjs
@@ -10910,12 +10923,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(),
@@ -12300,9 +12321,219 @@ ${JSON.stringify(analysis.metadata, null, 2)}
 
 // src/db/connection.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-var import_fs5 = require("fs");
 var import_path5 = require("path");
 init_config();
+
+// 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/db/connection.ts
 var DB_PATH2 = process.env.MNEMOSYNE_DB_PATH || (0, import_path5.resolve)(process.cwd(), CONFIG.database.path);
 var db = null;
 var vecEnabled = false;
@@ -12321,8 +12552,7 @@ function getDb() {
       console.warn("[DB] sqlite-vec not available:", err.message);
       vecEnabled = false;
     }
-    const schema = (0, import_fs5.readFileSync)((0, import_path5.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}])`);
@@ -12354,7 +12584,6 @@ var Store2 = class extends Store {
 };
 
 // src/server/MnemosyneServer.ts
-init_config();
 var MnemosyneServer = class {
   store;
   api;
@@ -12362,8 +12591,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) => {
@@ -12391,8 +12621,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`);
@@ -12417,12 +12648,13 @@ var MnemosyneServer = class {
     };
     const dirs = [
       (0, import_path6.resolve)(process.cwd(), "src/dashboard"),
-      (0, import_path6.resolve)(process.cwd(), "dashboard")
+      (0, import_path6.resolve)(process.cwd(), "dashboard"),
+      (0, import_path6.resolve)(__dirname, "../dashboard")
     ];
     for (const dir of dirs) {
       const filePath = (0, import_path6.resolve)(dir, urlPath);
-      if ((0, import_fs6.existsSync)(filePath)) {
-        const data = (0, import_fs6.readFileSync)(filePath);
+      if ((0, import_fs5.existsSync)(filePath)) {
+        const data = (0, import_fs5.readFileSync)(filePath);
         res.writeHead(200, { "Content-Type": mime[ext] || "application/octet-stream" });
         res.end(data);
         return;