mindlore 0.0.1 → 0.1.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 mindlore
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 mindlore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -103,9 +103,51 @@ Also suggests installing:
 - **markitdown** — better web/document extraction (URL, DOCX, YouTube)
 - **context-mode** — token savings for large sessions
 
+## How It Works
+
+Mindlore operates through Claude Code lifecycle hooks — invisible background scripts
+that fire automatically as you work. No commands to run, no workflow changes.
+
+```
+                          ┌─────────────────────────────┐
+                          │     Claude Code Session      │
+                          └──────────────┬──────────────┘
+                                         │
+  ┌──────────────────────────────────────┼──────────────────────────────────────┐
+  │                                      │                                      │
+  ▼                                      ▼                                      ▼
+SESSION START                      DURING SESSION                         SESSION END
+  │                                      │                                      │
+  ├─ session-focus hook            ├─ search hook                         ├─ session-end hook
+  │  reads INDEX.md + last delta   │  7-col FTS5 + porter stemmer         │  writes delta to diary/
+  │  injects into context          │  per-keyword scoring, top 3 injected │
+  │                                │                                      │
+  │                                ├─ index + fts5-sync hooks             │
+  │                                │  file changes → FTS5 update          │
+  │                                │                                      │
+  │                                ├─ /mindlore-ingest skill              │
+  │                                │  URL → raw/ → sources/ → FTS5       │
+  │                                │                                      │
+  └────────────────────────────────┴──────────────────────────────────────┘
+                                         │
+                          ┌──────────────┴──────────────┐
+                          │       NEXT SESSION           │
+                          │  session-focus injects delta  │
+                          │  → knowledge compounds       │
+                          └─────────────────────────────┘
+```
+
+**Key design decisions:**
+
+- **Hooks are global** — registered in `~/.claude/settings.json`, active in all projects
+- **Data is per-project** — `.mindlore/` lives in each project directory
+- **No `.mindlore/`?** — hooks silently skip, zero overhead
+- **FTS5 search** — SQLite full-text search with BM25 ranking, no external services
+- **Content-hash dedup** — SHA256 prevents re-indexing unchanged files
+
 ## Hooks
 
-Mindlore works through 7 Claude Code lifecycle hooks (v0.1):
+7 Claude Code lifecycle hooks (v0.1):
 
 | Event | Hook | What it does |
 |-------|------|-------------|
@@ -117,6 +159,19 @@ Mindlore works through 7 Claude Code lifecycle hooks (v0.1):
 | PreCompact | pre-compact | FTS5 flush before compaction |
 | PostCompact | post-compact | Re-inject context |
 
+## Uninstall
+
+Remove Mindlore from your system:
+
+```bash
+npx mindlore uninstall
+```
+
+This removes:
+- Hooks from `~/.claude/settings.json`
+- Skills from `~/.claude/skills/`
+- Optionally: `.mindlore/` project data (asks for confirmation)
+
 ## Inspired By
 
 - [Andrej Karpathy](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) — LLM Knowledge Bases concept

package/SCHEMA.md

@@ -59,14 +59,14 @@ tags: [tag1, tag2]
 
 | Type | Required Fields | Optional |
 |------|----------------|----------|
-| `raw` | slug, type, source_url | tags |
-| `source` | slug, type, title, tags, quality, source_url, ingested | date_captured |
-| `domain` | slug, type, title, tags | — |
-| `analysis` | slug, type, title, tags, confidence, sources_used | — |
-| `insight` | slug, type, title, tags | sources_used |
-| `connection` | slug, type, title, tags | sources_used |
-| `learning` | slug, type, title, tags | — |
-| `decision` | slug, type, title, tags | supersedes, status |
+| `raw` | slug, type, source_url | tags, description |
+| `source` | slug, type, title, tags, quality, source_url, ingested | date_captured, description, raw_slug |
+| `domain` | slug, type, title, tags | description, status |
+| `analysis` | slug, type, title, tags, confidence, sources_used | description |
+| `insight` | slug, type, title, tags | sources_used, description |
+| `connection` | slug, type, title, tags | sources_used, description |
+| `learning` | slug, type, title, tags | description |
+| `decision` | slug, type, title, tags | supersedes, status, description |
 | `diary` | slug, type, date | — (hook adds automatically) |
 
 ### Field Value Rules
@@ -77,6 +77,9 @@ tags: [tag1, tag2]
 - `sources_used`: list of slugs referenced in the analysis
 - `supersedes`: slug of the decision this one replaces
 - `date`: ISO 8601 date (YYYY-MM-DD)
+- `description`: one-line summary (15-30 words). Used in FTS5 search and inject output. Optional but strongly recommended for search quality
+- `raw_slug`: slug of the raw/ file this source was processed from (source→raw traceability)
+- `status`: `stub` | `active` | `archived` (domain maturity indicator)
 
 ## 4. Seven Operations
 

package/hooks/lib/mindlore-common.cjs

@@ -41,6 +41,74 @@ function sha256(content) {
   return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
 
+/**
+ * Parse YAML frontmatter from markdown content.
+ * Returns { meta: { key: value }, body: string }
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { meta: {}, body: content };
+
+  const meta = {};
+  const lines = match[1].split('\n');
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value.slice(1, -1).split(',').map((s) => s.trim().replace(/^["']|["']$/g, ''));
+    }
+    if (typeof value === 'string') {
+      value = value.replace(/^["']|["']$/g, '');
+    }
+    meta[key] = value;
+  }
+
+  const bodyStart = content.indexOf('---', 3);
+  const body = bodyStart !== -1 ? content.slice(bodyStart + 3).replace(/^\r?\n/, '') : content;
+
+  return { meta, body };
+}
+
+/**
+ * Extract FTS5 metadata from parsed frontmatter + file path.
+ * Returns { slug, description, type, category, title }
+ */
+function extractFtsMetadata(meta, body, filePath, baseDir) {
+  const slug = meta.slug || path.basename(filePath, '.md');
+  const description = meta.description || '';
+  const type = meta.type || '';
+  const relativePath = baseDir ? path.relative(baseDir, filePath) : filePath;
+  const category = path.dirname(relativePath).split(path.sep)[0] || 'root';
+  let title = meta.title || meta.name || '';
+  if (!title) {
+    const headingMatch = body.match(/^#\s+(.+)/m);
+    title = headingMatch ? headingMatch[1].trim() : path.basename(filePath, '.md');
+  }
+  return { slug, description, type, category, title };
+}
+
+/**
+ * Shared SQL constants to prevent drift across indexing paths.
+ */
+const SQL_FTS_INSERT =
+  'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content) VALUES (?, ?, ?, ?, ?, ?, ?)';
+
+/**
+ * Extract headings (h1-h3) from markdown content.
+ */
+function extractHeadings(content, max) {
+  const headings = [];
+  for (const line of content.split('\n')) {
+    if (/^#{1,3}\s/.test(line)) {
+      headings.push(line.replace(/^#+\s*/, '').trim());
+      if (headings.length >= max) break;
+    }
+  }
+  return headings;
+}
+
 function requireDatabase() {
   try {
     return require('better-sqlite3');
@@ -84,6 +152,10 @@ module.exports = {
   findMindloreDir,
   getLatestDelta,
   sha256,
+  parseFrontmatter,
+  extractFtsMetadata,
+  SQL_FTS_INSERT,
+  extractHeadings,
   requireDatabase,
   openDatabase,
   getAllMdFiles,

package/hooks/mindlore-fts5-sync.cjs

@@ -13,7 +13,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, sha256, requireDatabase, getAllMdFiles } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT } = require('./lib/mindlore-common.cjs');
 
 function main() {
   // Read stdin to check if this is a .mindlore/ file change
@@ -35,24 +35,25 @@ function main() {
   // Only trigger on .mindlore/ changes (empty filePath = skip)
   if (!filePath || !filePath.includes(MINDLORE_DIR)) return;
 
+  // Skip if this is a single .md file change — mindlore-index.cjs handles those.
+  // This hook is for bulk changes (git pull, manual batch edits).
+  if (filePath.endsWith('.md')) return;
+
   const baseDir = path.join(process.cwd(), MINDLORE_DIR);
   if (!fs.existsSync(baseDir)) return;
 
   const dbPath = path.join(baseDir, DB_NAME);
   if (!fs.existsSync(dbPath)) return;
 
-  const Database = requireDatabase();
-  if (!Database) return;
-
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
+  const db = openDatabase(dbPath);
+  if (!db) return;
 
   const mdFiles = getAllMdFiles(baseDir);
   let synced = 0;
 
   const getHash = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?');
   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);
   const upsertHash = db.prepare(`
     INSERT INTO file_hashes (path, content_hash, last_indexed)
     VALUES (?, ?, ?)
@@ -72,8 +73,10 @@ function main() {
         const existing = getHash.get(file);
         if (existing && existing.content_hash === hash) continue;
 
+        const { meta, body } = parseFrontmatter(content);
+        const { slug, description, type, category, title } = extractFtsMetadata(meta, body, file, baseDir);
         deleteFts.run(file);
-        insertFts.run(file, content);
+        insertFts.run(file, slug, description, type, category, title, body);
         upsertHash.run(file, hash, now);
         synced++;
       }
@@ -84,7 +87,7 @@ function main() {
   }
 
   if (synced > 0) {
-    process.stderr.write(`[Mindlore FTS5 Sync: ${synced} files re-indexed]\n`);
+    process.stdout.write(`[Mindlore FTS5 Sync: ${synced} files re-indexed]\n`);
   }
 }
 

package/hooks/mindlore-index.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, requireDatabase } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT } = require('./lib/mindlore-common.cjs');
 
 function main() {
   let input = '';
@@ -43,13 +43,10 @@ function main() {
 
   if (!fs.existsSync(dbPath)) return;
 
-  const Database = requireDatabase();
-  if (!Database) return;
-
   if (!fs.existsSync(filePath)) {
     // File was deleted — remove from index
-    const db = new Database(dbPath);
-    db.pragma('journal_mode = WAL');
+    const db = openDatabase(dbPath);
+    if (!db) return;
     try {
       db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
       db.prepare('DELETE FROM file_hashes WHERE path = ?').run(filePath);
@@ -62,8 +59,8 @@ function main() {
   const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
   const hash = sha256(content);
 
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
+  const db = openDatabase(dbPath);
+  if (!db) return;
 
   try {
     // Check if content changed
@@ -73,12 +70,13 @@ function main() {
 
     if (existing && existing.content_hash === hash) return; // Unchanged
 
+    // Parse frontmatter for rich FTS5 columns
+    const { meta, body } = parseFrontmatter(content);
+    const { slug, description, type, category, title } = extractFtsMetadata(meta, body, filePath, baseDir);
+
     // Update FTS5
     db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
-    db.prepare('INSERT INTO mindlore_fts (path, content) VALUES (?, ?)').run(
-      filePath,
-      content
-    );
+    db.prepare(SQL_FTS_INSERT).run(filePath, slug, description, type, category, title, body);
 
     // Update hash
     db.prepare(

package/hooks/mindlore-post-compact.cjs

@@ -7,7 +7,7 @@
  * After context compaction, re-inject session context:
  * 1. Read INDEX.md
  * 2. Read latest delta
- * 3. Inject via stderr (same as session-focus)
+ * 3. Inject via stdout (same as session-focus)
  *
  * This ensures the agent has knowledge context after compaction.
  */
@@ -39,7 +39,7 @@ function main() {
   }
 
   if (output.length > 0) {
-    process.stderr.write(output.join('\n\n') + '\n');
+    process.stdout.write(output.join('\n\n') + '\n');
   }
 }
 

package/hooks/mindlore-pre-compact.cjs

@@ -42,7 +42,7 @@ function main() {
     fs.appendFileSync(logPath, entry, 'utf8');
   }
 
-  process.stderr.write('[Mindlore: pre-compact FTS5 flush complete]\n');
+  process.stdout.write('[Mindlore: pre-compact FTS5 flush complete]\n');
 }
 
 main();

package/hooks/mindlore-search.cjs

@@ -4,59 +4,62 @@
 /**
  * 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 } = 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');
@@ -67,12 +70,12 @@ function main() {
   let userMessage = '';
   try {
     const parsed = JSON.parse(input);
-    userMessage = parsed.content || parsed.message || parsed.query || input;
+    userMessage = parsed.prompt || parsed.content || parsed.message || parsed.query || input;
   } catch (_err) {
     userMessage = input;
   }
 
-  if (!userMessage || userMessage.length < MIN_QUERY_LENGTH) return;
+  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
 
   const baseDir = findMindloreDir();
   if (!baseDir) return;
@@ -81,7 +84,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 +92,67 @@ 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
+        }
+      }
 
-    const results = db
-      .prepare(
-        `SELECT path, rank
-         FROM mindlore_fts
-         WHERE mindlore_fts MATCH ?
-         ORDER BY rank
-         LIMIT ?`
-      )
-      .all(ftsQuery, MAX_RESULTS);
+      if (hits >= MIN_KEYWORD_HITS) {
+        scores.push({ path: row.path, hits, totalRank });
+      }
+    }
 
-    if (results.length === 0) return;
+    // 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);
+
+    if (relevant.length === 0) return;
+
+    // Build rich inject output
+    const metaStmt = db.prepare(
+      'SELECT slug, description, category, title 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(', ')}` : '';
+      output.push(
+        `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${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-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.1.0",
   "description": "AI-native knowledge system for Claude Code",
   "type": "commonjs",
   "bin": {