@titan-design/brain 0.3.0 → 0.4.0

package/dist/cli.js

@@ -6,8 +6,8 @@ import { Command as Command23 } from "@commander-js/extra-typings";
 
 // src/commands/init.ts
 import { Command } from "@commander-js/extra-typings";
-import { mkdirSync as mkdirSync4, existsSync as existsSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 import { execSync } from "child_process";
 import { createInterface } from "readline";
 
@@ -93,8 +93,8 @@ function saveConfig(config, configDir, dataDir) {
 // src/services/brain-db.ts
 import Database from "better-sqlite3";
 import * as sqliteVec from "sqlite-vec";
-import { mkdirSync as mkdirSync3, renameSync, existsSync as existsSync3 } from "fs";
-import { join as join4, dirname as dirname2, relative as relative2 } from "path";
+import { mkdirSync as mkdirSync4, renameSync as renameSync2, existsSync as existsSync4 } from "fs";
+import { join as join5, dirname as dirname2, relative as relative2 } from "path";
 
 // src/services/repos/note-repo.ts
 var NoteRepo = class {
@@ -106,9 +106,9 @@ var NoteRepo = class {
   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)
+          (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,
@@ -126,7 +126,10 @@ var NoteRepo = class {
       record.lastReviewed,
       record.reviewInterval,
       record.expires,
-      record.metadata
+      record.metadata,
+      record.module,
+      record.moduleInstance,
+      record.contentDir
     );
     return record;
   }
@@ -180,8 +183,12 @@ var NoteRepo = class {
     this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
   }
   // --- Chunk + Vector Operations ---
-  // TODO: add guard for chunks.length !== embeddings.length mismatch
   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);
     }
@@ -289,6 +296,25 @@ var NoteRepo = class {
     }
     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;
@@ -389,6 +415,29 @@ var NoteRepo = class {
     const rows = this.db.prepare(`SELECT id FROM notes WHERE ${conditions.join(" AND ")}`).all(...params);
     return new Set(rows.map((r) => r.id));
   }
+  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(" ");
@@ -411,7 +460,10 @@ function rowToNoteRecord(row) {
     lastReviewed: row.last_reviewed,
     reviewInterval: row.review_interval,
     expires: row.expires,
-    metadata: row.metadata
+    metadata: row.metadata,
+    module: row.module ?? null,
+    moduleInstance: row.module_instance ?? null,
+    contentDir: row.content_dir ?? null
   };
 }
 function rowToFileRecord(row) {
@@ -719,16 +771,101 @@ var CaptureRepo = class {
   }
 };
 
+// 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/indexing.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { basename, dirname, join as join3, relative } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { basename, dirname, join as join4, relative } from "path";
 
 // src/services/markdown-parser.ts
 import matter from "gray-matter";
 
 // src/types.ts
-var VALID_NOTE_TYPES = [
+var VALID_CORE_NOTE_TYPES = [
   "note",
   "decision",
   "pattern",
@@ -777,7 +914,7 @@ function parseMarkdown(filePath, content) {
   const frontmatter = coerceFrontmatter(filePath, data);
   const chunks = chunkBody(body);
   const relations = extractRelations(id, data);
-  return { id, filePath, frontmatter, content: body, chunks, relations };
+  return { id, filePath, frontmatter, rawFrontmatter: data, content: body, chunks, relations };
 }
 function deriveId(filePath, data) {
   if (typeof data.id === "string" && data.id.length > 0) return data.id;
@@ -787,10 +924,12 @@ function deriveId(filePath, data) {
 }
 function coerceFrontmatter(filePath, data) {
   const filename = (filePath.split("/").pop() ?? filePath).replace(/\.md$/, "");
+  const hasModule = typeof data.module === "string";
+  const type = hasModule && typeof data.type === "string" ? data.type : coerceEnum(data.type, VALID_CORE_NOTE_TYPES, "note");
   return {
     id: typeof data.id === "string" ? data.id : void 0,
     title: typeof data.title === "string" ? data.title : filename,
-    type: coerceEnum(data.type, VALID_NOTE_TYPES, "note"),
+    type,
     tier: coerceEnum(data.tier, VALID_NOTE_TIERS, "slow"),
     category: coerceString(data.category),
     tags: coerceTags(data.tags),
@@ -809,7 +948,10 @@ function coerceFrontmatter(filePath, data) {
     outcome: coerceString(data.outcome),
     related: coerceStringArray(data.related),
     supersedes: coerceString(data.supersedes),
-    parent: coerceString(data.parent)
+    parent: coerceString(data.parent),
+    module: coerceString(data.module),
+    "module-instance": coerceString(data["module-instance"]),
+    "content-dir": coerceString(data["content-dir"])
   };
 }
 function coerceString(value) {
@@ -1108,12 +1250,32 @@ async function scanForChanges(rootDir, knownFiles) {
   return result;
 }
 
+// src/services/content-dir.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, renameSync, rmSync } from "fs";
+import { join as join3, extname } from "path";
+var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".json", ".yaml", ".yml"]);
+function readIndexableContent(contentDir) {
+  if (!existsSync2(contentDir)) return "";
+  const files = readdirSync(contentDir);
+  const parts = [];
+  for (const file of files.sort()) {
+    const ext = extname(file).toLowerCase();
+    if (!INDEXABLE_EXTENSIONS.has(ext)) continue;
+    try {
+      const content = readFileSync2(join3(contentDir, file), "utf-8");
+      parts.push(content);
+    } catch {
+    }
+  }
+  return parts.join("\n\n");
+}
+
 // src/services/indexing.ts
 function isSkippedFile(filePath) {
   return filePath.includes("/_templates/") || basename(filePath) === "_index.md";
 }
 function addFrontmatterField(filePath, field, value) {
-  const content = readFileSync2(filePath, "utf-8");
+  const content = readFileSync3(filePath, "utf-8");
   const endOfFrontmatter = content.indexOf("\n---", 4);
   if (endOfFrontmatter === -1) return;
   const frontmatter = content.slice(0, endOfFrontmatter);
@@ -1129,6 +1291,7 @@ ${field}: ${value}` + content.slice(endOfFrontmatter);
 }
 function frontmatterToRecord(parsed) {
   const fm = parsed.frontmatter;
+  const metadata = fm.module ? JSON.stringify(parsed.rawFrontmatter) : null;
   return {
     id: parsed.id,
     filePath: parsed.filePath,
@@ -1146,7 +1309,10 @@ function frontmatterToRecord(parsed) {
     lastReviewed: fm["last-reviewed"] ?? null,
     reviewInterval: fm["review-interval"] ?? null,
     expires: fm.expires ?? null,
-    metadata: null
+    metadata,
+    module: fm.module ?? null,
+    moduleInstance: fm["module-instance"] ?? null,
+    contentDir: fm["content-dir"] ?? null
   };
 }
 function chunkId(noteId, content) {
@@ -1193,11 +1359,18 @@ async function indexSingleFile(db, embedder, filePath, content, hash, mtime) {
   const parsed = parseMarkdown(filePath, content);
   const noteRecord = frontmatterToRecord(parsed);
   db.upsertNote(noteRecord);
+  let ftsContent = parsed.content;
+  if (noteRecord.contentDir) {
+    const dirContent = readIndexableContent(noteRecord.contentDir);
+    if (dirContent) {
+      ftsContent = ftsContent + "\n\n" + dirContent;
+    }
+  }
   db.upsertNoteFTS(
     parsed.id,
     parsed.frontmatter.title,
     parsed.frontmatter.summary ?? "",
-    parsed.content
+    ftsContent
   );
   const chunks = rawChunksToChunks(parsed.id, parsed.chunks);
   if (chunks.length > 0) {
@@ -1235,7 +1408,7 @@ async function indexFiles(db, embedder, notesDir, opts) {
   const indexedNoteIds = [];
   const toProcess = [...changes.new, ...changes.modified].filter((f) => !isSkippedFile(f.path));
   for (const file of toProcess) {
-    const content = readFileSync2(file.path, "utf-8");
+    const content = readFileSync3(file.path, "utf-8");
     const noteId = await indexSingleFile(db, embedder, file.path, content, file.hash, file.mtime);
     indexedNoteIds.push(noteId);
     indexed++;
@@ -1262,10 +1435,10 @@ async function processInbox(db, notesDir, embedder) {
       const yyyy = String(now.getFullYear());
       const mm = String(now.getMonth() + 1).padStart(2, "0");
       const dd = String(now.getDate()).padStart(2, "0");
-      const outPath = join3(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${parsed.id}.md`);
+      const outPath = join4(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${parsed.id}.md`);
       const dir = dirname(outPath);
-      if (!existsSync2(dir)) {
-        mkdirSync2(dir, { recursive: true });
+      if (!existsSync3(dir)) {
+        mkdirSync3(dir, { recursive: true });
       }
       writeFileSync2(outPath, markdown, "utf-8");
       const hash = createHash2("sha256").update(markdown).digest("hex");
@@ -1304,17 +1477,18 @@ function generateNoteIndex(db, notesDir) {
     }
     lines2.push("");
   }
-  writeFileSync2(join3(notesDir, "_index.md"), lines2.join("\n"), "utf-8");
+  writeFileSync2(join4(notesDir, "_index.md"), lines2.join("\n"), "utf-8");
 }
 
 // src/services/brain-db.ts
-var SCHEMA_VERSION = 6;
+var SCHEMA_VERSION = 7;
 var BrainDB = class {
   db;
   vectorDimensions = null;
   noteRepo;
   memoryRepo;
   captureRepo;
+  activityRepo;
   constructor(dbPath) {
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
@@ -1324,6 +1498,7 @@ var BrainDB = class {
     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();
@@ -1352,6 +1527,7 @@ var BrainDB = class {
     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());
     const dims = this.getMetaValue("embedding_dimensions");
     if (dims) {
       this.ensureVectorTable(Number(dims));
@@ -1462,30 +1638,35 @@ var BrainDB = class {
       );
 
       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,
+        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
+        expires         TEXT,
+        metadata        TEXT,
+        module          TEXT,
+        module_instance TEXT,
+        content_dir     TEXT
       );
 
       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,
+        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)
       );
 
@@ -1520,6 +1701,8 @@ var BrainDB = class {
       ${this.captureDDL()}
       ${this.memoryDDL()}
       ${this.noteAccessDDL()}
+      ${this.activitiesDDL()}
+      ${this.moduleIndexesDDL()}
     `;
   }
   migrateToV3() {
@@ -1535,6 +1718,56 @@ var BrainDB = class {
       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());
+  }
+  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);
@@ -1606,12 +1839,12 @@ var BrainDB = class {
   cascadeArchive(noteId, notesDir) {
     const note = this.getNoteById(noteId);
     if (!note) throw new Error(`Note not found: ${noteId}`);
-    const archiveDir = join4(notesDir, ".archive");
+    const archiveDir = join5(notesDir, ".archive");
     const relativePath = relative2(notesDir, note.filePath);
-    const archivePath = join4(archiveDir, relativePath);
-    mkdirSync3(dirname2(archivePath), { recursive: true });
-    if (existsSync3(note.filePath)) {
-      renameSync(note.filePath, archivePath);
+    const archivePath = join5(archiveDir, relativePath);
+    mkdirSync4(dirname2(archivePath), { recursive: true });
+    if (existsSync4(note.filePath)) {
+      renameSync2(note.filePath, archivePath);
     }
     const txn = this.db.transaction(() => {
       this.memoryRepo.deleteMemoriesForNote(noteId);
@@ -1624,7 +1857,7 @@ var BrainDB = class {
     const orphanedIds = [];
     for (const child of directChildren) {
       const childNote = this.getNoteById(child.id);
-      if (childNote && existsSync3(childNote.filePath)) {
+      if (childNote && existsSync4(childNote.filePath)) {
         addFrontmatterField(childNote.filePath, "orphaned_from", noteId);
         orphanedIds.push(child.id);
       }
@@ -1701,6 +1934,9 @@ var BrainDB = class {
   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);
@@ -1725,6 +1961,9 @@ var BrainDB = class {
   getFilteredNoteIds(filters) {
     return this.noteRepo.getFilteredNoteIds(filters);
   }
+  getModuleNoteIds(filter) {
+    return this.noteRepo.getModuleNoteIds(filter);
+  }
   // --- Memory Delegates ---
   addMemory(entry) {
     this.memoryRepo.addMemory(entry);
@@ -1805,6 +2044,22 @@ var BrainDB = class {
   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/adapters/local-embedder.ts
@@ -2174,16 +2429,16 @@ var initCommand = new Command("init").description("Initialize a new brain worksp
   const config = loadConfig();
   const created = [];
   for (const sub of SUBDIRS) {
-    const dir = join5(config.notesDir, sub);
-    if (!existsSync4(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    const dir = join6(config.notesDir, sub);
+    if (!existsSync5(dir)) {
+      mkdirSync5(dir, { recursive: true });
       created.push(sub);
     }
   }
-  const templatesDir = join5(config.notesDir, "_templates");
+  const templatesDir = join6(config.notesDir, "_templates");
   for (const [filename, content] of Object.entries(TEMPLATES)) {
-    const filePath = join5(templatesDir, filename);
-    if (!existsSync4(filePath)) {
+    const filePath = join6(templatesDir, filename);
+    if (!existsSync5(filePath)) {
       writeFileSync3(filePath, content, "utf-8");
     }
   }
@@ -2243,7 +2498,7 @@ var initCommand = new Command("init").description("Initialize a new brain worksp
 
 // src/commands/index-cmd.ts
 import { Command as Command2 } from "@commander-js/extra-typings";
-import { readFileSync as readFileSync3, watch } from "fs";
+import { readFileSync as readFileSync4, watch } from "fs";
 
 // src/services/memory-extractor.ts
 import { randomUUID } from "crypto";
@@ -2270,11 +2525,20 @@ Output valid JSON with this exact structure:
 {"actions":[{"type":"ADD","fact":"..."},{"type":"UPDATE","id":"...","fact":"..."},{"type":"DELETE","id":"..."},{"type":"NONE"}]}
 
 Only output the JSON object, nothing else.`;
-async function extractMemoriesFromNote(db, llm, noteId, containerTag = "default", embedder) {
+async function extractMemoriesFromNote(db, llm, noteId, containerTag = "default", embedder, moduleRegistry) {
   const chunks = db.getChunksForNote(noteId);
   if (chunks.length === 0) {
     return { noteId, facts: [], memoriesCreated: 0, memoriesUpdated: 0, memoriesDeleted: 0 };
   }
+  if (moduleRegistry) {
+    const note = db.getNoteById(noteId);
+    if (note?.module) {
+      const strategy = moduleRegistry.getExtractionStrategy(note.module);
+      if (strategy && !strategy.shouldExtract(note)) {
+        return { noteId, facts: [], memoriesCreated: 0, memoriesUpdated: 0, memoriesDeleted: 0 };
+      }
+    }
+  }
   const allFacts = [];
   for (const chunk of chunks) {
     const facts = await extractFactsFromChunk(llm, chunk);
@@ -2552,7 +2816,7 @@ function startWatcher(db, embedder, notesDir) {
     const changes = await scanForChanges(notesDir, knownFiles);
     const toProcess = [...changes.new, ...changes.modified].filter((f) => !isSkippedFile(f.path));
     for (const file of toProcess) {
-      const content = readFileSync3(file.path, "utf-8");
+      const content = readFileSync4(file.path, "utf-8");
       await indexSingleFile(db, embedder, file.path, content, file.hash, file.mtime);
       process.stderr.write(`  Re-indexed: ${file.path}
 `);
@@ -2594,15 +2858,194 @@ async function extractFromNotes(db, embedder, noteIds, ollamaUrl, model, contain
 // src/commands/search.ts
 import { Command as Command3 } from "@commander-js/extra-typings";
 
+// src/modules/loader.ts
+import { readdirSync as readdirSync2, existsSync as existsSync6 } from "fs";
+import { join as join7, basename as basename2, 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 = [];
+  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];
+  }
+};
+
+// 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);
+    }
+  };
+}
+
+// src/modules/loader.ts
+function getBuiltinModulesDir() {
+  try {
+    const thisDir = import.meta.dirname ?? dirname3(fileURLToPath(import.meta.url));
+    return join7(thisDir, "..", "..", "modules");
+  } catch {
+    return "";
+  }
+}
+function discoverModules(modulesDir) {
+  const dir = modulesDir ?? getBuiltinModulesDir();
+  if (!dir || !existsSync6(dir)) return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).filter((f) => !f.startsWith("_") && !f.endsWith(".test.ts") && !f.endsWith(".test.js")).map((f) => join7(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 = basename2(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) {
   const config = loadConfig();
   const db = new BrainDB(config.dbPath);
   const embedder = createEmbedder(config);
+  const { registry } = await loadModules();
   const svc = {
     db,
     embedder,
     config,
+    modules: registry,
     close() {
       db.close();
     }
@@ -2631,7 +3074,7 @@ async function withDb(fn) {
 }
 
 // src/services/search.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // src/services/reranker.ts
 var DEFAULT_MODEL2 = "Xenova/ms-marco-MiniLM-L-6-v2";
@@ -2663,7 +3106,7 @@ async function rerank(query, results, topK) {
 
 // src/services/search.ts
 var RRF_K = 60;
-var EXCERPT_MAX_LENGTH = 200;
+var EXCERPT_MAX_LENGTH = 500;
 var OVERFETCH_MULTIPLIER = 3;
 function distanceToCosineSim(distance) {
   return 1 - distance * distance / 2;
@@ -2787,17 +3230,33 @@ function fuseByScore(ftsResults, vectorByNote, weights) {
   }
   return scored;
 }
-async function search(db, embedder, query, options, fusionWeights = { bm25: 0.3, vector: 0.7 }) {
+async function search(db, embedder, query, options, fusionWeights = { bm25: 0.3, vector: 0.7 }, moduleRegistry) {
   if (!query.trim()) return [];
   const limit = options.limit;
   const overfetchLimit = limit * OVERFETCH_MULTIPLIER;
-  const allowedNoteIds = db.getFilteredNoteIds({
+  let allowedNoteIds = db.getFilteredNoteIds({
     tier: options.tier,
     category: options.category,
     confidence: options.confidence,
     since: options.since,
     tags: options.tags
   });
+  if (moduleRegistry) {
+    const privateModuleNoteIds = getPrivateModuleNoteIds(db, moduleRegistry);
+    if (privateModuleNoteIds.size > 0) {
+      if (allowedNoteIds) {
+        for (const id of privateModuleNoteIds) {
+          allowedNoteIds.delete(id);
+        }
+      } else {
+        const allNoteIds = new Set(db.getAllNotes().map((n) => n.id));
+        for (const id of privateModuleNoteIds) {
+          allNoteIds.delete(id);
+        }
+        allowedNoteIds = allNoteIds;
+      }
+    }
+  }
   const ftsResults = db.searchFTS(query, overfetchLimit);
   const filteredFts = allowedNoteIds ? ftsResults.filter((r) => allowedNoteIds.has(r.noteId)) : ftsResults;
   const queryVec = await embedQuery(embedder, query);
@@ -2872,6 +3331,18 @@ async function searchMemories(db, embedder, query, limit = 10, containerTag) {
   results.sort((a, b) => b.score - a.score);
   return results.slice(0, limit);
 }
+function getPrivateModuleNoteIds(db, registry) {
+  const privateIds = /* @__PURE__ */ new Set();
+  for (const { module: moduleName, filter } of registry.getFilters()) {
+    if (filter.visibility === "private") {
+      const noteIds = db.getModuleNoteIds({ module: moduleName });
+      for (const id of noteIds) {
+        privateIds.add(id);
+      }
+    }
+  }
+  return privateIds;
+}
 
 // src/services/graph.ts
 var MAX_DEPTH = 3;
@@ -3109,8 +3580,8 @@ function formatMap(map) {
 // src/commands/add.ts
 import { Command as Command5 } from "@commander-js/extra-typings";
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
-import { join as join6, dirname as dirname3, resolve } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync8 } from "fs";
+import { join as join8, dirname as dirname4, resolve } from "path";
 function buildFrontmatter(opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const title = opts.title ?? "Untitled";
@@ -3162,10 +3633,10 @@ function resolveOutputPath(notesDir, tier, type, id) {
     const yyyy = String(now.getFullYear());
     const mm = String(now.getMonth() + 1).padStart(2, "0");
     const dd = String(now.getDate()).padStart(2, "0");
-    return join6(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${id}.md`);
+    return join8(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${id}.md`);
   }
-  const typeDir = TYPE_DIRS[type];
-  return join6(notesDir, typeDir, `${id}.md`);
+  const typeDir = TYPE_DIRS[type] ?? "notes";
+  return join8(notesDir, typeDir, `${id}.md`);
 }
 async function handleUrlAdd(opts) {
   const { fetchAndExtract } = await import("./web-extract-K4LTMRW2.js");
@@ -3213,8 +3684,8 @@ async function handleUrlAdd(opts) {
   const markdown = frontmatterLines.join("\n") + "\n\n" + result.markdown;
   await withBrain(async ({ db, embedder, config }) => {
     const outPath = resolveOutputPath(config.notesDir, tier, type, id);
-    const dir = dirname3(outPath);
-    if (!existsSync6(dir)) mkdirSync5(dir, { recursive: true });
+    const dir = dirname4(outPath);
+    if (!existsSync8(dir)) mkdirSync6(dir, { recursive: true });
     writeFileSync4(outPath, markdown, "utf-8");
     const hash = createHash3("sha256").update(markdown).digest("hex");
     await indexSingleFile(db, embedder, outPath, markdown, hash, Date.now());
@@ -3234,9 +3705,9 @@ var addCommand = new Command5("add").description("Create a new note from file or
   "--type <type>",
   "Note type (note, decision, pattern, research, meeting, session-log, guide)"
 ).option("--tier <tier>", "Note tier (slow, fast)").option("--tags <tags>", "Comma-separated tags").option("--summary <text>", "One-line summary for search excerpts").option("--confidence <level>", "Confidence level (high, medium, low, speculative)").option("--status <status>", "Note status (current, outdated, deprecated, draft)").option("--category <cat>", "Category label").option("--related <ids>", "Comma-separated related note IDs").option("--review-interval <interval>", "Review interval (e.g. 90d, 30d, 180d)").option("--created <date>", "Created date (YYYY-MM-DD), defaults to today").option("--url <url>", "Fetch URL and create note from extracted content").action(async (file, opts) => {
-  if (opts.type && !VALID_NOTE_TYPES.includes(opts.type)) {
+  if (opts.type && !VALID_CORE_NOTE_TYPES.includes(opts.type)) {
     process.stderr.write(
-      `Error: invalid type "${opts.type}". Valid types: ${VALID_NOTE_TYPES.join(", ")}
+      `Error: invalid type "${opts.type}". Valid types: ${VALID_CORE_NOTE_TYPES.join(", ")}
 `
     );
     process.exitCode = 1;
@@ -3272,9 +3743,9 @@ var addCommand = new Command5("add").description("Create a new note from file or
   }
   let content;
   if (file) {
-    content = readFileSync4(resolve(file), "utf-8");
+    content = readFileSync5(resolve(file), "utf-8");
   } else if (!process.stdin.isTTY) {
-    content = readFileSync4(0, "utf-8");
+    content = readFileSync5(0, "utf-8");
   } else {
     process.stderr.write("Error: provide a file argument or pipe content to stdin\n");
     process.exitCode = 1;
@@ -3290,9 +3761,9 @@ var addCommand = new Command5("add").description("Create a new note from file or
   const type = opts.type ?? parsed.frontmatter.type ?? "note";
   const config = loadConfig();
   const outPath = resolveOutputPath(config.notesDir, tier, type, id);
-  const dir = dirname3(outPath);
-  if (!existsSync6(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname4(outPath);
+  if (!existsSync8(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   try {
     writeFileSync4(outPath, content, "utf-8");
@@ -3622,8 +4093,8 @@ var templateCommand = new Command8("template").description("Output a frontmatter
 
 // src/commands/archive.ts
 import { Command as Command9 } from "@commander-js/extra-typings";
-import { renameSync as renameSync2, mkdirSync as mkdirSync6, existsSync as existsSync7 } from "fs";
-import { join as join7, basename as basename2 } from "path";
+import { renameSync as renameSync3, mkdirSync as mkdirSync7, existsSync as existsSync9 } from "fs";
+import { join as join9, basename as basename3 } from "path";
 var archiveCommand = new Command9("archive").description("Move expired fast-tier notes to archive").option("--dry-run", "List files that would be archived without moving them").action(async (opts) => {
   await withDb(({ db, config }) => {
     const notes = db.getAllNotes();
@@ -3640,19 +4111,19 @@ var archiveCommand = new Command9("archive").description("Move expired fast-tier
     for (const note of expired) {
       const expiresDate = new Date(note.expires);
       const yyyy = String(expiresDate.getFullYear());
-      const archiveDir = join7(config.notesDir, "archive", yyyy);
-      const filename = basename2(note.filePath);
-      const archivePath = join7(archiveDir, filename);
+      const archiveDir = join9(config.notesDir, "archive", yyyy);
+      const filename = basename3(note.filePath);
+      const archivePath = join9(archiveDir, filename);
       if (opts.dryRun) {
         process.stdout.write(`Would archive: ${note.filePath} \u2192 ${archivePath}
 `);
         continue;
       }
-      if (!existsSync7(archiveDir)) {
-        mkdirSync6(archiveDir, { recursive: true });
+      if (!existsSync9(archiveDir)) {
+        mkdirSync7(archiveDir, { recursive: true });
       }
-      if (existsSync7(note.filePath)) {
-        renameSync2(note.filePath, archivePath);
+      if (existsSync9(note.filePath)) {
+        renameSync3(note.filePath, archivePath);
       }
       db.upsertNote({ ...note, filePath: archivePath });
     }
@@ -3760,13 +4231,13 @@ var configCommand = new Command10("config").description("Get or set configuratio
 // src/commands/quick.ts
 import { Command as Command11 } from "@commander-js/extra-typings";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFileSync as readFileSync5 } from "fs";
-var quickCommand = new Command11("quick").description("Quickly capture a thought into the inbox").argument("<text...>", "Text to capture (or pipe via stdin)").option("--title <title>", "Optional title for the item").option("--source <source>", "Source label (cli, api, alert)", "cli").option("--url <url>", "Source URL for reference").action(async (textParts, opts) => {
+import { readFileSync as readFileSync6 } from "fs";
+var quickCommand = new Command11("quick").description("Quickly capture a thought into the inbox").argument("[text...]", "Text to capture (or pipe via stdin)").option("--title <title>", "Optional title for the item").option("--source <source>", "Source label (cli, api, alert)", "cli").option("--url <url>", "Source URL for reference").action(async (textParts, opts) => {
   let content;
   if (textParts.length > 0) {
     content = textParts.join(" ");
   } else if (!process.stdin.isTTY) {
-    content = readFileSync5(0, "utf-8").trim();
+    content = readFileSync6(0, "utf-8").trim();
   } else {
     process.stderr.write("Error: provide text as arguments or pipe via stdin\n");
     process.exitCode = 1;
@@ -3808,6 +4279,12 @@ var quickCommand = new Command11("quick").description("Quickly capture a thought
 import { Command as Command12 } from "@commander-js/extra-typings";
 var VALID_STATUSES = ["pending", "processing", "indexed", "failed", "discarded"];
 var inboxCommand = new Command12("inbox").description("View and manage inbox items").option("--status <status>", "Filter by status (pending, processing, indexed, failed, discarded)").option("--discard <id>", "Discard an inbox item").option("--delete <id>", "Permanently delete an inbox item").option("--count", "Show count only").action(async (opts) => {
+  const actionFlags = [opts.discard, opts.delete, opts.count].filter(Boolean);
+  if (actionFlags.length > 1) {
+    process.stderr.write("Error: --discard, --delete, and --count are mutually exclusive\n");
+    process.exitCode = 1;
+    return;
+  }
   if (opts.status && !VALID_STATUSES.includes(opts.status)) {
     process.stderr.write(
       `Error: invalid status "${opts.status}". Valid: ${VALID_STATUSES.join(", ")}
@@ -3869,8 +4346,8 @@ var inboxCommand = new Command12("inbox").description("View and manage inbox ite
 // src/commands/ingest.ts
 import { Command as Command13 } from "@commander-js/extra-typings";
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFileSync as readFileSync6, statSync } from "fs";
-import { resolve as resolve2, basename as basename3 } from "path";
+import { readFileSync as readFileSync7, statSync } from "fs";
+import { resolve as resolve2, basename as basename4 } from "path";
 var ingestCommand = new Command13("ingest").description("Bulk-import files into the inbox").argument("[files...]", "Files to ingest").option("--source <source>", "Source label (file, crawler, api)", "file").option("--url <url>", "Source URL for all items").option("--urls <file>", "File containing URLs to import (one per line)").action(async (files, opts) => {
   if (opts.urls) {
     await handleUrlsFile(opts.urls);
@@ -3901,7 +4378,7 @@ var ingestCommand = new Command13("ingest").description("Bulk-import files into
 `);
         continue;
       }
-      const content = readFileSync6(absPath, "utf-8");
+      const content = readFileSync7(absPath, "utf-8");
       if (!content.trim()) {
         process.stderr.write(`Skipping: ${filePath} (empty)
 `);
@@ -3910,7 +4387,7 @@ var ingestCommand = new Command13("ingest").description("Bulk-import files into
       const item = {
         id: randomUUID3(),
         content,
-        title: basename3(filePath, ".md"),
+        title: basename4(filePath, ".md"),
         source,
         sourceUrl: opts.url ?? null,
         sourceMeta: JSON.stringify({ originalPath: absPath }),
@@ -3928,7 +4405,7 @@ var ingestCommand = new Command13("ingest").description("Bulk-import files into
 async function handleUrlsFile(urlsPath) {
   const { fetchAndExtract } = await import("./web-extract-K4LTMRW2.js");
   const urlFile = resolve2(urlsPath);
-  const content = readFileSync6(urlFile, "utf-8");
+  const content = readFileSync7(urlFile, "utf-8");
   const urls = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   await withDb(async ({ db }) => {
     let ingested = 0;
@@ -3970,6 +4447,14 @@ import { Command as Command14 } from "@commander-js/extra-typings";
 import { randomUUID as randomUUID4 } from "crypto";
 var feedCommand = new Command14("feed").description("Manage RSS feed subscriptions").addCommand(
   new Command14("add").description("Subscribe to an RSS feed").argument("<url>", "Feed URL").option("--name <name>", "Display name for the feed").option("--tag <tag>", "Container tag for namespacing", "default").option("--filter <prompt>", "Filter prompt to select relevant items").action(async (url, opts) => {
+    try {
+      new URL(url);
+    } catch {
+      process.stderr.write(`Error: invalid URL: ${url}
+`);
+      process.exitCode = 1;
+      return;
+    }
     await withDb(({ db }) => {
       try {
         const name = opts.name ?? new URL(url).hostname;
@@ -4046,9 +4531,6 @@ var extractCommand = new Command15("extract").description("Extract memories from
     return;
   }
   await withBrain(async ({ db, embedder, config }) => {
-    const llm = await requireOllama(config.ollamaUrl, opts.model ?? config.ollamaModel);
-    if (!llm) return;
-    db.setEmbeddingModel(embedder.model, embedder.dimensions);
     const noteIds = [];
     if (opts.note) {
       const note = db.getNoteById(opts.note);
@@ -4063,6 +4545,9 @@ var extractCommand = new Command15("extract").description("Extract memories from
       const allNotes = db.getAllNotes();
       noteIds.push(...allNotes.map((n) => n.id));
     }
+    const llm = await requireOllama(config.ollamaUrl, opts.model ?? config.ollamaModel);
+    if (!llm) return;
+    db.setEmbeddingModel(embedder.model, embedder.dimensions);
     let totalFacts = 0;
     let totalCreated = 0;
     let totalUpdated = 0;
@@ -4116,6 +4601,11 @@ var memoriesCommand = new Command16("memories").description("View and manage ext
         memories = db.getLatestMemories(opts.container);
       }
       const limit = parseInt(opts.limit, 10);
+      if (isNaN(limit) || limit <= 0) {
+        process.stderr.write("Error: --limit must be a positive integer\n");
+        process.exitCode = 1;
+        return;
+      }
       const limited = memories.slice(0, limit);
       if (opts.json) {
         process.stdout.write(JSON.stringify(limited) + "\n");
@@ -4344,7 +4834,8 @@ var profileCommand = new Command18("profile").description("Generate a context pr
 
 // src/commands/tidy.ts
 import { Command as Command19 } from "@commander-js/extra-typings";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
+var TIDY_CONTENT_MAX_CHARS = 3e3;
 var TIDY_SYSTEM = `You are a note quality reviewer. Given a note, provide brief, actionable suggestions to improve it.
 
 Focus on:
@@ -4391,13 +4882,13 @@ var tidyCommand = new Command19("tidy").description("LLM-powered note cleanup su
 `);
       let content;
       try {
-        content = readFileSync7(note.filePath, "utf-8");
+        content = readFileSync8(note.filePath, "utf-8");
       } catch {
         process.stderr.write(`  Skipping: file not found
 `);
         continue;
       }
-      const truncated = content.slice(0, 3e3);
+      const truncated = content.slice(0, TIDY_CONTENT_MAX_CHARS);
       const suggestions = await llm.generate(truncated, TIDY_SYSTEM);
       results.push({ noteId: note.id, title: note.title, suggestions });
     }
@@ -4416,18 +4907,18 @@ ${r.title} (${r.noteId})
 
 // src/commands/install-hooks.ts
 import { Command as Command20 } from "@commander-js/extra-typings";
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, writeFileSync as writeFileSync5, unlinkSync, statSync as statSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, unlinkSync, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir2, platform } from "os";
 import { execSync as execSync2 } from "child_process";
 var PLIST_LABEL = "com.brain.index";
-var PLIST_PATH = join8(homedir2(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-var SYSTEMD_DIR = join8(homedir2(), ".config", "systemd", "user");
+var PLIST_PATH = join10(homedir2(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+var SYSTEMD_DIR = join10(homedir2(), ".config", "systemd", "user");
 var SYSTEMD_SERVICE = "brain-index.service";
 var SYSTEMD_TIMER = "brain-index.timer";
 function generateLaunchdPlist(brainBin, intervalMinutes, notesDir) {
   const intervalSeconds = intervalMinutes * 60;
-  const logPath = join8(notesDir, ".brain-hook.log");
+  const logPath = join10(notesDir, ".brain-hook.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -4485,7 +4976,7 @@ function findBrainBin() {
 function installLaunchd(intervalMinutes, notesDir) {
   const brainBin = findBrainBin();
   const plist = generateLaunchdPlist(brainBin, intervalMinutes, notesDir);
-  if (existsSync8(PLIST_PATH)) {
+  if (existsSync10(PLIST_PATH)) {
     try {
       execSync2(`launchctl unload "${PLIST_PATH}"`, { stdio: "ignore" });
     } catch {
@@ -4507,9 +4998,9 @@ function installLaunchd(intervalMinutes, notesDir) {
 }
 function installSystemd(intervalMinutes) {
   const brainBin = findBrainBin();
-  const servicePath = join8(SYSTEMD_DIR, SYSTEMD_SERVICE);
-  const timerPath = join8(SYSTEMD_DIR, SYSTEMD_TIMER);
-  mkdirSync7(SYSTEMD_DIR, { recursive: true });
+  const servicePath = join10(SYSTEMD_DIR, SYSTEMD_SERVICE);
+  const timerPath = join10(SYSTEMD_DIR, SYSTEMD_TIMER);
+  mkdirSync8(SYSTEMD_DIR, { recursive: true });
   writeFileSync5(servicePath, generateSystemdService(brainBin), "utf-8");
   writeFileSync5(timerPath, generateSystemdTimer(intervalMinutes), "utf-8");
   try {
@@ -4528,7 +5019,7 @@ function installSystemd(intervalMinutes) {
 `);
 }
 function uninstallLaunchd() {
-  if (!existsSync8(PLIST_PATH)) {
+  if (!existsSync10(PLIST_PATH)) {
     process.stderr.write("No launchd agent installed.\n");
     return;
   }
@@ -4540,9 +5031,9 @@ function uninstallLaunchd() {
   process.stderr.write("Uninstalled launchd agent.\n");
 }
 function uninstallSystemd() {
-  const timerPath = join8(SYSTEMD_DIR, SYSTEMD_TIMER);
-  const servicePath = join8(SYSTEMD_DIR, SYSTEMD_SERVICE);
-  if (!existsSync8(timerPath)) {
+  const timerPath = join10(SYSTEMD_DIR, SYSTEMD_TIMER);
+  const servicePath = join10(SYSTEMD_DIR, SYSTEMD_SERVICE);
+  if (!existsSync10(timerPath)) {
     process.stderr.write("No systemd timer installed.\n");
     return;
   }
@@ -4552,29 +5043,29 @@ function uninstallSystemd() {
     });
   } catch {
   }
-  if (existsSync8(timerPath)) unlinkSync(timerPath);
-  if (existsSync8(servicePath)) unlinkSync(servicePath);
+  if (existsSync10(timerPath)) unlinkSync(timerPath);
+  if (existsSync10(servicePath)) unlinkSync(servicePath);
   process.stderr.write("Uninstalled systemd timer.\n");
 }
 function getStatus(notesDir) {
   const os = platform();
   if (os === "darwin") {
-    const logPath = join8(notesDir, ".brain-hook.log");
+    const logPath = join10(notesDir, ".brain-hook.log");
     let logSize = null;
     try {
       logSize = statSync2(logPath).size;
     } catch {
     }
     return {
-      installed: existsSync8(PLIST_PATH),
+      installed: existsSync10(PLIST_PATH),
       platform: "macOS (launchd)",
       logSize
     };
   }
   if (os === "linux") {
-    const timerPath = join8(SYSTEMD_DIR, SYSTEMD_TIMER);
+    const timerPath = join10(SYSTEMD_DIR, SYSTEMD_TIMER);
     return {
-      installed: existsSync8(timerPath),
+      installed: existsSync10(timerPath),
       platform: "Linux (systemd)",
       logSize: null
     };
@@ -4597,7 +5088,7 @@ var installHooksCommand = new Command20("install-hooks").description("Set up sch
 `);
       if (status.logSize !== null) {
         const kb = (status.logSize / 1024).toFixed(1);
-        process.stderr.write(`  Log: ${join8(config.notesDir, ".brain-hook.log")} (${kb} KB)
+        process.stderr.write(`  Log: ${join10(config.notesDir, ".brain-hook.log")} (${kb} KB)
 `);
       }
     }
@@ -4945,7 +5436,14 @@ program.addCommand(tidyCommand);
 program.addCommand(installHooksCommand);
 program.addCommand(doctorCommand);
 program.addCommand(lineageCommand);
-program.parseAsync().catch((err) => {
+async function main() {
+  const { registry } = await loadModules();
+  for (const { command } of registry.getCommands()) {
+    program.addCommand(command);
+  }
+  await program.parseAsync();
+}
+main().catch((err) => {
   process.stderr.write(`Error: ${err.message}
 `);
   process.exitCode = 1;