mindlore 0.1.0 → 0.2.0

package/README.md

@@ -44,7 +44,7 @@ To add your first source:
 | Skill | Version | Description |
 |-------|---------|-------------|
 | `/mindlore-ingest` | v0.1 | Add knowledge sources (URL, text, file, PDF) |
-| `/mindlore-health` | v0.1 | 16-point structural health check |
+| `/mindlore-health` | v0.1 | 18-point structural health check |
 | `/mindlore-query` | v0.2 | Search and retrieve knowledge (4 modes) |
 | `/mindlore-log` | v0.2 | Session logging with reflect and status |
 | `/mindlore-decide` | v0.2 | Decision records with supersedes chain |
@@ -147,17 +147,19 @@ SESSION START                      DURING SESSION                         SESSIO
 
 ## Hooks
 
-7 Claude Code lifecycle hooks (v0.1):
+9 Claude Code lifecycle hooks (v0.2):
 
 | Event | Hook | What it does |
 |-------|------|-------------|
 | SessionStart | session-focus | Injects last delta + INDEX |
-| UserPromptSubmit | search | FTS5 search, top 3 results |
+| UserPromptSubmit | search | FTS5 search, top 3 results + tags |
+| UserPromptSubmit | decision-detector | TR+EN decision signal detection |
 | FileChanged | index | Sync changed files to FTS5 |
 | FileChanged | fts5-sync | Incremental batch re-index |
-| SessionEnd | session-end | Write delta to diary/ |
+| SessionEnd | session-end | Structured delta (commits, files, reads) |
 | PreCompact | pre-compact | FTS5 flush before compaction |
 | PostCompact | post-compact | Re-inject context |
+| PreToolUse (Read) | read-guard | Repeated-read warning |
 
 ## Uninstall
 

package/SCHEMA.md

@@ -143,14 +143,70 @@ Discover unexpected connections between sources. Cross-reference analysis.
 - Max results: 3 per query (BM25 ranking)
 - Hook injects: file path + first 2 headings
 
+### FTS5 Columns (9-col schema, v0.2)
+
+| Column | Indexed | Source |
+|--------|---------|--------|
+| `path` | UNINDEXED | File system path |
+| `slug` | Yes | Frontmatter slug |
+| `description` | Yes | Frontmatter description |
+| `type` | UNINDEXED | Frontmatter type |
+| `category` | Yes | Parent directory name |
+| `title` | Yes | Frontmatter title or first heading |
+| `content` | Yes | Markdown body (sans frontmatter) |
+| `tags` | Yes | Frontmatter tags (comma-separated) |
+| `quality` | UNINDEXED | Frontmatter quality (NULL until 50+ sources) |
+
 ### Search Flow (UserPromptSubmit hook)
 
 1. Extract keywords from user prompt
 2. Query FTS5 with BM25 ranking
-3. Return max 3 results as stderr additionalContext
+3. Return max 3 results as stdout additionalContext
 4. Agent reads full file only if needed (progressive disclosure)
 
-## 6. Compounding
+## 6. Wiki vs Diary (Writeback Target Rules)
+
+Knowledge goes to one of two layers. The agent MUST pick the correct one.
+
+### Wiki Layer (permanent knowledge)
+
+Directories: `sources/`, `domains/`, `analyses/`, `insights/`, `connections/`, `learnings/`
+
+- Persists across sessions — reference value
+- Indexed by FTS5, discoverable via search hook
+- Updated by ingest, query writeback, reflect, evolve
+- Content should be factual, sourced, and reusable
+
+### Diary Layer (session-scoped logs)
+
+Directories: `diary/`, `decisions/`
+
+- Session-specific: deltas, logs, decision snapshots
+- diary/ entries get `archived: true` after reflect processes them
+- decisions/ are permanent but session-originated (context + rationale)
+- Patterns extracted from diary → moved to `learnings/` (wiki layer)
+
+### Selection Rule
+
+| Content Type | Target | Example |
+|-------------|--------|---------|
+| Ingested source summary | `sources/` | URL or text summary |
+| Topic wiki page | `domains/` | Consolidated knowledge on a subject |
+| Multi-source synthesis | `analyses/` | Comparison table, architecture decision |
+| Short Q&A answer | `insights/` | Query writeback (<200 lines) |
+| Cross-reference finding | `connections/` | Link between 2+ unrelated sources |
+| Persistent rule/lesson | `learnings/` | YAPMA/BEST PRACTICE from reflect |
+| Session log/delta | `diary/` | What happened this session |
+| Decision record | `decisions/` | Why X was chosen over Y |
+| Raw capture | `raw/` | Immutable original (URL dump, paste) |
+
+### Anti-patterns
+
+- Do NOT write session-specific notes to `insights/` — use `diary/`
+- Do NOT write permanent rules to `diary/` — use `learnings/`
+- Do NOT write decision rationale to `analyses/` — use `decisions/`
+
+## 7. Compounding
 
 Knowledge compounds when outputs become inputs:
 
@@ -173,7 +229,7 @@ Offer to save when:
 - Large synthesis (200+ lines, 3+ sources) → analyses/
 - Cross-cutting link → connections/
 
-## 7. Learnings
+## 8. Learnings
 
 Persistent rules extracted from reflect operations.
 Organized by topic: `git.md`, `testing.md`, `security.md`, etc.
@@ -201,7 +257,7 @@ tags: [testing, jest, mock]
 - Use `YAPMA:` / `BEST PRACTICE:` / `KRITIK:` prefixes
 - Reflect skill proposes, user approves before writing
 
-## 8. Naming Conventions
+## 9. Naming Conventions
 
 ### Files
 

package/hooks/lib/mindlore-common.cjs

@@ -86,14 +86,22 @@ function extractFtsMetadata(meta, body, filePath, baseDir) {
     const headingMatch = body.match(/^#\s+(.+)/m);
     title = headingMatch ? headingMatch[1].trim() : path.basename(filePath, '.md');
   }
-  return { slug, description, type, category, title };
+  let tags = '';
+  if (meta.tags) {
+    tags = Array.isArray(meta.tags) ? meta.tags.join(', ') : String(meta.tags);
+  }
+  const quality = meta.quality !== undefined && meta.quality !== null ? meta.quality : null;
+  return { slug, description, type, category, title, tags, quality };
 }
 
 /**
  * Shared SQL constants to prevent drift across indexing paths.
  */
+const SQL_FTS_CREATE =
+  "CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts USING fts5(path UNINDEXED, slug, description, type UNINDEXED, category, title, content, tags, quality UNINDEXED, tokenize='porter unicode61')";
+
 const SQL_FTS_INSERT =
-  'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content) VALUES (?, ?, ?, ?, ?, ?, ?)';
+  'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content, tags, quality) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)';
 
 /**
  * Extract headings (h1-h3) from markdown content.
@@ -145,6 +153,30 @@ function getAllMdFiles(dir, skip) {
   return results;
 }
 
+/**
+ * Read CC hook stdin and parse JSON envelope.
+ * Returns the value of the first matching field, or raw text as fallback.
+ * @param {string[]} fields - Priority-ordered field names to extract
+ */
+function readHookStdin(fields) {
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8').trim();
+  } catch (_err) {
+    return '';
+  }
+  if (!input) return '';
+  try {
+    const parsed = JSON.parse(input);
+    for (const f of fields) {
+      if (parsed[f]) return parsed[f];
+    }
+  } catch (_err) {
+    // plain text
+  }
+  return input;
+}
+
 module.exports = {
   MINDLORE_DIR,
   DB_NAME,
@@ -154,6 +186,8 @@ module.exports = {
   sha256,
   parseFrontmatter,
   extractFtsMetadata,
+  readHookStdin,
+  SQL_FTS_CREATE,
   SQL_FTS_INSERT,
   extractHeadings,
   requireDatabase,

package/hooks/mindlore-decision-detector.cjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-decision-detector — UserPromptSubmit hook
+ *
+ * Detects decision signals in user messages (TR + EN).
+ * Outputs a suggestion to record the decision via /mindlore-decide.
+ * Does NOT block (exit 0) — advisory only.
+ */
+
+const { findMindloreDir, readHookStdin } = require('./lib/mindlore-common.cjs');
+
+const SIGNALS_TR = [
+  'karar verdik', 'karar verildi', 'kararlastirdik', 'kararlaştırdık',
+  'şunu seçtik', 'sunu sectik', 'bunu yapmayalım', 'bunu yapmayalim',
+  'yerine', 'tercih ettik', 'onaylandi', 'onaylandı', 'kesinleşti', 'kesinlesti',
+  'vazgeçtik', 'vazgectik', 'iptal ettik',
+];
+
+const SIGNALS_EN = [
+  'decided', 'decision made', "let's go with", 'lets go with',
+  "we'll use", 'well use', 'approved', 'settled on',
+  'going with', 'chosen', 'finalized', 'rejected',
+];
+
+function detectDecision(text) {
+  const lower = text.toLowerCase();
+  for (const signal of SIGNALS_TR) {
+    if (lower.includes(signal)) return signal;
+  }
+  for (const signal of SIGNALS_EN) {
+    if (lower.includes(signal)) return signal;
+  }
+  return null;
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  const userText = readHookStdin(['prompt', 'content', 'message']);
+  if (!userText || userText.length < 10) return;
+
+  const signal = detectDecision(userText);
+  if (signal) {
+    process.stdout.write(`[Mindlore: Karar sinyali tespit edildi ("${signal}") — /mindlore-decide record ile kaydetmek ister misin?]\n`);
+  }
+}
+
+main();

package/hooks/mindlore-fts5-sync.cjs

@@ -13,24 +13,10 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
-  // Read stdin to check if this is a .mindlore/ file change
-  let input = '';
-  try {
-    input = fs.readFileSync(0, 'utf8').trim();
-  } catch (_err) {
-    // No stdin — skip
-  }
-
-  let filePath = '';
-  try {
-    const parsed = JSON.parse(input);
-    filePath = parsed.path || parsed.file_path || '';
-  } catch (_err) {
-    filePath = input;
-  }
+  const filePath = readHookStdin(['path', 'file_path']);
 
   // Only trigger on .mindlore/ changes (empty filePath = skip)
   if (!filePath || !filePath.includes(MINDLORE_DIR)) return;
@@ -74,9 +60,9 @@ function main() {
         if (existing && existing.content_hash === hash) continue;
 
         const { meta, body } = parseFrontmatter(content);
-        const { slug, description, type, category, title } = extractFtsMetadata(meta, body, file, baseDir);
+        const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, file, baseDir);
         deleteFts.run(file);
-        insertFts.run(file, slug, description, type, category, title, body);
+        insertFts.run(file, slug, description, type, category, title, body, tags, quality);
         upsertHash.run(file, hash, now);
         synced++;
       }

package/hooks/mindlore-index.cjs

@@ -10,24 +10,10 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
-  let input = '';
-  try {
-    input = fs.readFileSync(0, 'utf8').trim();
-  } catch (_err) {
-    return;
-  }
-
-  let filePath = '';
-  try {
-    const parsed = JSON.parse(input);
-    filePath = parsed.path || parsed.file_path || '';
-  } catch (_err) {
-    filePath = input;
-  }
-
+  const filePath = readHookStdin(['path', 'file_path']);
   if (!filePath) return;
 
   // Only process .md files inside .mindlore/
@@ -72,11 +58,11 @@ function main() {
 
     // Parse frontmatter for rich FTS5 columns
     const { meta, body } = parseFrontmatter(content);
-    const { slug, description, type, category, title } = extractFtsMetadata(meta, body, filePath, baseDir);
+    const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, filePath, baseDir);
 
     // Update FTS5
     db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
-    db.prepare(SQL_FTS_INSERT).run(filePath, slug, description, type, category, title, body);
+    db.prepare(SQL_FTS_INSERT).run(filePath, slug, description, type, category, title, body, tags, quality);
 
     // Update hash
     db.prepare(

package/hooks/mindlore-read-guard.cjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-read-guard — PreToolUse hook (if: "Read")
+ *
+ * OpenWolf repeated-read pattern: detects files read multiple times
+ * in the same session and emits a soft warning.
+ * Does NOT block (exit 0) — advisory only.
+ *
+ * Storage: .mindlore/diary/_session-reads.json
+ * Cleanup: session-end hook writes stats to delta then deletes the file.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, readHookStdin } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  const filePath = readHookStdin(['file_path', 'path']);
+  if (!filePath) return;
+
+  // Only track CWD-relative files, skip .mindlore/ internals
+  const cwd = process.cwd();
+  const resolved = path.resolve(filePath);
+  if (!resolved.startsWith(cwd)) return;
+  if (resolved.startsWith(path.resolve(baseDir))) return;
+
+  // Load or create session reads tracker
+  const diaryDir = path.join(baseDir, 'diary');
+  if (!fs.existsSync(diaryDir)) {
+    fs.mkdirSync(diaryDir, { recursive: true });
+  }
+
+  const readsPath = path.join(diaryDir, '_session-reads.json');
+  let reads = {};
+  if (fs.existsSync(readsPath)) {
+    try {
+      reads = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
+    } catch (_err) {
+      reads = {};
+    }
+  }
+
+  const normalizedPath = path.resolve(filePath);
+  const count = (reads[normalizedPath] || 0) + 1;
+  reads[normalizedPath] = count;
+
+  // Write updated reads
+  fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
+
+  // Warn on repeated reads (2nd+ time)
+  if (count > 1) {
+    const basename = path.basename(filePath);
+    process.stderr.write(`[Mindlore: ${basename} bu session'da ${count}. kez okunuyor. Değişiklik yoksa tekrar okumayı atlayabilirsin.]\n`);
+  }
+}
+
+main();

package/hooks/mindlore-search.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, DB_NAME, requireDatabase, extractHeadings } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, DB_NAME, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 const MAX_RESULTS = 3;
 const MIN_QUERY_WORDS = 3;
@@ -60,21 +60,7 @@ function extractKeywords(text) {
 }
 
 function main() {
-  let input = '';
-  try {
-    input = fs.readFileSync(0, 'utf8');
-  } catch (_err) {
-    return;
-  }
-
-  let userMessage = '';
-  try {
-    const parsed = JSON.parse(input);
-    userMessage = parsed.prompt || parsed.content || parsed.message || parsed.query || input;
-  } catch (_err) {
-    userMessage = input;
-  }
-
+  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
   if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
 
   const baseDir = findMindloreDir();
@@ -127,7 +113,7 @@ function main() {
 
     // Build rich inject output
     const metaStmt = db.prepare(
-      'SELECT slug, description, category, title FROM mindlore_fts WHERE path = ?'
+      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
     );
 
     const output = [];
@@ -146,8 +132,9 @@ function main() {
       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}${headingStr}`
+        `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${tagsStr}${headingStr}`
       );
     }
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindlore",
-  "version": "0.1.0",
+  "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

@@ -15,6 +15,7 @@ const path = require('path');
 // ── Constants ──────────────────────────────────────────────────────────
 
 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'];
 
@@ -91,13 +92,16 @@ function migrateDatabase(dbPath, Database) {
     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 → 7 columns, porter stemmer)...');
+      log('Upgrading FTS5 schema (2 → 9 columns, porter stemmer)...');
       db.exec('DROP TABLE IF EXISTS mindlore_fts');
-      db.exec(`
-        CREATE VIRTUAL TABLE mindlore_fts
-        USING fts5(path UNINDEXED, slug, description, type UNINDEXED, category, title, content, tokenize='porter unicode61');
-      `);
-      // Clear hashes so full re-index happens
+      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;
@@ -105,10 +109,7 @@ function migrateDatabase(dbPath, Database) {
   } catch (_err) {
     // table_info fails on FTS5 virtual tables in some versions — recreate
     db.exec('DROP TABLE IF EXISTS mindlore_fts');
-    db.exec(`
-      CREATE VIRTUAL TABLE mindlore_fts
-      USING fts5(path UNINDEXED, slug, description, type UNINDEXED, category, title, content, tokenize='porter unicode61');
-    `);
+    db.exec(SQL_FTS_CREATE);
     db.exec('DELETE FROM file_hashes');
     db.close();
     return true;
@@ -143,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 UNINDEXED, slug, description, type UNINDEXED, category, title, content, tokenize='porter unicode61');
-  `);
+  db.exec(SQL_FTS_CREATE);
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS file_hashes (

package/scripts/mindlore-fts5-index.cjs

@@ -67,9 +67,9 @@ function main() {
 
         // Update FTS5
         const { meta, body } = parseFrontmatter(content);
-        const { slug, description, type, category, title } = extractFtsMetadata(meta, body, filePath, baseDir);
+        const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, filePath, baseDir);
         deleteFts.run(filePath);
-        insertFts.run(filePath, slug, description, type, category, title, body);
+        insertFts.run(filePath, slug, description, type, category, title, body, tags, quality);
 
         // Update hash
         upsertHash.run(filePath, hash, now);

package/scripts/mindlore-health-check.cjs

@@ -15,35 +15,19 @@ const path = require('path');
 // ── Constants ──────────────────────────────────────────────────────────
 
 const { DIRECTORIES, TYPE_TO_DIR } = require('./lib/constants.cjs');
+const { parseFrontmatter: _parseFm, getAllMdFiles: _getAllMd } = require('../hooks/lib/mindlore-common.cjs');
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
+// Wrapper: shared parseFrontmatter returns { meta, body }, health-check expects flat object or null
 function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-
-  const fm = {};
-  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();
-    // Handle arrays
-    if (value.startsWith('[') && value.endsWith(']')) {
-      value = value
-        .slice(1, -1)
-        .split(',')
-        .map((s) => s.trim());
-    }
-    fm[key] = value;
-  }
-  return fm;
+  const { meta } = _parseFm(content);
+  return Object.keys(meta).length > 0 ? meta : null;
 }
 
 // Health check needs ALL .md files (no skip), so pass empty set
 function getAllMdFiles(dir) {
-  return require('../hooks/lib/mindlore-common.cjs').getAllMdFiles(dir, new Set());
+  return _getAllMd(dir, new Set());
 }
 
 // ── Checks ─────────────────────────────────────────────────────────────
@@ -148,24 +132,30 @@ class HealthChecker {
           .prepare('SELECT count(*) as cnt FROM file_hashes')
           .get();
 
-        // Verify 7-column schema (slug, description, type, category, title, content + path)
-        let schemaOk = true;
+        // Verify 9-column schema (slug, description, type, category, title, content, tags, quality + path)
+        let schemaVersion = 0;
         try {
-          db.prepare('SELECT slug, description, category, title FROM mindlore_fts LIMIT 0').run();
+          db.prepare('SELECT tags, quality FROM mindlore_fts LIMIT 0').run();
+          schemaVersion = 9;
         } catch (_err) {
-          schemaOk = false;
+          try {
+            db.prepare('SELECT slug, description, category, title FROM mindlore_fts LIMIT 0').run();
+            schemaVersion = 7;
+          } catch (_err2) {
+            schemaVersion = 2;
+          }
         }
 
-        if (!schemaOk) {
+        if (schemaVersion < 9) {
           return {
             warn: true,
-            detail: `${result.cnt} indexed, ${hashResult.cnt} hashes — OLD SCHEMA (run: npx mindlore init to upgrade)`,
+            detail: `${result.cnt} indexed, ${hashResult.cnt} hashes — ${schemaVersion}-col schema (run: npx mindlore init to upgrade to 9-col)`,
           };
         }
 
         return {
           ok: true,
-          detail: `${result.cnt} indexed, ${hashResult.cnt} hashes, 7-col schema`,
+          detail: `${result.cnt} indexed, ${hashResult.cnt} hashes, 9-col schema`,
         };
       } catch (err) {
         return { ok: false, detail: `FTS5 error: ${err.message}` };
@@ -279,11 +269,72 @@ class HealthChecker {
           detail: `${mdFiles.length} files validated`,
         };
       }
-      return {
-        ok: wrongDir > 0 ? false : undefined,
-        warn: wrongDir === 0,
-        detail: issues.join(', '),
-      };
+      if (wrongDir > 0) {
+        return { ok: false, detail: issues.join(', ') };
+      }
+      return { warn: true, detail: issues.join(', ') };
+    });
+  }
+
+  // Check 17: Stale deltas (30+ days without archived: true)
+  checkStaleDeltas() {
+    this.check('Stale deltas', () => {
+      const diaryDir = path.join(this.baseDir, 'diary');
+      if (!fs.existsSync(diaryDir)) return { ok: true, detail: 'no diary dir' };
+
+      const now = Date.now();
+      const thirtyDays = 30 * 24 * 60 * 60 * 1000;
+      let stale = 0;
+
+      const files = fs.readdirSync(diaryDir).filter((f) => f.startsWith('delta-') && f.endsWith('.md'));
+      for (const file of files) {
+        const fullPath = path.join(diaryDir, file);
+        const content = fs.readFileSync(fullPath, 'utf8').replace(/\r\n/g, '\n');
+        const fm = parseFrontmatter(content);
+        if (fm && fm.archived === 'true') continue;
+
+        const stat = fs.statSync(fullPath);
+        if (now - stat.mtimeMs > thirtyDays) stale++;
+      }
+
+      if (stale === 0) return { ok: true, detail: `${files.length} deltas, none stale` };
+      return { warn: true, detail: `${stale} deltas older than 30 days without archived flag — run /mindlore-log reflect` };
+    });
+  }
+
+  // Check 18: Conflicting analyses (same tags, different confidence)
+  checkConflictingAnalyses() {
+    this.check('Conflicting analyses', () => {
+      const analysesDir = path.join(this.baseDir, 'analyses');
+      if (!fs.existsSync(analysesDir)) return { ok: true, detail: 'no analyses dir' };
+
+      const files = fs.readdirSync(analysesDir).filter((f) => f.endsWith('.md'));
+      if (files.length < 2) return { ok: true, detail: `${files.length} analyses, no conflict possible` };
+
+      const tagMap = {};
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(analysesDir, file), 'utf8').replace(/\r\n/g, '\n');
+        const fm = parseFrontmatter(content);
+        if (!fm || !fm.tags || !fm.confidence) continue;
+
+        const tags = Array.isArray(fm.tags) ? fm.tags : String(fm.tags).split(',').map((t) => t.trim());
+        for (const tag of tags) {
+          if (!tagMap[tag]) tagMap[tag] = [];
+          tagMap[tag].push({ file, confidence: fm.confidence });
+        }
+      }
+
+      const conflicts = [];
+      for (const [tag, entries] of Object.entries(tagMap)) {
+        if (entries.length < 2) continue;
+        const confidences = new Set(entries.map((e) => e.confidence));
+        if (confidences.size > 1) {
+          conflicts.push(`${tag}: ${entries.map((e) => `${e.file}(${e.confidence})`).join(' vs ')}`);
+        }
+      }
+
+      if (conflicts.length === 0) return { ok: true, detail: `${files.length} analyses, no conflicts` };
+      return { warn: true, detail: `${conflicts.length} tag conflicts: ${conflicts.slice(0, 2).join('; ')}` };
     });
   }
 
@@ -296,6 +347,8 @@ class HealthChecker {
     this.checkDatabase();
     this.checkOrphans();
     this.checkFrontmatter();
+    this.checkStaleDeltas();
+    this.checkConflictingAnalyses();
     return this;
   }
 

package/skills/mindlore-decide/SKILL.md

@@ -0,0 +1,71 @@
+# Skill: Mindlore Decide
+
+Record and list decisions in the `.mindlore/decisions/` directory.
+
+## Trigger
+
+User says `/mindlore-decide record` or `/mindlore-decide list`.
+
+## Modes
+
+### record
+
+Record a new decision.
+
+**Flow:**
+1. Ask user (or extract from context): What was decided? What alternatives were considered? Why this choice?
+2. Generate slug from decision title (kebab-case, max 5 words)
+3. Check if a previous decision on same topic exists → set `supersedes` field
+4. Write to `.mindlore/decisions/{slug}.md` with frontmatter:
+
+```yaml
+---
+slug: use-fts5-over-vector
+type: decision
+title: Use FTS5 over vector search for v0.1
+tags: [search, fts5, architecture]
+date: 2026-04-11
+supersedes: null
+status: active
+description: Chose FTS5 keyword search as primary engine, vector deferred to v0.4
+---
+```
+
+5. Body structure:
+```markdown
+# {title}
+
+## Context
+Why this decision was needed.
+
+## Alternatives Considered
+1. **Option A** — pros/cons
+2. **Option B** — pros/cons
+
+## Decision
+What was chosen and why.
+
+## Consequences
+What this means going forward.
+```
+
+6. Append to `log.md`: `| {date} | decide | {slug}.md |`
+7. FTS5 auto-indexes via FileChanged hook
+
+### list
+
+List active decisions.
+
+**Flow:**
+1. Read all `.md` files in `.mindlore/decisions/`
+2. Parse frontmatter, filter `status: active`
+3. Display as table: slug, title, date, tags
+4. Show supersedes chain if any (A → B → C)
+
+## Rules
+
+- Slug must be unique in decisions/
+- `supersedes` field points to the slug of the replaced decision
+- When a decision is superseded, update old one: `status: superseded`
+- Tags should match domain topics for FTS5 discoverability
+- Keep decision body concise — context + alternatives + choice + consequences

package/skills/mindlore-ingest/SKILL.md

@@ -94,9 +94,20 @@ Only update the stats line: increment source count and total count.
 N source, N analysis, N total
 ```
 
-## Post-Ingest Verification
+## Post-Ingest Quality Gate
 
-After ingest, run health check:
+After every ingest, verify all 6 checkpoints before reporting success:
+
+1. **raw/ file exists** — immutable capture written with frontmatter (slug, type, source_url)
+2. **sources/ summary exists** — processed summary with full frontmatter (slug, type, title, tags, quality, description)
+3. **INDEX.md updated** — stats line incremented, Recent section has new entry
+4. **Domain updated** — if relevant domain exists, new finding added (max 1 domain per ingest)
+5. **log.md entry** — append `| {date} | ingest | {slug}.md |`
+6. **FTS5 indexed** — FileChanged hook auto-triggers, but verify: `node scripts/mindlore-fts5-search.cjs "{keyword}"` returns the new file
+
+If any checkpoint fails, fix it before reporting "ingest complete". Do NOT skip steps.
+
+Optional: run full health check for structural integrity:
 ```bash
 node scripts/mindlore-health-check.cjs
 ```

package/skills/mindlore-log/SKILL.md

@@ -0,0 +1,79 @@
+# Skill: Mindlore Log
+
+Session logging, pattern extraction, and wiki updates.
+
+## Trigger
+
+`/mindlore-log <mode>` where mode is `log`, `reflect`, `status`, or `save`.
+
+## Modes
+
+### log
+
+Write a manual diary entry.
+
+**Flow:**
+1. User provides note/observation (or extract from conversation context)
+2. Generate slug: `note-YYYY-MM-DD-HHmm`
+3. Write to `.mindlore/diary/{slug}.md`:
+
+```yaml
+---
+slug: note-2026-04-11-1530
+type: diary
+date: 2026-04-11
+---
+```
+
+4. Body: user's note as-is
+5. Append to `log.md`: `| {date} | log | {slug}.md |`
+
+### reflect
+
+Scan old deltas, extract patterns, write to learnings/.
+
+**Flow (v0.2 — basic):**
+1. Read all non-archived delta files in `diary/` (no `archived: true` frontmatter)
+2. Present summary to user: "Found N unprocessed deltas spanning DATE1 to DATE2"
+3. For each delta, extract: repeated topics, recurring decisions, common file changes
+4. Propose learnings to user: "I found these patterns: ..."
+5. User approves → write to `learnings/{topic}.md` (append if exists, create if not)
+6. Format: `YAPMA:` / `BEST PRACTICE:` / `KRITIK:` prefixed rules
+7. Mark processed deltas: add `archived: true` to their frontmatter
+8. Append to `log.md`: `| {date} | reflect | {N} deltas processed, {M} learnings written |`
+
+**Important:** Do NOT auto-extract patterns. Present findings, user approves. This is v0.2 basic mode — automated pattern extraction deferred to v0.2.1.
+
+### status
+
+Show recent session summary.
+
+**Flow:**
+1. Read last 5 delta files from `diary/` (sorted by date, newest first)
+2. For each delta, extract: date, commits count, changed files count
+3. Display as compact table
+4. Show any open items (from delta "Yarım Kalan" sections if present)
+5. Show total: "N sessions, M commits, K unique files changed"
+
+### save
+
+Structured delta + log.md append + domain wiki update.
+
+**Flow:**
+1. Gather current session context:
+   - Recent git commits (last 5)
+   - Changed files
+   - Decisions made (if decision-detector captured any)
+2. Write structured delta to `diary/delta-YYYY-MM-DD-HHmm.md` (same format as session-end hook)
+3. Append to `log.md`
+4. Ask user: "Which domain pages should be updated with this session's findings?"
+5. If user specifies domains → update those `.mindlore/domains/{slug}.md` pages with new findings
+6. Max 2 domain updates per save (prevent sprawl)
+
+## Rules
+
+- Diary files are session-scoped (temporary), learnings are permanent
+- reflect marks deltas as `archived: true` — they stay in diary/ but are not processed again
+- Health check warns on deltas older than 30 days without `archived: true`
+- learnings/ files are topic-based (one per topic), append-only
+- save mode is the manual equivalent of what session-end hook does automatically

package/skills/mindlore-query/SKILL.md

@@ -0,0 +1,125 @@
+# Skill: Mindlore Query
+
+Search, ask, analyze, and retrieve knowledge from `.mindlore/`.
+
+## Trigger
+
+`/mindlore-query <mode> [query]` where mode is `search`, `ask`, `stats`, or `brief`.
+
+## Modes
+
+### search
+
+FTS5 keyword search with direct results.
+
+**Flow:**
+1. Parse user query into keywords (strip stop words)
+2. Run FTS5 MATCH on `mindlore_fts` table
+3. Return top 5 results (configurable) with: path, title, description, category, rank score
+4. Display as table with snippet preview
+5. If `--tags <tag>` flag provided: `WHERE tags MATCH '<tag>'` filter
+
+**Output format:**
+```
+| # | Category | Title | Description | Score |
+|---|----------|-------|-------------|-------|
+| 1 | sources  | React Hooks | useEffect cleanup patterns | -2.34 |
+```
+
+### ask
+
+Compounding query pipeline — knowledge grows with each answer.
+
+**Flow:**
+1. Parse user question
+2. FTS5 search → find relevant files (sources + domains + analyses + insights — previous answers INCLUDED)
+3. Read top 3-5 relevant files using ctx_execute_file if context-mode available, else Read
+4. Synthesize answer from found knowledge
+5. Cite sources: `[kaynak: sources/x.md]` format
+6. Ask user: "Bu cevabı kaydetmemi ister misin?"
+7. If yes → determine target:
+   - Short answer (<200 lines, 1-2 sources) → `insights/{slug}.md`
+   - Large synthesis (200+ lines, 3+ sources) → `analyses/{slug}.md`
+8. Write with frontmatter:
+
+```yaml
+---
+slug: react-hooks-cleanup-comparison
+type: insight
+title: React Hooks Cleanup Comparison
+tags: [react, hooks, useEffect]
+confidence: high
+sources_used: [react-hooks, typescript-generics]
+description: Comparison of cleanup patterns in useEffect vs useLayoutEffect
+---
+```
+
+9. FTS5 auto-indexes via FileChanged hook → next query finds this answer
+10. Update relevant domain page (max 1) with backlink if applicable
+11. Append to `log.md`: `| {date} | query-ask | {slug}.md |`
+
+**Compounding effect:** Step 2 searches ALL of `.mindlore/` including previous `insights/` and `analyses/`. Each saved answer enriches the next query.
+
+**Error compounding prevention:**
+- `confidence` field is REQUIRED on writebacks (high/medium/low)
+- `sources_used` lists exact slugs — traceability
+- Health check flags conflicting analyses on same topic (different confidence)
+- User approval is the quality gate — low-quality answers are not saved
+
+### stats
+
+Knowledge base statistics.
+
+**Flow:**
+1. Count files per directory (9 directories)
+2. Count FTS5 entries and file_hashes entries
+3. Find most recent ingest (latest file by modified date per directory)
+4. Count tags frequency (parse all frontmatter, aggregate tags)
+5. Display summary:
+
+```
+Mindlore Stats
+─────────────
+Total files: 47 (FTS5: 47 indexed)
+ - sources:     18
+ - domains:      5
+ - analyses:     6
+ - insights:     3
+ - connections:  2
+ - learnings:    4
+ - diary:        8
+ - decisions:    1
+ - raw:          0
+
+Top tags: security (12), hooks (8), fts5 (6), testing (5)
+Last ingest: 2026-04-11 (sources/react-hooks.md)
+DB size: 1.2 MB
+```
+
+### brief
+
+Quick context on a topic — token-efficient (~50 tokens output).
+
+**Flow:**
+1. FTS5 search for topic
+2. If domain page exists → read first 3 lines of body (after frontmatter)
+3. If no domain → read description field from top FTS5 match
+4. Return: title + description + "Read full: {path}" pointer
+5. Do NOT read full file — this mode is for quick "do I need to open this?" decisions
+
+**Output format:**
+```
+[Mindlore Brief: Security]
+SSH hardening, firewall rules, audit checks. 5 sources, 2 analyses linked.
+→ Read full: .mindlore/domains/security.md
+```
+
+## Rules
+
+- All modes respect the SCHEMA.md writeback rules (Section 6: Wiki vs Diary)
+- search and brief are read-only — no writes
+- ask writes only with user approval
+- stats is read-only
+- Token strategy: prefer ctx_execute_file (if context-mode installed), fallback to Read
+- Tags filter: `--tags security` works in search and ask modes
+- Max results: search=5, ask=3-5 (for synthesis), brief=1

package/templates/SCHEMA.md

@@ -143,14 +143,70 @@ Discover unexpected connections between sources. Cross-reference analysis.
 - Max results: 3 per query (BM25 ranking)
 - Hook injects: file path + first 2 headings
 
+### FTS5 Columns (9-col schema, v0.2)
+
+| Column | Indexed | Source |
+|--------|---------|--------|
+| `path` | UNINDEXED | File system path |
+| `slug` | Yes | Frontmatter slug |
+| `description` | Yes | Frontmatter description |
+| `type` | UNINDEXED | Frontmatter type |
+| `category` | Yes | Parent directory name |
+| `title` | Yes | Frontmatter title or first heading |
+| `content` | Yes | Markdown body (sans frontmatter) |
+| `tags` | Yes | Frontmatter tags (comma-separated) |
+| `quality` | UNINDEXED | Frontmatter quality (NULL until 50+ sources) |
+
 ### Search Flow (UserPromptSubmit hook)
 
 1. Extract keywords from user prompt
 2. Query FTS5 with BM25 ranking
-3. Return max 3 results as stderr additionalContext
+3. Return max 3 results as stdout additionalContext
 4. Agent reads full file only if needed (progressive disclosure)
 
-## 6. Compounding
+## 6. Wiki vs Diary (Writeback Target Rules)
+
+Knowledge goes to one of two layers. The agent MUST pick the correct one.
+
+### Wiki Layer (permanent knowledge)
+
+Directories: `sources/`, `domains/`, `analyses/`, `insights/`, `connections/`, `learnings/`
+
+- Persists across sessions — reference value
+- Indexed by FTS5, discoverable via search hook
+- Updated by ingest, query writeback, reflect, evolve
+- Content should be factual, sourced, and reusable
+
+### Diary Layer (session-scoped logs)
+
+Directories: `diary/`, `decisions/`
+
+- Session-specific: deltas, logs, decision snapshots
+- diary/ entries get `archived: true` after reflect processes them
+- decisions/ are permanent but session-originated (context + rationale)
+- Patterns extracted from diary → moved to `learnings/` (wiki layer)
+
+### Selection Rule
+
+| Content Type | Target | Example |
+|-------------|--------|---------|
+| Ingested source summary | `sources/` | URL or text summary |
+| Topic wiki page | `domains/` | Consolidated knowledge on a subject |
+| Multi-source synthesis | `analyses/` | Comparison table, architecture decision |
+| Short Q&A answer | `insights/` | Query writeback (<200 lines) |
+| Cross-reference finding | `connections/` | Link between 2+ unrelated sources |
+| Persistent rule/lesson | `learnings/` | YAPMA/BEST PRACTICE from reflect |
+| Session log/delta | `diary/` | What happened this session |
+| Decision record | `decisions/` | Why X was chosen over Y |
+| Raw capture | `raw/` | Immutable original (URL dump, paste) |
+
+### Anti-patterns
+
+- Do NOT write session-specific notes to `insights/` — use `diary/`
+- Do NOT write permanent rules to `diary/` — use `learnings/`
+- Do NOT write decision rationale to `analyses/` — use `decisions/`
+
+## 7. Compounding
 
 Knowledge compounds when outputs become inputs:
 
@@ -173,7 +229,7 @@ Offer to save when:
 - Large synthesis (200+ lines, 3+ sources) → analyses/
 - Cross-cutting link → connections/
 
-## 7. Learnings
+## 8. Learnings
 
 Persistent rules extracted from reflect operations.
 Organized by topic: `git.md`, `testing.md`, `security.md`, etc.
@@ -201,7 +257,7 @@ tags: [testing, jest, mock]
 - Use `YAPMA:` / `BEST PRACTICE:` / `KRITIK:` prefixes
 - Reflect skill proposes, user approves before writing
 
-## 8. Naming Conventions
+## 9. Naming Conventions
 
 ### Files