@titan-design/brain 0.3.0 → 0.5.0

package/dist/chunk-QL2GPXP6.js

@@ -0,0 +1,1803 @@
+import {
+  createEmbedder
+} from "./chunk-BDNH2E2O.js";
+import {
+  addFrontmatterField
+} from "./chunk-4SD4JRLS.js";
+
+// src/services/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { homedir } from "os";
+var GLOBAL_BRAIN_DIR = join(homedir(), ".brain");
+function parentResolveOpts(cmd) {
+  const parent = cmd.parent?.opts();
+  return {
+    forceGlobal: parent?.global,
+    instancePath: parent?.instance
+  };
+}
+var VALID_EMBEDDERS = ["local", "ollama", "remote"];
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function validateConfig(config) {
+  if (config.embedder !== void 0 && !VALID_EMBEDDERS.includes(config.embedder)) {
+    throw new Error(
+      `Invalid embedder "${config.embedder}". Must be one of: ${VALID_EMBEDDERS.join(", ")}`
+    );
+  }
+  if (config.fusionWeights !== void 0) {
+    const sum = config.fusionWeights.bm25 + config.fusionWeights.vector;
+    if (Math.abs(sum - 1) > 1e-6) {
+      throw new Error(
+        `Fusion weights must sum to 1.0, got ${sum} (bm25: ${config.fusionWeights.bm25}, vector: ${config.fusionWeights.vector})`
+      );
+    }
+  }
+}
+function resolveInstance(opts = {}) {
+  if (opts.instancePath) {
+    return { root: resolve(opts.instancePath), isLocal: true, source: "flag:--instance" };
+  }
+  if (opts.forceGlobal) {
+    return { root: GLOBAL_BRAIN_DIR, isLocal: false, source: "flag:--global" };
+  }
+  let dir = resolve(opts.cwd ?? process.cwd());
+  while (true) {
+    const candidate = join(dir, ".brain");
+    if (existsSync(candidate)) {
+      return { root: candidate, isLocal: true, source: `local:${candidate}` };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { root: GLOBAL_BRAIN_DIR, isLocal: false, source: "global" };
+}
+function getConfigDir(override) {
+  const dir = override ?? GLOBAL_BRAIN_DIR;
+  ensureDir(dir);
+  return dir;
+}
+function getDataDir(override) {
+  const dir = override ?? GLOBAL_BRAIN_DIR;
+  ensureDir(dir);
+  return dir;
+}
+function getConfigPath(instanceRoot) {
+  const root = instanceRoot ?? GLOBAL_BRAIN_DIR;
+  ensureDir(root);
+  return join(root, "config.json");
+}
+function getDefaultConfig(instanceRoot) {
+  const root = instanceRoot ?? GLOBAL_BRAIN_DIR;
+  return {
+    notesDir: join(homedir(), "brain"),
+    dbPath: join(root, "brain.db"),
+    embedder: "local",
+    fusionWeights: { bm25: 0.3, vector: 0.7 }
+  };
+}
+function loadConfig(instance) {
+  const globalDefaults = getDefaultConfig(GLOBAL_BRAIN_DIR);
+  const globalPath = getConfigPath(GLOBAL_BRAIN_DIR);
+  let config = { ...globalDefaults };
+  if (existsSync(globalPath)) {
+    const raw = JSON.parse(readFileSync(globalPath, "utf-8"));
+    config = {
+      ...config,
+      ...raw,
+      fusionWeights: { ...config.fusionWeights, ...raw.fusionWeights }
+    };
+  }
+  if (instance && instance.isLocal) {
+    const localDefaults = getDefaultConfig(instance.root);
+    config.dbPath = localDefaults.dbPath;
+    config.notesDir = join(instance.root, "notes");
+    const localPath = getConfigPath(instance.root);
+    if (existsSync(localPath)) {
+      const raw = JSON.parse(readFileSync(localPath, "utf-8"));
+      config = {
+        ...config,
+        ...raw,
+        fusionWeights: { ...config.fusionWeights, ...raw.fusionWeights }
+      };
+    }
+  }
+  return config;
+}
+function saveConfig(config, instanceRoot) {
+  validateConfig(config);
+  const root = instanceRoot ?? GLOBAL_BRAIN_DIR;
+  const filePath = getConfigPath(root);
+  const defaults = getDefaultConfig(root);
+  let existing;
+  if (existsSync(filePath)) {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    existing = {
+      ...defaults,
+      ...raw,
+      fusionWeights: { ...defaults.fusionWeights, ...raw.fusionWeights }
+    };
+  } else {
+    existing = defaults;
+  }
+  const merged = {
+    ...existing,
+    ...config,
+    fusionWeights: { ...existing.fusionWeights, ...config.fusionWeights }
+  };
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+
+// src/services/brain-db.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { mkdirSync as mkdirSync2, renameSync, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2, relative } from "path";
+
+// src/services/repos/note-repo.ts
+var NoteRepo = class {
+  constructor(db, ensureVectorTable) {
+    this.db = db;
+    this.ensureVectorTable = ensureVectorTable;
+  }
+  // --- Note CRUD ---
+  upsertNote(record) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO notes
+          (id, file_path, title, type, tier, category, tags, summary, confidence, status, sources, created_at, modified_at, last_reviewed, review_interval, expires, metadata, module, module_instance, content_dir)
+        VALUES
+          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      record.id,
+      record.filePath,
+      record.title,
+      record.type,
+      record.tier,
+      record.category,
+      record.tags,
+      record.summary,
+      record.confidence,
+      record.status,
+      record.sources,
+      record.createdAt,
+      record.modifiedAt,
+      record.lastReviewed,
+      record.reviewInterval,
+      record.expires,
+      record.metadata,
+      record.module,
+      record.moduleInstance,
+      record.contentDir
+    );
+    return record;
+  }
+  getNoteById(id) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE id = ?").get(id);
+    return row ? rowToNoteRecord(row) : null;
+  }
+  getNotesByIds(ids) {
+    if (ids.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(`SELECT * FROM notes WHERE id IN (${placeholders})`).all(...ids);
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      map.set(row.id, rowToNoteRecord(row));
+    }
+    return map;
+  }
+  getAllNotes() {
+    const rows = this.db.prepare("SELECT * FROM notes").all();
+    return rows.map(rowToNoteRecord);
+  }
+  getNoteCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM notes").get();
+    return row.count;
+  }
+  getNoteByFilePath(filePath) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE file_path = ?").get(filePath);
+    return row ? rowToNoteRecord(row) : null;
+  }
+  // --- File Tracking ---
+  upsertFile(record) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO files (path, hash, mtime, indexed_at)
+         VALUES (?, ?, ?, ?)`
+    ).run(record.path, record.hash, record.mtime, record.indexedAt);
+  }
+  getFile(path) {
+    const row = this.db.prepare("SELECT * FROM files WHERE path = ?").get(path);
+    return row ? rowToFileRecord(row) : null;
+  }
+  getAllFiles() {
+    const rows = this.db.prepare("SELECT * FROM files").all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const rec = rowToFileRecord(row);
+      map.set(rec.path, rec);
+    }
+    return map;
+  }
+  deleteFile(path) {
+    this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
+  }
+  // --- Chunk + Vector Operations ---
+  upsertChunks(noteId, chunks, embeddings) {
+    if (chunks.length !== embeddings.length) {
+      throw new Error(
+        `upsertChunks: chunks (${chunks.length}) and embeddings (${embeddings.length}) length mismatch`
+      );
+    }
+    if (embeddings.length > 0) {
+      this.ensureVectorTable(embeddings[0].length);
+    }
+    this.deleteChunksForNote(noteId);
+    const insertChunk = this.db.prepare(
+      `INSERT INTO chunks (id, note_id, heading, heading_ancestry, content, token_count, chunk_type, cut_type, position)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insertVector = this.db.prepare(
+      `INSERT INTO chunk_vectors (chunk_id, embedding)
+       VALUES (?, ?)`
+    );
+    const txn = this.db.transaction(() => {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        insertChunk.run(
+          chunk.id,
+          noteId,
+          chunk.heading,
+          chunk.headingAncestry,
+          chunk.content,
+          chunk.tokenCount,
+          chunk.chunkType,
+          chunk.cutType,
+          chunk.position
+        );
+        insertVector.run(chunk.id, Buffer.from(embeddings[i].buffer));
+      }
+    });
+    txn();
+  }
+  getChunksForNote(noteId) {
+    const rows = this.db.prepare("SELECT * FROM chunks WHERE note_id = ? ORDER BY rowid").all(noteId);
+    return rows.map(rowToChunk);
+  }
+  getChunkCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+    return row.count;
+  }
+  deleteChunksForNote(noteId) {
+    const chunkIds = this.db.prepare("SELECT id FROM chunks WHERE note_id = ?").all(noteId);
+    if (chunkIds.length > 0) {
+      const deleteVec = this.db.prepare("DELETE FROM chunk_vectors WHERE chunk_id = ?");
+      const txn = this.db.transaction(() => {
+        for (const { id } of chunkIds) {
+          deleteVec.run(id);
+        }
+      });
+      txn();
+    }
+    this.db.prepare("DELETE FROM chunks WHERE note_id = ?").run(noteId);
+  }
+  getChunkContent(chunkId) {
+    const row = this.db.prepare("SELECT content FROM chunks WHERE id = ?").get(chunkId);
+    return row?.content ?? "";
+  }
+  getFirstChunkForNote(noteId) {
+    const row = this.db.prepare("SELECT content, heading FROM chunks WHERE note_id = ? ORDER BY rowid LIMIT 1").get(noteId);
+    return row ?? null;
+  }
+  getChunkEmbedding(chunkId) {
+    const row = this.db.prepare("SELECT embedding FROM chunk_vectors WHERE chunk_id = ?").get(chunkId);
+    if (!row) return null;
+    return new Float32Array(
+      row.embedding.buffer,
+      row.embedding.byteOffset,
+      row.embedding.byteLength / 4
+    );
+  }
+  getChunkHeading(chunkId, noteId) {
+    if (chunkId) {
+      const row2 = this.db.prepare("SELECT heading FROM chunks WHERE id = ?").get(chunkId);
+      if (row2?.heading) return row2.heading;
+    }
+    const row = this.db.prepare("SELECT heading FROM chunks WHERE note_id = ? ORDER BY rowid LIMIT 1").get(noteId);
+    return row?.heading ?? null;
+  }
+  // --- Relations ---
+  upsertRelations(noteId, relations) {
+    const txn = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM relations WHERE source_id = ?").run(noteId);
+      const insert = this.db.prepare(
+        `INSERT INTO relations (source_id, target_id, type, created_at)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const rel of relations) {
+        insert.run(rel.sourceId, rel.targetId, rel.type, Date.now());
+      }
+    });
+    txn();
+  }
+  getRelationsFrom(noteId) {
+    const rows = this.db.prepare("SELECT source_id, target_id, type FROM relations WHERE source_id = ?").all(noteId);
+    return rows.map(rowToRelation);
+  }
+  getRelationsTo(noteId) {
+    const rows = this.db.prepare("SELECT source_id, target_id, type FROM relations WHERE target_id = ?").all(noteId);
+    return rows.map(rowToRelation);
+  }
+  getRelationsBatch(ids) {
+    if (ids.length === 0) return /* @__PURE__ */ new Map();
+    const result = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      result.set(id, { from: [], to: [] });
+    }
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT source_id, target_id, type FROM relations WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`
+    ).all(...ids, ...ids);
+    for (const row of rows) {
+      const rel = rowToRelation(row);
+      result.get(rel.sourceId)?.from.push(rel);
+      result.get(rel.targetId)?.to.push(rel);
+    }
+    return result;
+  }
+  getRelationsFiltered(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts.module) {
+      conditions.push("module = ?");
+      params.push(opts.module);
+    }
+    if (opts.moduleInstance) {
+      conditions.push("module_instance = ?");
+      params.push(opts.moduleInstance);
+    }
+    if (opts.type) {
+      conditions.push("type = ?");
+      params.push(opts.type);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT source_id, target_id, type FROM relations ${where}`).all(...params);
+    return rows.map(rowToRelation);
+  }
+  // --- Lineage ---
+  getDescendants(noteId, maxDepth) {
+    const depthLimit = maxDepth ?? 100;
+    const rows = this.db.prepare(
+      `
+      WITH RECURSIVE descendants(id, depth) AS (
+        SELECT source_id, 1 FROM relations
+        WHERE target_id = ? AND type = 'derived-from'
+        UNION ALL
+        SELECT r.source_id, d.depth + 1 FROM relations r
+        JOIN descendants d ON r.target_id = d.id
+        WHERE r.type = 'derived-from' AND d.depth < ?
+      )
+      SELECT id, depth FROM descendants
+    `
+    ).all(noteId, depthLimit);
+    return rows;
+  }
+  // --- Access Tracking ---
+  recordAccess(noteId, event) {
+    this.db.prepare("INSERT INTO note_access (note_id, event, created_at) VALUES (?, ?, ?)").run(noteId, event, Date.now());
+  }
+  getAccessCount(noteId) {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM note_access WHERE note_id = ?").get(noteId);
+    return row.count;
+  }
+  getAccessCounts(noteIds) {
+    if (noteIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = noteIds.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT note_id, COUNT(*) as count FROM note_access
+       WHERE note_id IN (${placeholders}) GROUP BY note_id`
+    ).all(...noteIds);
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      map.set(row.note_id, row.count);
+    }
+    return map;
+  }
+  // --- FTS ---
+  upsertNoteFTS(noteId, title, summary, content) {
+    this.db.prepare("DELETE FROM notes_fts WHERE note_id = ?").run(noteId);
+    this.db.prepare("INSERT INTO notes_fts (note_id, title, summary, content) VALUES (?, ?, ?, ?)").run(noteId, title, summary, content);
+  }
+  searchFTS(query, limit) {
+    if (!query.trim()) return [];
+    const sanitized = sanitizeFtsQuery(query);
+    if (!sanitized) return [];
+    const rows = this.db.prepare(
+      `SELECT note_id as noteId, rank
+         FROM notes_fts
+         WHERE notes_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(sanitized, limit);
+    return rows;
+  }
+  // --- Search ---
+  searchVector(embedding, limit) {
+    try {
+      return this.db.prepare(
+        `SELECT cv.chunk_id as chunkId, c.note_id as noteId, cv.distance
+         FROM chunk_vectors cv
+         JOIN chunks c ON c.id = cv.chunk_id
+         WHERE embedding MATCH ? AND k = ?
+         ORDER BY distance`
+      ).all(Buffer.from(embedding.buffer), limit);
+    } catch {
+      return [];
+    }
+  }
+  getFilteredNoteIds(filters) {
+    const conditions = [];
+    const params = [];
+    if (filters.tier) {
+      conditions.push("tier = ?");
+      params.push(filters.tier);
+    }
+    if (filters.category) {
+      conditions.push("category = ?");
+      params.push(filters.category);
+    }
+    if (filters.confidence) {
+      conditions.push("confidence = ?");
+      params.push(filters.confidence);
+    }
+    if (filters.since) {
+      conditions.push("modified_at >= ?");
+      params.push(filters.since);
+    }
+    if (filters.tags?.length) {
+      conditions.push(
+        `(${filters.tags.map(() => "',' || tags || ',' LIKE '%,' || ? || ',%'").join(" AND ")})`
+      );
+      for (const tag of filters.tags) params.push(tag);
+    }
+    if (conditions.length === 0) return null;
+    const rows = this.db.prepare(`SELECT id FROM notes WHERE ${conditions.join(" AND ")}`).all(...params);
+    return new Set(rows.map((r) => r.id));
+  }
+  getFilteredNoteIdsByMetadata(filters, baseIds) {
+    if (filters.length === 0) return baseIds ?? /* @__PURE__ */ new Set();
+    let ids = baseIds ?? null;
+    for (const filter of filters) {
+      const typeRow = this.db.prepare(
+        `SELECT json_type(metadata, '$.' || ?) AS jt FROM notes
+           WHERE metadata IS NOT NULL AND json_extract(metadata, '$.' || ?) IS NOT NULL LIMIT 1`
+      ).get(filter.field, filter.field);
+      const isArray = typeRow?.jt === "array";
+      let rows;
+      if (isArray) {
+        const sql = ids ? `SELECT n.id FROM notes n, json_each(json_extract(n.metadata, '$.' || ?)) AS je
+             WHERE CAST(je.value AS TEXT) = ? AND n.id IN (SELECT value FROM json_each(?))` : `SELECT n.id FROM notes n, json_each(json_extract(n.metadata, '$.' || ?)) AS je
+             WHERE CAST(je.value AS TEXT) = ?`;
+        rows = ids ? this.db.prepare(sql).all(filter.field, filter.value, JSON.stringify([...ids])) : this.db.prepare(sql).all(filter.field, filter.value);
+      } else {
+        const sql = ids ? `SELECT id FROM notes WHERE json_extract(metadata, '$.' || ?) = ?
+             AND id IN (SELECT value FROM json_each(?))` : `SELECT id FROM notes WHERE json_extract(metadata, '$.' || ?) = ?`;
+        rows = ids ? this.db.prepare(sql).all(filter.field, filter.value, JSON.stringify([...ids])) : this.db.prepare(sql).all(filter.field, filter.value);
+      }
+      ids = new Set(rows.map((r) => r.id));
+    }
+    return ids ?? /* @__PURE__ */ new Set();
+  }
+  getFacetCounts(field, noteIds) {
+    if (noteIds.size === 0) return [];
+    const idsJson = JSON.stringify([...noteIds]);
+    const typeRow = this.db.prepare(
+      `SELECT json_type(metadata, '$.' || ?) AS jt FROM notes
+         WHERE metadata IS NOT NULL AND json_extract(metadata, '$.' || ?) IS NOT NULL
+         AND id IN (SELECT value FROM json_each(?)) LIMIT 1`
+    ).get(field, field, idsJson);
+    const isArray = typeRow?.jt === "array";
+    if (isArray) {
+      return this.db.prepare(
+        `SELECT CAST(je.value AS TEXT) AS value, COUNT(DISTINCT n.id) AS count
+           FROM notes n, json_each(json_extract(n.metadata, '$.' || ?)) AS je
+           WHERE n.id IN (SELECT value FROM json_each(?))
+           GROUP BY je.value ORDER BY count DESC, CAST(je.value AS TEXT) ASC`
+      ).all(field, idsJson);
+    }
+    return this.db.prepare(
+      `SELECT CAST(json_extract(metadata, '$.' || ?) AS TEXT) AS value, COUNT(*) AS count
+         FROM notes
+         WHERE id IN (SELECT value FROM json_each(?))
+         AND metadata IS NOT NULL AND json_extract(metadata, '$.' || ?) IS NOT NULL
+         GROUP BY value ORDER BY count DESC`
+    ).all(field, idsJson, field);
+  }
+  getModuleNoteIds(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.module) {
+      conditions.push("module = ?");
+      params.push(filter.module);
+    }
+    if (filter.moduleInstance) {
+      conditions.push("module_instance = ?");
+      params.push(filter.moduleInstance);
+    }
+    if (filter.type) {
+      conditions.push("type = ?");
+      params.push(filter.type);
+    }
+    if (filter.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT id FROM notes ${where}`).all(...params);
+    return rows.map((r) => r.id);
+  }
+};
+function sanitizeFtsQuery(query) {
+  return query.split(/\s+/).filter(Boolean).map((term) => `"${term.replace(/"/g, '""')}"`).join(" ");
+}
+function rowToNoteRecord(row) {
+  return {
+    id: row.id,
+    filePath: row.file_path,
+    title: row.title,
+    type: row.type,
+    tier: row.tier,
+    category: row.category,
+    tags: row.tags,
+    summary: row.summary,
+    confidence: row.confidence,
+    status: row.status ?? "current",
+    sources: row.sources,
+    createdAt: row.created_at,
+    modifiedAt: row.modified_at,
+    lastReviewed: row.last_reviewed,
+    reviewInterval: row.review_interval,
+    expires: row.expires,
+    metadata: row.metadata,
+    module: row.module ?? null,
+    moduleInstance: row.module_instance ?? null,
+    contentDir: row.content_dir ?? null
+  };
+}
+function rowToFileRecord(row) {
+  return {
+    path: row.path,
+    hash: row.hash,
+    mtime: row.mtime,
+    indexedAt: row.indexed_at
+  };
+}
+function rowToChunk(row) {
+  return {
+    id: row.id,
+    noteId: row.note_id,
+    heading: row.heading,
+    headingAncestry: row.heading_ancestry,
+    content: row.content,
+    tokenCount: row.token_count,
+    chunkType: row.chunk_type ?? "section",
+    cutType: row.cut_type ?? "heading_boundary",
+    position: row.position ?? 0
+  };
+}
+function rowToRelation(row) {
+  return {
+    sourceId: row.source_id,
+    targetId: row.target_id,
+    type: row.type
+  };
+}
+
+// src/services/repos/memory-repo.ts
+function rowToMemoryEntry(row) {
+  return {
+    id: row.id,
+    memory: row.memory,
+    sourceNoteId: row.source_note_id,
+    sourceChunkId: row.source_chunk_id,
+    containerTag: row.container_tag,
+    isLatest: row.is_latest === 1,
+    parentMemoryId: row.parent_memory_id,
+    rootMemoryId: row.root_memory_id,
+    relationType: row.relation_type,
+    validAt: row.valid_at,
+    invalidAt: row.invalid_at,
+    forgetAfter: row.forget_after,
+    isForgotten: row.is_forgotten === 1,
+    isInference: row.is_inference === 1,
+    createdAt: row.created_at
+  };
+}
+function rowToMemoryHistory(row) {
+  return {
+    id: row.id,
+    memoryId: row.memory_id,
+    event: row.event,
+    oldMemory: row.old_memory,
+    newMemory: row.new_memory,
+    actor: row.actor,
+    createdAt: row.created_at
+  };
+}
+var MemoryRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  queryLatestMemories(baseWhere, baseParams, containerTag) {
+    const where = containerTag ? `${baseWhere} AND container_tag = ?` : baseWhere;
+    const params = containerTag ? [...baseParams, containerTag] : baseParams;
+    const rows = this.db.prepare(`SELECT * FROM memory_entries WHERE ${where} ORDER BY created_at DESC`).all(...params);
+    return rows.map(rowToMemoryEntry);
+  }
+  addMemory(entry) {
+    this.db.prepare(
+      `INSERT INTO memory_entries
+          (id, memory, source_note_id, source_chunk_id, container_tag,
+           is_latest, parent_memory_id, root_memory_id, relation_type,
+           valid_at, invalid_at, forget_after, is_forgotten, is_inference, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      entry.id,
+      entry.memory,
+      entry.sourceNoteId,
+      entry.sourceChunkId,
+      entry.containerTag,
+      entry.isLatest ? 1 : 0,
+      entry.parentMemoryId,
+      entry.rootMemoryId,
+      entry.relationType,
+      entry.validAt,
+      entry.invalidAt,
+      entry.forgetAfter,
+      entry.isForgotten ? 1 : 0,
+      entry.isInference ? 1 : 0,
+      entry.createdAt
+    );
+  }
+  getMemory(id) {
+    const row = this.db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(id);
+    return row ? rowToMemoryEntry(row) : null;
+  }
+  getMemoriesForNote(noteId) {
+    const rows = this.db.prepare(
+      "SELECT * FROM memory_entries WHERE source_note_id = ? AND is_latest = 1 ORDER BY created_at"
+    ).all(noteId);
+    return rows.map(rowToMemoryEntry);
+  }
+  getLatestMemories(containerTag) {
+    return this.queryLatestMemories("is_latest = 1 AND is_forgotten = 0", [], containerTag);
+  }
+  getMemoryVersionChain(rootId) {
+    const rows = this.db.prepare(
+      "SELECT * FROM memory_entries WHERE root_memory_id = ? OR id = ? ORDER BY created_at"
+    ).all(rootId, rootId);
+    return rows.map(rowToMemoryEntry);
+  }
+  markMemorySuperseded(id) {
+    this.db.prepare("UPDATE memory_entries SET is_latest = 0 WHERE id = ?").run(id);
+  }
+  deleteMemoriesForNote(noteId) {
+    const memoryIds = this.db.prepare("SELECT id FROM memory_entries WHERE source_note_id = ?").all(noteId);
+    if (memoryIds.length > 0) {
+      const deleteVector = this.db.prepare("DELETE FROM memory_vectors WHERE memory_id = ?");
+      const deleteHistory = this.db.prepare("DELETE FROM memory_history WHERE memory_id = ?");
+      const txn = this.db.transaction(() => {
+        for (const { id } of memoryIds) {
+          deleteVector.run(id);
+          deleteHistory.run(id);
+        }
+      });
+      txn();
+    }
+    this.db.prepare("DELETE FROM memory_entries WHERE source_note_id = ?").run(noteId);
+  }
+  forgetExpiredMemories() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const expired = this.db.prepare(
+      "SELECT id, memory FROM memory_entries WHERE forget_after IS NOT NULL AND forget_after <= ? AND is_forgotten = 0 AND is_latest = 1"
+    ).all(now);
+    if (expired.length === 0) return 0;
+    const update = this.db.prepare("UPDATE memory_entries SET is_forgotten = 1 WHERE id = ?");
+    const insertHistory = this.db.prepare(
+      `INSERT INTO memory_history (memory_id, event, old_memory, new_memory, actor, created_at)
+       VALUES (?, 'forget', ?, NULL, 'system', ?)`
+    );
+    const txn = this.db.transaction(() => {
+      for (const { id, memory } of expired) {
+        update.run(id);
+        insertHistory.run(id, memory, now);
+      }
+    });
+    txn();
+    return expired.length;
+  }
+  getMemoriesSince(since, containerTag) {
+    return this.queryLatestMemories("created_at >= ? AND is_latest = 1", [since], containerTag);
+  }
+  getMemoryCount() {
+    const row = this.db.prepare(
+      "SELECT COUNT(*) as count FROM memory_entries WHERE is_latest = 1 AND is_forgotten = 0"
+    ).get();
+    return row.count;
+  }
+  getMemoriesByIds(ids) {
+    if (ids.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(`SELECT * FROM memory_entries WHERE id IN (${placeholders})`).all(...ids);
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      map.set(row.id, rowToMemoryEntry(row));
+    }
+    return map;
+  }
+  addMemoryHistory(entry) {
+    this.db.prepare(
+      `INSERT INTO memory_history (memory_id, event, old_memory, new_memory, actor, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      entry.memoryId,
+      entry.event,
+      entry.oldMemory,
+      entry.newMemory,
+      entry.actor,
+      entry.createdAt
+    );
+  }
+  getMemoryHistory(memoryId) {
+    const rows = this.db.prepare("SELECT * FROM memory_history WHERE memory_id = ? ORDER BY created_at").all(memoryId);
+    return rows.map(rowToMemoryHistory);
+  }
+  deleteMemoryVector(memoryId) {
+    this.db.prepare("DELETE FROM memory_vectors WHERE memory_id = ?").run(memoryId);
+  }
+  upsertMemoryVector(memoryId, embedding) {
+    this.db.prepare("DELETE FROM memory_vectors WHERE memory_id = ?").run(memoryId);
+    this.db.prepare("INSERT INTO memory_vectors (memory_id, embedding) VALUES (?, ?)").run(memoryId, Buffer.from(embedding.buffer));
+  }
+  searchMemoryVectors(embedding, limit) {
+    try {
+      return this.db.prepare(
+        `SELECT memory_id as memoryId, distance
+           FROM memory_vectors
+           WHERE embedding MATCH ? AND k = ?
+           ORDER BY distance`
+      ).all(Buffer.from(embedding.buffer), limit);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/services/repos/capture-repo.ts
+function rowToInboxItem(row) {
+  return {
+    id: row.id,
+    content: row.content,
+    title: row.title,
+    source: row.source,
+    sourceUrl: row.source_url,
+    sourceMeta: row.source_meta,
+    status: row.status,
+    createdAt: row.created_at,
+    processedAt: row.processed_at
+  };
+}
+function rowToFeedRecord(row) {
+  return {
+    id: row.id,
+    url: row.url,
+    name: row.name,
+    containerTag: row.container_tag,
+    filterPrompt: row.filter_prompt,
+    lastPolled: row.last_polled,
+    createdAt: row.created_at
+  };
+}
+var CaptureRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  // --- Inbox ---
+  addInboxItem(item) {
+    this.db.prepare(
+      `INSERT INTO inbox (id, content, title, source, source_url, source_meta, status, created_at, processed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      item.id,
+      item.content,
+      item.title,
+      item.source,
+      item.sourceUrl,
+      item.sourceMeta,
+      item.status,
+      item.createdAt,
+      item.processedAt
+    );
+  }
+  getInboxItems(status) {
+    if (status) {
+      const rows2 = this.db.prepare("SELECT * FROM inbox WHERE status = ? ORDER BY created_at DESC").all(status);
+      return rows2.map(rowToInboxItem);
+    }
+    const rows = this.db.prepare("SELECT * FROM inbox ORDER BY created_at DESC").all();
+    return rows.map(rowToInboxItem);
+  }
+  getInboxItem(id) {
+    const row = this.db.prepare("SELECT * FROM inbox WHERE id = ?").get(id);
+    return row ? rowToInboxItem(row) : null;
+  }
+  updateInboxStatus(id, status) {
+    const processedAt = status === "indexed" || status === "failed" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    this.db.prepare("UPDATE inbox SET status = ?, processed_at = COALESCE(?, processed_at) WHERE id = ?").run(status, processedAt, id);
+  }
+  deleteInboxItem(id) {
+    this.db.prepare("DELETE FROM inbox WHERE id = ?").run(id);
+  }
+  // --- Feeds ---
+  addFeed(feed) {
+    this.db.prepare(
+      `INSERT INTO feeds (id, url, name, container_tag, filter_prompt, last_polled, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      feed.id,
+      feed.url,
+      feed.name,
+      feed.containerTag,
+      feed.filterPrompt,
+      feed.lastPolled,
+      feed.createdAt
+    );
+  }
+  getFeeds() {
+    const rows = this.db.prepare("SELECT * FROM feeds ORDER BY name").all();
+    return rows.map(rowToFeedRecord);
+  }
+  getFeedById(id) {
+    const row = this.db.prepare("SELECT * FROM feeds WHERE id = ?").get(id);
+    return row ? rowToFeedRecord(row) : null;
+  }
+  removeFeed(id) {
+    this.db.prepare("DELETE FROM feeds WHERE id = ?").run(id);
+  }
+  updateFeedLastPolled(id, lastPolled) {
+    this.db.prepare("UPDATE feeds SET last_polled = ? WHERE id = ?").run(lastPolled, id);
+  }
+};
+
+// src/services/repos/activity-repo.ts
+function rowToActivityRecord(row) {
+  return {
+    id: row.id,
+    noteIds: row.note_ids,
+    module: row.module,
+    moduleInstance: row.module_instance,
+    activityType: row.activity_type,
+    actorType: row.actor_type,
+    actorId: row.actor_id,
+    sessionId: row.session_id,
+    metadata: row.metadata,
+    outcome: row.outcome,
+    startedAt: row.started_at,
+    completedAt: row.completed_at
+  };
+}
+var ActivityRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  addActivity(record) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO activities
+          (id, note_ids, module, module_instance, activity_type, actor_type, actor_id, session_id, metadata, outcome, started_at, completed_at)
+        VALUES
+          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      record.id,
+      record.noteIds,
+      record.module,
+      record.moduleInstance,
+      record.activityType,
+      record.actorType,
+      record.actorId,
+      record.sessionId,
+      record.metadata,
+      record.outcome,
+      record.startedAt,
+      record.completedAt
+    );
+  }
+  getActivity(id) {
+    const row = this.db.prepare("SELECT * FROM activities WHERE id = ?").get(id);
+    return row ? rowToActivityRecord(row) : null;
+  }
+  getActivities(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts?.module) {
+      conditions.push("module = ?");
+      params.push(opts.module);
+    }
+    if (opts?.moduleInstance) {
+      conditions.push("module_instance = ?");
+      params.push(opts.moduleInstance);
+    }
+    if (opts?.activityType) {
+      conditions.push("activity_type = ?");
+      params.push(opts.activityType);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM activities ${where}`).all(...params);
+    return rows.map(rowToActivityRecord);
+  }
+  getActivitiesByNoteId(noteId) {
+    const rows = this.db.prepare(`SELECT * FROM activities WHERE note_ids LIKE '%' || ? || '%'`).all(noteId);
+    return rows.map(rowToActivityRecord).filter((a) => {
+      if (!a.noteIds) return false;
+      try {
+        const ids = JSON.parse(a.noteIds);
+        return ids.includes(noteId);
+      } catch {
+        return false;
+      }
+    });
+  }
+  getActivitiesBySession(sessionId) {
+    const rows = this.db.prepare("SELECT * FROM activities WHERE session_id = ?").all(sessionId);
+    return rows.map(rowToActivityRecord);
+  }
+};
+
+// src/services/brain-db.ts
+var SCHEMA_VERSION = 8;
+var BrainDB = class {
+  db;
+  vectorDimensions = null;
+  noteRepo;
+  memoryRepo;
+  captureRepo;
+  activityRepo;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    sqliteVec.load(this.db);
+    this.migrate();
+    this.noteRepo = new NoteRepo(this.db, (dims) => this.ensureVectorTable(dims));
+    this.memoryRepo = new MemoryRepo(this.db);
+    this.captureRepo = new CaptureRepo(this.db);
+    this.activityRepo = new ActivityRepo(this.db);
+  }
+  close() {
+    this.db.close();
+  }
+  // --- Schema Migration ---
+  applyMigration(current, target, fn) {
+    if (current >= 1 && current < target) {
+      fn();
+      this.db.pragma(`user_version = ${target}`);
+      this.setMetaValue("schema_version", String(target));
+    }
+  }
+  migrate() {
+    const currentVersion = this.db.pragma("user_version", { simple: true });
+    if (currentVersion < 1) {
+      this.db.exec(this.schemaV1());
+      this.db.pragma(`user_version = ${SCHEMA_VERSION}`);
+      this.setMetaValue("schema_version", String(SCHEMA_VERSION));
+    }
+    this.applyMigration(
+      currentVersion,
+      2,
+      () => this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_note_id ON chunks(note_id)")
+    );
+    this.applyMigration(currentVersion, 3, () => this.migrateToV3());
+    this.applyMigration(currentVersion, 4, () => this.db.exec(this.captureDDL()));
+    this.applyMigration(currentVersion, 5, () => this.db.exec(this.memoryDDL()));
+    this.applyMigration(currentVersion, 6, () => this.db.exec(this.noteAccessDDL()));
+    this.applyMigration(currentVersion, 7, () => this.migrateToV7());
+    this.applyMigration(currentVersion, 8, () => this.migrateToV8());
+    const dims = this.getMetaValue("embedding_dimensions");
+    if (dims) {
+      this.ensureVectorTable(Number(dims));
+    }
+  }
+  ensureVectorTable(dimensions) {
+    if (this.vectorDimensions === dimensions) return;
+    const existing = this.getMetaValue("embedding_dimensions");
+    if (existing && Number(existing) !== dimensions) {
+      this.db.exec("DROP TABLE IF EXISTS chunk_vectors");
+      this.db.exec("DROP TABLE IF EXISTS memory_vectors");
+    }
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+        chunk_id TEXT PRIMARY KEY,
+        embedding float[${dimensions}]
+      )
+    `);
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_vectors USING vec0(
+        memory_id TEXT PRIMARY KEY,
+        embedding float[${dimensions}]
+      )
+    `);
+    this.vectorDimensions = dimensions;
+  }
+  captureDDL() {
+    return `
+      CREATE TABLE IF NOT EXISTS inbox (
+        id            TEXT PRIMARY KEY,
+        content       TEXT NOT NULL,
+        title         TEXT,
+        source        TEXT NOT NULL DEFAULT 'cli',
+        source_url    TEXT,
+        source_meta   TEXT,
+        status        TEXT NOT NULL DEFAULT 'pending',
+        created_at    TEXT NOT NULL,
+        processed_at  TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS feeds (
+        id            TEXT PRIMARY KEY,
+        url           TEXT NOT NULL UNIQUE,
+        name          TEXT NOT NULL,
+        container_tag TEXT NOT NULL DEFAULT 'default',
+        filter_prompt TEXT,
+        last_polled   TEXT,
+        created_at    TEXT NOT NULL
+      );
+    `;
+  }
+  memoryDDL() {
+    return `
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id                TEXT PRIMARY KEY,
+        memory            TEXT NOT NULL,
+        source_note_id    TEXT NOT NULL,
+        source_chunk_id   TEXT,
+        container_tag     TEXT NOT NULL DEFAULT 'default',
+        is_latest         INTEGER NOT NULL DEFAULT 1,
+        parent_memory_id  TEXT,
+        root_memory_id    TEXT,
+        relation_type     TEXT,
+        valid_at          TEXT,
+        invalid_at        TEXT,
+        forget_after      TEXT,
+        is_forgotten      INTEGER NOT NULL DEFAULT 0,
+        is_inference      INTEGER NOT NULL DEFAULT 0,
+        created_at        TEXT NOT NULL,
+        FOREIGN KEY (source_note_id) REFERENCES notes(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_source ON memory_entries(source_note_id);
+      CREATE INDEX IF NOT EXISTS idx_memory_latest ON memory_entries(is_latest) WHERE is_latest = 1;
+      CREATE INDEX IF NOT EXISTS idx_memory_container ON memory_entries(container_tag);
+
+      CREATE TABLE IF NOT EXISTS memory_history (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id   TEXT NOT NULL,
+        event       TEXT NOT NULL,
+        old_memory  TEXT,
+        new_memory  TEXT,
+        actor       TEXT NOT NULL DEFAULT 'system',
+        created_at  TEXT NOT NULL,
+        FOREIGN KEY (memory_id) REFERENCES memory_entries(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_history_memory ON memory_history(memory_id);
+    `;
+  }
+  noteAccessDDL() {
+    return `
+      CREATE TABLE IF NOT EXISTS note_access (
+        note_id    TEXT NOT NULL,
+        event      TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_note_access_note ON note_access(note_id);
+    `;
+  }
+  schemaV1() {
+    return `
+      CREATE TABLE IF NOT EXISTS files (
+        path        TEXT PRIMARY KEY,
+        hash        TEXT NOT NULL,
+        mtime       INTEGER NOT NULL,
+        indexed_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS notes (
+        id              TEXT PRIMARY KEY,
+        file_path       TEXT NOT NULL UNIQUE,
+        title           TEXT NOT NULL,
+        type            TEXT NOT NULL,
+        tier            TEXT NOT NULL,
+        category        TEXT,
+        tags            TEXT,
+        summary         TEXT,
+        confidence      TEXT,
+        status          TEXT DEFAULT 'current',
+        sources         TEXT,
+        created_at      TEXT,
+        modified_at     TEXT,
+        last_reviewed   TEXT,
+        review_interval TEXT,
+        expires         TEXT,
+        metadata        TEXT,
+        module          TEXT,
+        module_instance TEXT,
+        content_dir     TEXT,
+        embed_status    TEXT GENERATED ALWAYS AS (json_extract(metadata, '$.embed_status')),
+        activity_type   TEXT GENERATED ALWAYS AS (json_extract(metadata, '$.activity_type'))
+      );
+
+      CREATE TABLE IF NOT EXISTS relations (
+        source_id       TEXT NOT NULL,
+        target_id       TEXT NOT NULL,
+        type            TEXT NOT NULL,
+        created_at      INTEGER NOT NULL,
+        module          TEXT,
+        module_instance TEXT,
+        PRIMARY KEY (source_id, target_id, type)
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+        note_id UNINDEXED,
+        title,
+        summary,
+        content,
+        tokenize='unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id                TEXT PRIMARY KEY,
+        note_id           TEXT NOT NULL,
+        heading           TEXT,
+        heading_ancestry  TEXT,
+        content           TEXT NOT NULL,
+        token_count       INTEGER,
+        chunk_type        TEXT DEFAULT 'section',
+        cut_type          TEXT DEFAULT 'heading_boundary',
+        position          INTEGER DEFAULT 0,
+        FOREIGN KEY (note_id) REFERENCES notes(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chunks_note_id ON chunks(note_id);
+
+      CREATE TABLE IF NOT EXISTS db_meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      ${this.captureDDL()}
+      ${this.memoryDDL()}
+      ${this.noteAccessDDL()}
+      ${this.activitiesDDL()}
+      ${this.moduleIndexesDDL()}
+
+      CREATE INDEX IF NOT EXISTS idx_notes_embed_status ON notes(embed_status);
+      CREATE INDEX IF NOT EXISTS idx_notes_activity_type ON notes(activity_type);
+    `;
+  }
+  migrateToV3() {
+    const columns = this.db.pragma("table_info(chunks)");
+    const columnNames = new Set(columns.map((c) => c.name));
+    if (!columnNames.has("heading_ancestry")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN heading_ancestry TEXT");
+    }
+    if (!columnNames.has("cut_type")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN cut_type TEXT DEFAULT 'heading_boundary'");
+    }
+    if (!columnNames.has("position")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN position INTEGER DEFAULT 0");
+    }
+  }
+  migrateToV7() {
+    const noteColumns = this.db.pragma("table_info(notes)");
+    const noteColNames = new Set(noteColumns.map((c) => c.name));
+    if (!noteColNames.has("module")) {
+      this.db.exec("ALTER TABLE notes ADD COLUMN module TEXT");
+    }
+    if (!noteColNames.has("module_instance")) {
+      this.db.exec("ALTER TABLE notes ADD COLUMN module_instance TEXT");
+    }
+    if (!noteColNames.has("content_dir")) {
+      this.db.exec("ALTER TABLE notes ADD COLUMN content_dir TEXT");
+    }
+    const relColumns = this.db.pragma("table_info(relations)");
+    const relColNames = new Set(relColumns.map((c) => c.name));
+    if (!relColNames.has("module")) {
+      this.db.exec("ALTER TABLE relations ADD COLUMN module TEXT");
+    }
+    if (!relColNames.has("module_instance")) {
+      this.db.exec("ALTER TABLE relations ADD COLUMN module_instance TEXT");
+    }
+    this.db.exec(this.activitiesDDL());
+    this.db.exec(this.moduleIndexesDDL());
+  }
+  migrateToV8() {
+    this.db.exec(`
+      ALTER TABLE notes ADD COLUMN embed_status TEXT
+        GENERATED ALWAYS AS (json_extract(metadata, '$.embed_status'));
+      ALTER TABLE notes ADD COLUMN activity_type TEXT
+        GENERATED ALWAYS AS (json_extract(metadata, '$.activity_type'));
+      CREATE INDEX IF NOT EXISTS idx_notes_embed_status ON notes(embed_status);
+      CREATE INDEX IF NOT EXISTS idx_notes_activity_type ON notes(activity_type);
+    `);
+  }
+  activitiesDDL() {
+    return `
+      CREATE TABLE IF NOT EXISTS activities (
+        id              TEXT PRIMARY KEY,
+        note_ids        TEXT,
+        module          TEXT,
+        module_instance TEXT,
+        activity_type   TEXT,
+        actor_type      TEXT,
+        actor_id        TEXT,
+        session_id      TEXT,
+        metadata        TEXT,
+        outcome         TEXT,
+        started_at      TEXT,
+        completed_at    TEXT
+      );
+    `;
+  }
+  moduleIndexesDDL() {
+    return `
+      CREATE INDEX IF NOT EXISTS idx_notes_module ON notes(module);
+      CREATE INDEX IF NOT EXISTS idx_notes_module_instance ON notes(module, module_instance);
+      CREATE INDEX IF NOT EXISTS idx_activities_module ON activities(module, module_instance);
+      CREATE INDEX IF NOT EXISTS idx_activities_type ON activities(module, activity_type);
+      CREATE INDEX IF NOT EXISTS idx_activities_session ON activities(session_id);
+    `;
+  }
+  // --- Meta ---
+  setMetaValue(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO db_meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+  getMetaValue(key) {
+    const row = this.db.prepare("SELECT value FROM db_meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  // --- Embedding Model ---
+  setEmbeddingModel(model, dimensions) {
+    this.setMetaValue("embedding_model", model);
+    this.setMetaValue("embedding_dimensions", String(dimensions));
+    this.ensureVectorTable(dimensions);
+  }
+  getEmbeddingModel() {
+    const model = this.getMetaValue("embedding_model");
+    const dims = this.getMetaValue("embedding_dimensions");
+    if (!model || !dims) return null;
+    return { model, dimensions: Number(dims) };
+  }
+  checkModelMatch(model) {
+    const stored = this.getEmbeddingModel();
+    if (!stored) return;
+    if (stored.model !== model) {
+      throw new Error(
+        `Embedding model mismatch: DB uses "${stored.model}" but "${model}" was requested. Re-index with --force to switch models.`
+      );
+    }
+  }
+  // --- Table Introspection ---
+  listTables() {
+    const rows = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'"
+    ).all();
+    return rows.map((r) => r.name);
+  }
+  // --- Cross-repo Orchestration ---
+  deleteNote(id) {
+    const txn = this.db.transaction(() => {
+      this.memoryRepo.deleteMemoriesForNote(id);
+      this.noteRepo.deleteChunksForNote(id);
+      this.db.prepare("DELETE FROM notes_fts WHERE note_id = ?").run(id);
+      this.db.prepare("DELETE FROM relations WHERE source_id = ? OR target_id = ?").run(id, id);
+      this.db.prepare("DELETE FROM note_access WHERE note_id = ?").run(id);
+      this.db.prepare("DELETE FROM notes WHERE id = ?").run(id);
+    });
+    txn();
+  }
+  cascadeDeletePreview(noteId) {
+    const descendants = this.noteRepo.getDescendants(noteId);
+    const allIds = [noteId, ...descendants.map((d) => d.id)];
+    let memoryCount = 0;
+    for (const id of allIds) {
+      memoryCount += this.memoryRepo.getMemoriesForNote(id).length;
+    }
+    return { noteIds: allIds, noteCount: allIds.length, memoryCount };
+  }
+  cascadeDelete(noteId) {
+    const preview = this.cascadeDeletePreview(noteId);
+    const txn = this.db.transaction(() => {
+      for (const id of preview.noteIds.filter((id2) => id2 !== noteId).reverse()) {
+        this.deleteNote(id);
+      }
+      this.deleteNote(noteId);
+    });
+    txn();
+    return preview;
+  }
+  cascadeArchive(noteId, notesDir) {
+    const note = this.getNoteById(noteId);
+    if (!note) throw new Error(`Note not found: ${noteId}`);
+    const archiveDir = join2(notesDir, ".archive");
+    const relativePath = relative(notesDir, note.filePath);
+    const archivePath = join2(archiveDir, relativePath);
+    mkdirSync2(dirname2(archivePath), { recursive: true });
+    if (existsSync2(note.filePath)) {
+      renameSync(note.filePath, archivePath);
+    }
+    const txn = this.db.transaction(() => {
+      this.memoryRepo.deleteMemoriesForNote(noteId);
+      this.noteRepo.deleteChunksForNote(noteId);
+      this.db.prepare("DELETE FROM notes_fts WHERE note_id = ?").run(noteId);
+      this.db.prepare("UPDATE notes SET status = ?, file_path = ? WHERE id = ?").run("archived", archivePath, noteId);
+    });
+    txn();
+    const directChildren = this.noteRepo.getDescendants(noteId, 1);
+    const orphanedIds = [];
+    for (const child of directChildren) {
+      const childNote = this.getNoteById(child.id);
+      if (childNote && existsSync2(childNote.filePath)) {
+        addFrontmatterField(childNote.filePath, "orphaned_from", noteId);
+        orphanedIds.push(child.id);
+      }
+    }
+    return { archivedNote: noteId, archivedPath: archivePath, orphanedChildren: orphanedIds };
+  }
+  // --- Note Delegates ---
+  upsertNote(record) {
+    return this.noteRepo.upsertNote(record);
+  }
+  getNoteById(id) {
+    return this.noteRepo.getNoteById(id);
+  }
+  getNotesByIds(ids) {
+    return this.noteRepo.getNotesByIds(ids);
+  }
+  getAllNotes() {
+    return this.noteRepo.getAllNotes();
+  }
+  getNoteCount() {
+    return this.noteRepo.getNoteCount();
+  }
+  getNoteByFilePath(filePath) {
+    return this.noteRepo.getNoteByFilePath(filePath);
+  }
+  // --- File Delegates ---
+  upsertFile(record) {
+    this.noteRepo.upsertFile(record);
+  }
+  getFile(path) {
+    return this.noteRepo.getFile(path);
+  }
+  getAllFiles() {
+    return this.noteRepo.getAllFiles();
+  }
+  deleteFile(path) {
+    this.noteRepo.deleteFile(path);
+  }
+  // --- Chunk Delegates ---
+  upsertChunks(noteId, chunks, embeddings) {
+    this.noteRepo.upsertChunks(noteId, chunks, embeddings);
+  }
+  getChunksForNote(noteId) {
+    return this.noteRepo.getChunksForNote(noteId);
+  }
+  getChunkCount() {
+    return this.noteRepo.getChunkCount();
+  }
+  deleteChunksForNote(noteId) {
+    this.noteRepo.deleteChunksForNote(noteId);
+  }
+  getChunkContent(chunkId) {
+    return this.noteRepo.getChunkContent(chunkId);
+  }
+  getFirstChunkForNote(noteId) {
+    return this.noteRepo.getFirstChunkForNote(noteId);
+  }
+  getChunkHeading(chunkId, noteId) {
+    return this.noteRepo.getChunkHeading(chunkId, noteId);
+  }
+  getChunkEmbedding(chunkId) {
+    return this.noteRepo.getChunkEmbedding(chunkId);
+  }
+  // --- Relation Delegates ---
+  upsertRelations(noteId, relations) {
+    this.noteRepo.upsertRelations(noteId, relations);
+  }
+  getRelationsFrom(noteId) {
+    return this.noteRepo.getRelationsFrom(noteId);
+  }
+  getRelationsTo(noteId) {
+    return this.noteRepo.getRelationsTo(noteId);
+  }
+  getRelationsBatch(ids) {
+    return this.noteRepo.getRelationsBatch(ids);
+  }
+  getDescendants(noteId, maxDepth) {
+    return this.noteRepo.getDescendants(noteId, maxDepth);
+  }
+  getRelationsFiltered(opts) {
+    return this.noteRepo.getRelationsFiltered(opts);
+  }
+  // --- Access Delegates ---
+  recordAccess(noteId, event) {
+    this.noteRepo.recordAccess(noteId, event);
+  }
+  getAccessCount(noteId) {
+    return this.noteRepo.getAccessCount(noteId);
+  }
+  getAccessCounts(noteIds) {
+    return this.noteRepo.getAccessCounts(noteIds);
+  }
+  // --- FTS Delegates ---
+  upsertNoteFTS(noteId, title, summary, content) {
+    this.noteRepo.upsertNoteFTS(noteId, title, summary, content);
+  }
+  searchFTS(query, limit) {
+    return this.noteRepo.searchFTS(query, limit);
+  }
+  // --- Search Delegates ---
+  searchVector(embedding, limit) {
+    return this.noteRepo.searchVector(embedding, limit);
+  }
+  getFilteredNoteIds(filters) {
+    return this.noteRepo.getFilteredNoteIds(filters);
+  }
+  getFilteredNoteIdsByMetadata(filters, baseIds) {
+    return this.noteRepo.getFilteredNoteIdsByMetadata(filters, baseIds);
+  }
+  getFacetCounts(field, noteIds) {
+    return this.noteRepo.getFacetCounts(field, noteIds);
+  }
+  getModuleNoteIds(filter) {
+    return this.noteRepo.getModuleNoteIds(filter);
+  }
+  // --- Memory Delegates ---
+  addMemory(entry) {
+    this.memoryRepo.addMemory(entry);
+  }
+  getMemory(id) {
+    return this.memoryRepo.getMemory(id);
+  }
+  getMemoriesForNote(noteId) {
+    return this.memoryRepo.getMemoriesForNote(noteId);
+  }
+  getLatestMemories(containerTag) {
+    return this.memoryRepo.getLatestMemories(containerTag);
+  }
+  getMemoryVersionChain(rootId) {
+    return this.memoryRepo.getMemoryVersionChain(rootId);
+  }
+  markMemorySuperseded(id) {
+    this.memoryRepo.markMemorySuperseded(id);
+  }
+  deleteMemoriesForNote(noteId) {
+    this.memoryRepo.deleteMemoriesForNote(noteId);
+  }
+  forgetExpiredMemories() {
+    return this.memoryRepo.forgetExpiredMemories();
+  }
+  getMemoriesSince(since, containerTag) {
+    return this.memoryRepo.getMemoriesSince(since, containerTag);
+  }
+  getMemoryCount() {
+    return this.memoryRepo.getMemoryCount();
+  }
+  getMemoriesByIds(ids) {
+    return this.memoryRepo.getMemoriesByIds(ids);
+  }
+  addMemoryHistory(entry) {
+    this.memoryRepo.addMemoryHistory(entry);
+  }
+  getMemoryHistory(memoryId) {
+    return this.memoryRepo.getMemoryHistory(memoryId);
+  }
+  deleteMemoryVector(memoryId) {
+    this.memoryRepo.deleteMemoryVector(memoryId);
+  }
+  upsertMemoryVector(memoryId, embedding) {
+    this.memoryRepo.upsertMemoryVector(memoryId, embedding);
+  }
+  searchMemoryVectors(embedding, limit) {
+    return this.memoryRepo.searchMemoryVectors(embedding, limit);
+  }
+  // --- Capture Delegates ---
+  addInboxItem(item) {
+    this.captureRepo.addInboxItem(item);
+  }
+  getInboxItems(status) {
+    return this.captureRepo.getInboxItems(status);
+  }
+  getInboxItem(id) {
+    return this.captureRepo.getInboxItem(id);
+  }
+  updateInboxStatus(id, status) {
+    this.captureRepo.updateInboxStatus(id, status);
+  }
+  deleteInboxItem(id) {
+    this.captureRepo.deleteInboxItem(id);
+  }
+  addFeed(feed) {
+    this.captureRepo.addFeed(feed);
+  }
+  getFeeds() {
+    return this.captureRepo.getFeeds();
+  }
+  getFeedById(id) {
+    return this.captureRepo.getFeedById(id);
+  }
+  removeFeed(id) {
+    this.captureRepo.removeFeed(id);
+  }
+  updateFeedLastPolled(id, lastPolled) {
+    this.captureRepo.updateFeedLastPolled(id, lastPolled);
+  }
+  // --- Activity Delegates ---
+  addActivity(record) {
+    this.activityRepo.addActivity(record);
+  }
+  getActivity(id) {
+    return this.activityRepo.getActivity(id);
+  }
+  getActivities(opts) {
+    return this.activityRepo.getActivities(opts);
+  }
+  getActivitiesByNoteId(noteId) {
+    return this.activityRepo.getActivitiesByNoteId(noteId);
+  }
+  getActivitiesBySession(sessionId) {
+    return this.activityRepo.getActivitiesBySession(sessionId);
+  }
+};
+
+// src/modules/loader.ts
+import { readdirSync, existsSync as existsSync3 } from "fs";
+import { join as join3, basename, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/modules/registry.ts
+var ModuleRegistry = class {
+  modules = /* @__PURE__ */ new Map();
+  noteTypes = /* @__PURE__ */ new Map();
+  relationTypes = /* @__PURE__ */ new Map();
+  commands = [];
+  extractionStrategies = [];
+  filters = [];
+  migrations = [];
+  contentHandlers = [];
+  registerModule(mod) {
+    if (this.modules.has(mod.name)) {
+      throw new Error(`Module "${mod.name}" is already registered`);
+    }
+    this.modules.set(mod.name, mod);
+  }
+  getModule(name) {
+    return this.modules.get(name);
+  }
+  getModuleNames() {
+    return [...this.modules.keys()];
+  }
+  // --- Note Types ---
+  registerNoteType(moduleName, noteType) {
+    const key = noteType.name;
+    if (this.noteTypes.has(key)) {
+      const existing = this.noteTypes.get(key);
+      throw new Error(`Note type "${key}" already registered by module "${existing.module}"`);
+    }
+    this.noteTypes.set(key, { module: moduleName, noteType });
+  }
+  getNoteType(name) {
+    return this.noteTypes.get(name)?.noteType;
+  }
+  getNoteTypeModule(name) {
+    return this.noteTypes.get(name)?.module;
+  }
+  getAllNoteTypes() {
+    return [...this.noteTypes.values()];
+  }
+  // --- Relation Types ---
+  registerRelationType(moduleName, relationType) {
+    const key = relationType.name;
+    if (this.relationTypes.has(key)) {
+      const existing = this.relationTypes.get(key);
+      throw new Error(`Relation type "${key}" already registered by module "${existing.module}"`);
+    }
+    this.relationTypes.set(key, { module: moduleName, relationType });
+  }
+  getRelationType(name) {
+    return this.relationTypes.get(name)?.relationType;
+  }
+  // --- Commands ---
+  registerCommand(moduleName, command) {
+    this.commands.push({ module: moduleName, command });
+  }
+  getCommands() {
+    return [...this.commands];
+  }
+  // --- Directory Schemas ---
+  getDirectorySchema(noteTypeName) {
+    return this.noteTypes.get(noteTypeName)?.noteType.directorySchema;
+  }
+  // --- Extraction Strategies ---
+  registerExtractionStrategy(moduleName, strategy) {
+    this.extractionStrategies.push({ module: moduleName, strategy });
+  }
+  getExtractionStrategy(moduleName) {
+    return this.extractionStrategies.find((s) => s.module === moduleName)?.strategy;
+  }
+  // --- Filters ---
+  registerFilter(moduleName, filter) {
+    this.filters.push({ module: moduleName, filter });
+  }
+  getFilters() {
+    return [...this.filters];
+  }
+  getFilterForModule(moduleName) {
+    return this.filters.find((f) => f.module === moduleName)?.filter;
+  }
+  // --- Migrations ---
+  registerMigration(moduleName, migration) {
+    this.migrations.push({ module: moduleName, migration });
+  }
+  getMigrations(moduleName) {
+    if (moduleName) {
+      return this.migrations.filter((m) => m.module === moduleName);
+    }
+    return [...this.migrations];
+  }
+  // --- Content Handlers ---
+  registerContentHandler(moduleName, handler) {
+    this.contentHandlers.push({ module: moduleName, handler });
+  }
+  getContentHandlers() {
+    return [...this.contentHandlers];
+  }
+};
+
+// src/modules/context.ts
+function createModuleContext(registry, moduleName) {
+  return {
+    registerNoteType(noteType) {
+      registry.registerNoteType(moduleName, noteType);
+    },
+    registerRelationType(relationType) {
+      registry.registerRelationType(moduleName, relationType);
+    },
+    registerCommand(command) {
+      registry.registerCommand(moduleName, command);
+    },
+    registerExtractionStrategy(strategy) {
+      registry.registerExtractionStrategy(moduleName, strategy);
+    },
+    registerFilter(filter) {
+      registry.registerFilter(moduleName, filter);
+    },
+    registerMigration(migration) {
+      registry.registerMigration(moduleName, migration);
+    },
+    registerContentHandler(handler) {
+      registry.registerContentHandler(moduleName, handler);
+    }
+  };
+}
+
+// src/modules/loader.ts
+function getBuiltinModulesDir() {
+  try {
+    const thisDir = import.meta.dirname ?? dirname3(fileURLToPath(import.meta.url));
+    return join3(thisDir, "..", "..", "modules");
+  } catch {
+    return "";
+  }
+}
+function discoverModules(modulesDir) {
+  const dir = modulesDir ?? getBuiltinModulesDir();
+  if (!dir || !existsSync3(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).filter((f) => !f.startsWith("_") && !f.endsWith(".test.ts") && !f.endsWith(".test.js")).map((f) => join3(dir, f));
+}
+async function loadModules(opts) {
+  const registry = new ModuleRegistry();
+  const errors = [];
+  if (opts?.modules) {
+    for (const mod of opts.modules) {
+      try {
+        registry.registerModule(mod);
+        const ctx = createModuleContext(registry, mod.name);
+        mod.register(ctx);
+      } catch (err) {
+        errors.push({
+          module: mod.name,
+          error: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+    }
+  }
+  const modulePaths = discoverModules(opts?.modulesDir);
+  for (const modulePath of modulePaths) {
+    const name = basename(modulePath).replace(/\.[jt]s$/, "");
+    try {
+      const imported = await import(modulePath);
+      const mod = imported.default ?? imported;
+      if (!mod.name || !mod.register) {
+        throw new Error(`Module at ${modulePath} does not export a valid BrainModule`);
+      }
+      registry.registerModule(mod);
+      const ctx = createModuleContext(registry, mod.name);
+      mod.register(ctx);
+    } catch (err) {
+      errors.push({
+        module: name,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  return { registry, errors };
+}
+
+// src/services/brain-service.ts
+async function withBrain(fn, resolveOpts) {
+  const instance = resolveInstance(resolveOpts);
+  const config = loadConfig(instance);
+  const db = new BrainDB(config.dbPath);
+  const embedder = createEmbedder(config);
+  const { registry } = await loadModules();
+  const svc = {
+    db,
+    embedder,
+    config,
+    modules: registry,
+    instance,
+    close() {
+      db.close();
+    }
+  };
+  try {
+    return await fn(svc);
+  } finally {
+    svc.close();
+  }
+}
+async function withDb(fn, resolveOpts) {
+  const instance = resolveInstance(resolveOpts);
+  const config = loadConfig(instance);
+  const db = new BrainDB(config.dbPath);
+  const svc = {
+    db,
+    config,
+    instance,
+    close() {
+      db.close();
+    }
+  };
+  try {
+    return await fn(svc);
+  } finally {
+    svc.close();
+  }
+}
+
+export {
+  GLOBAL_BRAIN_DIR,
+  parentResolveOpts,
+  resolveInstance,
+  getConfigDir,
+  getDataDir,
+  loadConfig,
+  saveConfig,
+  BrainDB,
+  loadModules,
+  withBrain,
+  withDb
+};