mindlore 0.0.1 → 0.2.0

package/hooks/mindlore-search.cjs

@@ -4,75 +4,64 @@
 /**
  * mindlore-search — UserPromptSubmit hook
  *
- * Extracts keywords from user prompt, searches FTS5, injects top 3 results.
- * Results: file path + first 2 headings via stderr additionalContext.
+ * Extracts keywords from user prompt, searches FTS5 with per-keyword scoring,
+ * injects top results with description + headings (matching old knowledge system quality).
  */
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, DB_NAME, requireDatabase } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, DB_NAME, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 const MAX_RESULTS = 3;
-const MIN_QUERY_LENGTH = 3;
+const MIN_QUERY_WORDS = 3;
+const MIN_KEYWORD_HITS = 2;
+
+// Extended stop words (~70 TR + EN) matching old knowledge system
+const STOP_WORDS = new Set([
+  // English
+  'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+  'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
+  'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
+  'it', 'its', 'this', 'that', 'these', 'those', 'what', 'which', 'who',
+  'whom', 'how', 'when', 'where', 'why', 'not', 'no', 'nor', 'so',
+  'if', 'or', 'but', 'all', 'each', 'every', 'both', 'few', 'more',
+  'most', 'other', 'some', 'such', 'only', 'own', 'same', 'than',
+  'and', 'about', 'between', 'after', 'before', 'above', 'below',
+  'up', 'down', 'out', 'very', 'just', 'also', 'now', 'then',
+  'here', 'there', 'too', 'yet', 'my', 'your', 'his', 'her', 'our',
+  'their', 'me', 'him', 'us', 'them', 'i', 'you', 'he', 'she', 'we', 'they',
+  // Turkish
+  'bir', 'bu', 'su', 'ne', 'nasil', 'neden', 'var', 'yok', 'mi', 'mu',
+  'ile', 'icin', 'de', 'da', 've', 'veya', 'ama', 'ise', 'hem',
+  'bakalim', 'gel', 'git', 'yap', 'et', 'al', 'ver',
+  'evet', 'hayir', 'tamam', 'ok', 'oldu', 'olur', 'dur',
+  'simdi', 'sonra', 'once', 'hemen', 'biraz',
+  'lan', 'ya', 'ki', 'abi', 'hadi', 'hey', 'selam',
+  'olarak', 'olan', 'gibi', 'kadar', 'daha', 'cok', 'hem',
+  'bunu', 'buna', 'icinde', 'uzerinde', 'arasinda',
+  'sonucu', 'tarafindan', 'zaten', 'gayet',
+  'acaba', 'nedir', 'midir', 'mudur',
+  // Generic technical (appears everywhere, not distinctive)
+  'hook', 'file', 'dosya', 'kullan', 'ekle', 'yaz', 'oku', 'calistir',
+  'kontrol', 'test', 'check', 'run', 'add', 'update', 'config',
+  'setup', 'install', 'start', 'stop', 'create', 'delete', 'remove', 'set',
+  'get', 'list', 'show', 'view', 'open', 'close', 'save', 'load',
+]);
 
 function extractKeywords(text) {
-  // Remove common stop words and short words
-  const stopWords = new Set([
-    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
-    'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about', 'between',
-    'through', 'after', 'before', 'above', 'below', 'up', 'down', 'out',
-    'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either',
-    'neither', 'each', 'every', 'all', 'any', 'few', 'more', 'most',
-    'other', 'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too',
-    'very', 'just', 'also', 'now', 'then', 'here', 'there', 'when',
-    'where', 'why', 'how', 'what', 'which', 'who', 'whom', 'this',
-    'that', 'these', 'those', 'it', 'its', 'my', 'your', 'his', 'her',
-    'our', 'their', 'me', 'him', 'us', 'them', 'i', 'you', 'he', 'she',
-    'we', 'they', 'bu', 'su', 'bir', 'de', 'da', 've', 'ile', 'icin',
-    'var', 'mi', 'ne', 'nasil', 'nedir', 'evet', 'hayir',
-  ]);
-
   const words = text
     .toLowerCase()
-    .replace(/[^a-z0-9\u00e7\u011f\u0131\u00f6\u015f\u00fc\s-]/g, ' ')
+    .replace(/[^\w\s\u00e7\u011f\u0131\u00f6\u015f\u00fc-]/g, ' ')
     .split(/\s+/)
-    .filter((w) => w.length >= MIN_QUERY_LENGTH && !stopWords.has(w));
-
-  // Deduplicate and limit
-  return [...new Set(words)].slice(0, 5);
-}
+    .filter((w) => w.length >= 3 && !STOP_WORDS.has(w) && !/^\d+$/.test(w));
 
-function extractHeadings(content, max) {
-  const headings = [];
-  for (const line of content.split('\n')) {
-    if (line.startsWith('#')) {
-      headings.push(line.replace(/^#+\s*/, '').trim());
-      if (headings.length >= max) break;
-    }
-  }
-  return headings;
+  return [...new Set(words)].slice(0, 8);
 }
 
 function main() {
-  // Read user prompt from stdin
-  let input = '';
-  try {
-    input = fs.readFileSync(0, 'utf8');
-  } catch (_err) {
-    return;
-  }
-
-  let userMessage = '';
-  try {
-    const parsed = JSON.parse(input);
-    userMessage = parsed.content || parsed.message || parsed.query || input;
-  } catch (_err) {
-    userMessage = input;
-  }
-
-  if (!userMessage || userMessage.length < MIN_QUERY_LENGTH) return;
+  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
+  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
 
   const baseDir = findMindloreDir();
   if (!baseDir) return;
@@ -81,7 +70,7 @@ function main() {
   if (!fs.existsSync(dbPath)) return;
 
   const keywords = extractKeywords(userMessage);
-  if (keywords.length === 0) return;
+  if (keywords.length < MIN_QUERY_WORDS) return;
 
   const Database = requireDatabase();
   if (!Database) return;
@@ -89,39 +78,68 @@ function main() {
   const db = new Database(dbPath, { readonly: true });
 
   try {
-    // Build FTS5 query — OR between keywords
-    const ftsQuery = keywords.join(' OR ');
+    // Per-keyword scoring (like old knowledge-search.cjs)
+    // Count how many keywords match each document
+    const allPaths = db.prepare('SELECT DISTINCT path FROM mindlore_fts').all();
+    const scores = [];
+    const matchStmt = db.prepare('SELECT rank FROM mindlore_fts WHERE path = ? AND mindlore_fts MATCH ?');
+
+    for (const row of allPaths) {
+      let hits = 0;
+      let totalRank = 0;
+
+      for (const kw of keywords) {
+        try {
+          const r = matchStmt.get(row.path, '"' + kw + '"');
+          if (r) {
+            hits++;
+            totalRank += r.rank;
+          }
+        } catch (_err) {
+          // FTS5 query error for this keyword — skip
+        }
+      }
+
+      if (hits >= MIN_KEYWORD_HITS) {
+        scores.push({ path: row.path, hits, totalRank });
+      }
+    }
+
+    // Sort: most keyword hits first, then best rank
+    scores.sort((a, b) => b.hits - a.hits || a.totalRank - b.totalRank);
+    const relevant = scores.slice(0, MAX_RESULTS);
 
-    const results = db
-      .prepare(
-        `SELECT path, rank
-         FROM mindlore_fts
-         WHERE mindlore_fts MATCH ?
-         ORDER BY rank
-         LIMIT ?`
-      )
-      .all(ftsQuery, MAX_RESULTS);
+    if (relevant.length === 0) return;
 
-    if (results.length === 0) return;
+    // Build rich inject output
+    const metaStmt = db.prepare(
+      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
+    );
 
     const output = [];
-    for (const r of results) {
-      const relativePath = path.relative(baseDir, r.path);
-      let headings = [];
+    for (const r of relevant) {
+      const meta = metaStmt.get(r.path) || {};
+      const relativePath = path.relative(baseDir, r.path).replace(/\\/g, '/');
 
+      let headings = [];
       if (fs.existsSync(r.path)) {
         const content = fs.readFileSync(r.path, 'utf8');
-        headings = extractHeadings(content, 2);
+        headings = extractHeadings(content, 5);
       }
 
-      const headingStr = headings.length > 0 ? ` — ${headings.join(', ')}` : '';
-      output.push(`${relativePath}${headingStr}`);
+      const category = meta.category || path.dirname(relativePath).split('/')[0];
+      const title = meta.title || meta.slug || path.basename(r.path, '.md');
+      const description = meta.description || '';
+
+      const headingStr = headings.length > 0 ? `\nBasliklar: ${headings.join(', ')}` : '';
+      const tagsStr = meta.tags ? `\nTags: ${meta.tags}` : '';
+      output.push(
+        `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${tagsStr}${headingStr}`
+      );
     }
 
     if (output.length > 0) {
-      process.stderr.write(
-        `[Mindlore Search: ${keywords.join(', ')}]\n${output.join('\n')}\n`
-      );
+      process.stdout.write(output.join('\n\n') + '\n');
     }
   } catch (_err) {
     // FTS5 query error — silently skip

package/hooks/mindlore-session-end.cjs

@@ -11,6 +11,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 const { findMindloreDir } = require('./lib/mindlore-common.cjs');
 
 function formatDate(date) {
@@ -22,6 +23,47 @@ function formatDate(date) {
   return `${y}-${m}-${d}-${h}${min}`;
 }
 
+function getRecentGitChanges() {
+  try {
+    const raw = execSync('git diff --name-only HEAD~5..HEAD 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    if (!raw) return [];
+    return raw.split('\n').filter(Boolean).slice(0, 20);
+  } catch (_err) {
+    return [];
+  }
+}
+
+function getRecentCommits() {
+  try {
+    const raw = execSync('git log --oneline -5 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    if (!raw) return [];
+    return raw.split('\n').filter(Boolean);
+  } catch (_err) {
+    return [];
+  }
+}
+
+function getSessionReads(baseDir) {
+  const readsPath = path.join(baseDir, 'diary', '_session-reads.json');
+  if (!fs.existsSync(readsPath)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
+    const count = Object.keys(data).length;
+    const repeats = Object.values(data).filter((v) => v > 1).length;
+    // Clean up session file
+    fs.unlinkSync(readsPath);
+    return { count, repeats };
+  } catch (_err) {
+    return null;
+  }
+}
+
 function main() {
   const baseDir = findMindloreDir();
   if (!baseDir) return;
@@ -38,7 +80,12 @@ function main() {
   // Don't overwrite existing delta (idempotent)
   if (fs.existsSync(deltaPath)) return;
 
-  const content = [
+  // Gather structured data
+  const commits = getRecentCommits();
+  const changedFiles = getRecentGitChanges();
+  const reads = getSessionReads(baseDir);
+
+  const sections = [
     '---',
     `slug: delta-${dateStr}`,
     'type: diary',
@@ -48,14 +95,33 @@ function main() {
     `# Session Delta — ${dateStr}`,
     '',
     `Session ended: ${now.toISOString()}`,
-    '',
-    '## Changes',
-    '',
-    '_No structured changes tracked in v0.1. Upgrade to v0.2 for detailed deltas._',
-    '',
-  ].join('\n');
+  ];
+
+  // Commits section
+  sections.push('', '## Commits');
+  if (commits.length > 0) {
+    for (const c of commits) sections.push(`- ${c}`);
+  } else {
+    sections.push('- _(no commits)_');
+  }
+
+  // Changed files section
+  sections.push('', '## Changed Files');
+  if (changedFiles.length > 0) {
+    for (const f of changedFiles) sections.push(`- ${f}`);
+  } else {
+    sections.push('- _(no file changes)_');
+  }
+
+  // Read stats (from read-guard, if active)
+  if (reads) {
+    sections.push('', '## Read Stats');
+    sections.push(`- ${reads.count} files read, ${reads.repeats} repeated reads`);
+  }
+
+  sections.push('');
 
-  fs.writeFileSync(deltaPath, content, 'utf8');
+  fs.writeFileSync(deltaPath, sections.join('\n'), 'utf8');
 
   // Append to log.md
   const logPath = path.join(baseDir, 'log.md');

package/hooks/mindlore-session-focus.cjs

@@ -5,7 +5,7 @@
  * mindlore-session-focus — SessionStart hook
  *
  * Injects last delta file content + INDEX.md into session context.
- * Fires once at session start via stderr additionalContext.
+ * Fires once at session start via stdout additionalContext.
  */
 
 const fs = require('fs');
@@ -35,7 +35,7 @@ function main() {
   }
 
   if (output.length > 0) {
-    process.stderr.write(output.join('\n\n') + '\n');
+    process.stdout.write(output.join('\n\n') + '\n');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindlore",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "AI-native knowledge system for Claude Code",
   "type": "commonjs",
   "bin": {

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mindlore",
   "description": "AI-native knowledge system for Claude Code. Persistent, searchable, evolving knowledge base with FTS5.",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "skills": [
     {
       "name": "mindlore-ingest",
@@ -11,7 +11,22 @@
     {
       "name": "mindlore-health",
       "path": "skills/mindlore-health/SKILL.md",
-      "description": "Run 16-point structural health check on .mindlore/ knowledge base"
+      "description": "Run 18-point structural health check on .mindlore/ knowledge base"
+    },
+    {
+      "name": "mindlore-query",
+      "path": "skills/mindlore-query/SKILL.md",
+      "description": "Search, ask, stats, brief — compounding knowledge pipeline"
+    },
+    {
+      "name": "mindlore-log",
+      "path": "skills/mindlore-log/SKILL.md",
+      "description": "Session logging, pattern extraction, wiki updates"
+    },
+    {
+      "name": "mindlore-decide",
+      "path": "skills/mindlore-decide/SKILL.md",
+      "description": "Record and list decisions with context, alternatives, rationale"
     }
   ],
   "hooks": [
@@ -23,6 +38,10 @@
       "event": "UserPromptSubmit",
       "script": "hooks/mindlore-search.cjs"
     },
+    {
+      "event": "UserPromptSubmit",
+      "script": "hooks/mindlore-decision-detector.cjs"
+    },
     {
       "event": "FileChanged",
       "script": "hooks/mindlore-index.cjs"
@@ -42,6 +61,11 @@
     {
       "event": "PostCompact",
       "script": "hooks/mindlore-post-compact.cjs"
+    },
+    {
+      "event": "PreToolUse",
+      "script": "hooks/mindlore-read-guard.cjs",
+      "if": "Read"
     }
   ]
 }

package/scripts/init.cjs

@@ -14,7 +14,8 @@ const path = require('path');
 
 // ── Constants ──────────────────────────────────────────────────────────
 
-const { MINDLORE_DIR, DB_NAME, DIRECTORIES } = require('./lib/constants.cjs');
+const { MINDLORE_DIR, DB_NAME, DIRECTORIES, homedir } = require('./lib/constants.cjs');
+const { SQL_FTS_CREATE } = require('../hooks/lib/mindlore-common.cjs');
 
 const TEMPLATE_FILES = ['INDEX.md', 'log.md'];
 
@@ -84,11 +85,51 @@ function copyTemplates(baseDir, packageRoot) {
 
 // ── Step 3: Create FTS5 database ───────────────────────────────────────
 
+function migrateDatabase(dbPath, Database) {
+  const db = new Database(dbPath);
+  try {
+    // Check if FTS5 table has the new schema (7 columns with slug, description, etc.)
+    const info = db.pragma('table_info(mindlore_fts)');
+    const columns = info.map((r) => r.name);
+    if (!columns.includes('slug') || !columns.includes('description')) {
+      log('Upgrading FTS5 schema (2 → 9 columns, porter stemmer)...');
+      db.exec('DROP TABLE IF EXISTS mindlore_fts');
+      db.exec(SQL_FTS_CREATE);
+      db.exec('DELETE FROM file_hashes');
+      db.close();
+      return true;
+    } else if (!columns.includes('tags')) {
+      log('Upgrading FTS5 schema (7 → 9 columns, +tags +quality)...');
+      db.exec('DROP TABLE IF EXISTS mindlore_fts');
+      db.exec(SQL_FTS_CREATE);
+      db.exec('DELETE FROM file_hashes');
+      db.close();
+      return true;
+    }
+  } catch (_err) {
+    // table_info fails on FTS5 virtual tables in some versions — recreate
+    db.exec('DROP TABLE IF EXISTS mindlore_fts');
+    db.exec(SQL_FTS_CREATE);
+    db.exec('DELETE FROM file_hashes');
+    db.close();
+    return true;
+  }
+  db.close();
+  return false;
+}
+
 function createDatabase(baseDir) {
   const dbPath = path.join(baseDir, DB_NAME);
   if (fs.existsSync(dbPath)) {
-    log('Database already exists, skipping');
-    return false;
+    let Database;
+    try { Database = require('better-sqlite3'); } catch (_err) { return false; }
+    const migrated = migrateDatabase(dbPath, Database);
+    if (migrated) {
+      log('FTS5 schema upgraded — run index to rebuild');
+    } else {
+      log('Database already exists, schema OK');
+    }
+    return migrated;
   }
 
   let Database;
@@ -103,10 +144,7 @@ function createDatabase(baseDir) {
   const db = new Database(dbPath);
   db.pragma('journal_mode = WAL');
 
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts
-    USING fts5(path, content, tokenize='unicode61');
-  `);
+  db.exec(SQL_FTS_CREATE);
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS file_hashes (
@@ -124,7 +162,7 @@ function createDatabase(baseDir) {
 
 function mergeHooks(packageRoot) {
   const settingsPath = path.join(
-    require('./lib/constants.cjs').homedir(),
+    homedir(),
     '.claude',
     'settings.json'
   );
@@ -239,7 +277,59 @@ function addSchemaToProjectDocs() {
   return false;
 }
 
-// ── Step 6: Add .mindlore/ to .gitignore ───────────────────────────────
+// ── Step 6: Register skills ────────────────────────────────────────────
+
+function registerSkills(packageRoot, plugin) {
+  const skillsDir = path.join(homedir(), '.claude', 'skills');
+  ensureDir(skillsDir);
+
+  if (!plugin.skills || plugin.skills.length === 0) return 0;
+
+  let added = 0;
+  for (const skill of plugin.skills) {
+    const skillSrcDir = path.join(packageRoot, path.dirname(skill.path));
+    const skillDestDir = path.join(skillsDir, skill.name);
+
+    ensureDir(skillDestDir);
+    const entries = fs.readdirSync(skillSrcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      fs.copyFileSync(
+        path.join(skillSrcDir, entry.name),
+        path.join(skillDestDir, entry.name)
+      );
+    }
+    added++;
+  }
+
+  return added;
+}
+
+// ── Step 7: Install better-sqlite3 if needed ──────────────────────────
+
+function ensureBetterSqlite3() {
+  try {
+    require('better-sqlite3');
+    return true;
+  } catch (_err) {
+    try {
+      const { execSync } = require('child_process');
+      log('Installing better-sqlite3 (native dependency)...');
+      execSync('npm install better-sqlite3 --no-save', {
+        cwd: process.cwd(),
+        stdio: 'pipe',
+        timeout: 120000,
+      });
+      return true;
+    } catch (_installErr) {
+      log('WARNING: Could not install better-sqlite3. FTS5 search disabled.');
+      log('  Run manually: npm install better-sqlite3');
+      return false;
+    }
+  }
+}
+
+// ── Step 8: Add .mindlore/ to .gitignore ───────────────────────────────
 
 function addToGitignore() {
   const gitignorePath = path.join(process.cwd(), '.gitignore');
@@ -263,9 +353,15 @@ function main() {
   const args = process.argv.slice(2);
   const command = args[0];
 
+  if (command === 'uninstall') {
+    require('./uninstall.cjs');
+    return;
+  }
+
   if (command && command !== 'init') {
     console.log(`Unknown command: ${command}`);
     console.log('Usage: npx mindlore init [--recommended]');
+    console.log('       npx mindlore uninstall [--all]');
     process.exit(1);
   }
 
@@ -291,11 +387,20 @@ function main() {
       : 'All templates already in place'
   );
 
-  // Step 3: Database
+  // Step 3: better-sqlite3 (before DB creation so it's available)
+  ensureBetterSqlite3();
+
+  // Step 4: Database
   const dbCreated = createDatabase(baseDir);
   log(dbCreated ? 'Created FTS5 database' : 'Database already exists');
 
-  // Step 4: Hooks
+  // Read plugin.json once for hooks + skills
+  const pluginPath = path.join(packageRoot, 'plugin.json');
+  const plugin = fs.existsSync(pluginPath)
+    ? JSON.parse(fs.readFileSync(pluginPath, 'utf8'))
+    : {};
+
+  // Step 5: Hooks
   const hooksAdded = mergeHooks(packageRoot);
   if (typeof hooksAdded === 'number' && hooksAdded > 0) {
     log(`Registered ${hooksAdded} hooks in ~/.claude/settings.json`);
@@ -303,7 +408,7 @@ function main() {
     log('Hooks already registered (or settings.json not found)');
   }
 
-  // Step 5: SCHEMA.md in projectDocFiles
+  // Step 6: SCHEMA.md in projectDocFiles
   const schemaAdded = addSchemaToProjectDocs();
   log(
     schemaAdded
@@ -311,7 +416,15 @@ function main() {
       : 'SCHEMA.md already in project settings'
   );
 
-  // Step 6: .gitignore
+  // Step 7: Skills
+  const skillsAdded = registerSkills(packageRoot, plugin);
+  log(
+    skillsAdded > 0
+      ? `Registered ${skillsAdded} skills in ~/.claude/skills/`
+      : 'Skills already registered'
+  );
+
+  // Step 8: .gitignore
   const gitignoreAdded = addToGitignore();
   log(
     gitignoreAdded

package/scripts/mindlore-fts5-index.cjs

@@ -13,7 +13,7 @@ const path = require('path');
 // ── Constants ──────────────────────────────────────────────────────────
 
 const { DB_NAME } = require('./lib/constants.cjs');
-const { sha256, getAllMdFiles } = require('../hooks/lib/mindlore-common.cjs');
+const { sha256, getAllMdFiles, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT } = require('../hooks/lib/mindlore-common.cjs');
 
 // ── Main ───────────────────────────────────────────────────────────────
 
@@ -26,17 +26,12 @@ function main() {
     process.exit(1);
   }
 
-  let Database;
-  try {
-    Database = require('better-sqlite3');
-  } catch (_err) {
+  const db = openDatabase(dbPath);
+  if (!db) {
     console.error('  better-sqlite3 not installed. Run: npm install better-sqlite3');
     process.exit(1);
   }
 
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-
   // Prepare statements
   const getHash = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?');
   const upsertHash = db.prepare(`
@@ -47,7 +42,7 @@ function main() {
       last_indexed = excluded.last_indexed
   `);
   const deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
-  const insertFts = db.prepare('INSERT INTO mindlore_fts (path, content) VALUES (?, ?)');
+  const insertFts = db.prepare(SQL_FTS_INSERT);
 
   // Get all .md files
   const mdFiles = getAllMdFiles(baseDir);
@@ -71,8 +66,10 @@ function main() {
         }
 
         // Update FTS5
+        const { meta, body } = parseFrontmatter(content);
+        const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, filePath, baseDir);
         deleteFts.run(filePath);
-        insertFts.run(filePath, content);
+        insertFts.run(filePath, slug, description, type, category, title, body, tags, quality);
 
         // Update hash
         upsertHash.run(filePath, hash, now);