mindlore 0.6.0 → 0.6.2

package/hooks/lib/mindlore-common.cjs

@@ -154,6 +154,23 @@ const SQL_FTS_CREATE =
 const SQL_FTS_INSERT =
   'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content, tags, quality, date_captured, project) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
 
+const SQL_FTS_SESSIONS_CREATE =
+  "CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts_sessions USING fts5(path, slug, description, type, category, title, content, tags, quality, date_captured, project)";
+
+const SQL_FTS_SESSIONS_INSERT =
+  'INSERT INTO mindlore_fts_sessions (path, slug, description, type, category, title, content, tags, quality, date_captured, project) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+
+const SESSION_CATEGORIES = ['cc-subagent', 'cc-session'];
+
+function isSessionCategory(category) {
+  return SESSION_CATEGORIES.includes(category);
+}
+
+const VERSION_RE = /v(\d+)\.(\d+)(?:\.(\d+))?/g;
+function fixVersionTokens(query) {
+  return query.replace(VERSION_RE, (_m, a, b, c) => c ? `"v${a} ${b} ${c}"` : `"v${a} ${b}"`);
+}
+
 /**
  * Insert a row into FTS5 using an object parameter (replaces positional args).
  */
@@ -330,7 +347,7 @@ CREATE TABLE IF NOT EXISTS episodes (
 // ~625 tokens context budget for multi-session inject (~4 chars/token)
 const MULTI_SESSION_TOKEN_CAP_CHARS = 2500;
 
-const EPISODE_KINDS_CJS = ['session', 'decision', 'event', 'preference', 'learning', 'friction', 'discovery', 'nomination'];
+const EPISODE_KINDS_CJS = ['session', 'decision', 'event', 'preference', 'learning', 'friction', 'discovery', 'nomination', 'session-summary'];
 
 /**
  * Valid episode statuses. CO-EVOLUTION: mirrors EPISODE_STATUSES in scripts/lib/episodes.ts
@@ -623,7 +640,7 @@ function resolveWin32Bin(name) {
   if (process.platform === 'win32') {
     try {
       return require('child_process')
-        .execSync(`where ${name}`, { encoding: 'utf8', timeout: 3000 })
+        .execSync(`where ${name}`, { encoding: 'utf8', timeout: 3000, windowsHide: true })
         .trim().split('\n')[0].trim();
     } catch (_e) { /* fall through */ }
   }
@@ -654,14 +671,20 @@ function _rotateFile(filePath, maxBytes, keepLines) {
 
 let _telDirEnsured = false;
 
-function _writeTelemetry(hookName, duration_ms, ok) {
+function _writeTelemetry({ hookName, duration_ms, ok, extra }) {
   try {
     if (!_telDirEnsured) {
       fs.mkdirSync(GLOBAL_MINDLORE_DIR, { recursive: true });
       _telDirEnsured = true;
     }
     const telPath = path.join(GLOBAL_MINDLORE_DIR, 'telemetry.jsonl');
-    const line = JSON.stringify({ ts: new Date().toISOString(), hook: hookName, duration_ms, ok }) + '\n';
+    const entry = { ts: new Date().toISOString(), hook: hookName, duration_ms, ok };
+    if (extra && typeof extra === 'object') {
+      for (const key of ['inject_tokens', 'source_tokens', 'injected_tokens', 'full_read_tokens']) {
+        if (typeof extra[key] === 'number') entry[key] = extra[key];
+      }
+    }
+    const line = JSON.stringify(entry) + '\n';
     _rotateFile(telPath, HOOK_LOG_MAX_BYTES, TELEMETRY_KEEP_LINES);
     fs.appendFileSync(telPath, line);
   } catch { /* silent — telemetry must never crash hook */ }
@@ -678,7 +701,8 @@ async function withTelemetry(hookName, fn) {
     ok = false;
     thrown = err;
   }
-  _writeTelemetry(hookName, Date.now() - start, ok);
+  const extra = (result && typeof result === 'object') ? result : undefined;
+  _writeTelemetry({ hookName, duration_ms: Date.now() - start, ok, extra });
   if (thrown) throw thrown;
   return result;
 }
@@ -694,11 +718,28 @@ function withTelemetrySync(hookName, fn) {
     ok = false;
     thrown = err;
   }
-  _writeTelemetry(hookName, Date.now() - start, ok);
+  const extra = (result && typeof result === 'object') ? result : undefined;
+  _writeTelemetry({ hookName, duration_ms: Date.now() - start, ok, extra });
   if (thrown) throw thrown;
   return result;
 }
 
+function withTimeoutDb(db, sql, params = [], { timeoutMs = 3000, mode = 'all' } = {}) {
+  if (!db) return mode === 'get' ? undefined : [];
+  try {
+    db.pragma(`busy_timeout = ${timeoutMs}`);
+    const stmt = db.prepare(sql);
+    if (mode === 'get') {
+      return params.length > 0 ? stmt.get(...params) : stmt.get();
+    }
+    return params.length > 0 ? stmt.all(...params) : stmt.all();
+  } catch (err) {
+    hookLog('timeout', 'warn', `DB query timeout/error: ${err.message}`);
+    _writeTelemetry({ hookName: 'db_timeout', duration_ms: 0, ok: false });
+    return mode === 'get' ? undefined : [];
+  }
+}
+
 module.exports = {
   MINDLORE_DIR,
   GLOBAL_MINDLORE_DIR,
@@ -715,6 +756,11 @@ module.exports = {
   readHookStdin,
   SQL_FTS_CREATE,
   SQL_FTS_INSERT,
+  SQL_FTS_SESSIONS_CREATE,
+  SQL_FTS_SESSIONS_INSERT,
+  SESSION_CATEGORIES,
+  isSessionCategory,
+  fixVersionTokens,
   insertFtsRow,
   extractHeadings,
   requireDatabase,
@@ -763,6 +809,8 @@ module.exports = {
   // Telemetry (v0.6.0)
   withTelemetry,
   withTelemetrySync,
+  // DB timeout wrapper (v0.6.1)
+  withTimeoutDb,
 };
 
 function isDaemonRunning(pidFile) {

package/hooks/mindlore-fts5-sync.cjs

@@ -13,7 +13,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getActiveMindloreDir, getProjectName, resolveProject, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getActiveMindloreDir, getProjectName, resolveProject, hookLog, withTelemetry, SQL_FTS_SESSIONS_INSERT, isSessionCategory } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const filePath = readHookStdin(['path', 'file_path']);
@@ -39,6 +39,8 @@ function main() {
 
   const getHash = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?');
   const deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
+  const deleteFtsSessions = db.prepare('DELETE FROM mindlore_fts_sessions WHERE path = ?');
+  const insertFtsSessions = db.prepare(SQL_FTS_SESSIONS_INSERT);
   const upsertHash = db.prepare(`
     INSERT INTO file_hashes (path, content_hash, last_indexed)
     VALUES (?, ?, ?)
@@ -61,8 +63,14 @@ function main() {
 
         const { meta, body } = parseFrontmatter(content);
         const { slug, description, type, category, title, tags, quality, dateCaptured, project: ftsProject } = extractFtsMetadata(meta, body, file, baseDir);
+        const resolvedProject = resolveProject(ftsProject, file, project);
         deleteFts.run(file);
-        insertFtsRow(db, { path: file, slug, description, type, category, title, content: body, tags, quality, dateCaptured, project: resolveProject(ftsProject, file, project) });
+        deleteFtsSessions.run(file);
+        if (isSessionCategory(category)) {
+          insertFtsSessions.run(file, slug, description, type, category, title, body, tags, quality ?? null, dateCaptured ?? null, resolvedProject);
+        } else {
+          insertFtsRow(db, { path: file, slug, description, type, category, title, content: body, tags, quality, dateCaptured, project: resolvedProject });
+        }
         upsertHash.run(file, hash, now);
       }
     });
@@ -71,8 +79,6 @@ function main() {
     db.close();
   }
 
-  // FileChanged event stdout'u yutulur — log gerekiyorsa dosyaya yaz
-  // process.stdout.write kaldırıldı (kimse görmüyor)
 }
 
 withTelemetry('mindlore-fts5-sync', main).catch(err => {

package/hooks/mindlore-post-compact.cjs

@@ -14,7 +14,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, getLatestDelta, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, getLatestDelta, readConfig, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const baseDir = findMindloreDir();
@@ -29,8 +29,8 @@ function main() {
     output.push(`[Mindlore INDEX (post-compact)]\n${content}`);
   }
 
-  // Re-inject latest delta
   const diaryDir = path.join(baseDir, 'diary');
+
   const latestDelta = getLatestDelta(diaryDir);
   if (latestDelta) {
     const deltaContent = fs.readFileSync(latestDelta, 'utf8').trim();
@@ -38,8 +38,28 @@ function main() {
     output.push(`[Mindlore Delta (post-compact): ${deltaName}]\n${deltaContent}`);
   }
 
+  try {
+    const snapshots = fs.readdirSync(diaryDir)
+      .filter(f => f.startsWith('compaction-snapshot-'))
+      .sort();
+    if (snapshots.length > 0) {
+      const latestSnapshot = snapshots[snapshots.length - 1];
+      const snapshotContent = fs.readFileSync(
+        path.join(diaryDir, latestSnapshot), 'utf8'
+      ).trim();
+      output.push(`[Mindlore Compaction Resume]\n${snapshotContent}`);
+    }
+  } catch (_err) { /* snapshot best-effort */ }
+
   if (output.length > 0) {
-    process.stdout.write(output.join('\n\n') + '\n');
+    const config = readConfig(baseDir);
+    const budgetConfig = config?.tokenBudget ?? {};
+    const maxInjectChars = (budgetConfig.sessionInject || 2000) * 4;
+    let joined = output.join('\n\n');
+    if (joined.length > maxInjectChars) {
+      joined = joined.slice(0, maxInjectChars) + '\n[...truncated by token budget]';
+    }
+    process.stdout.write(joined + '\n');
   }
 }
 

package/hooks/mindlore-pre-compact.cjs

@@ -11,7 +11,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, openDatabase, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const baseDir = findMindloreDir();
@@ -25,6 +25,7 @@ function main() {
       spawnSync('node', [indexScript, baseDir], {
         timeout: 10000,
         stdio: 'pipe',
+        windowsHide: true,
       });
     } catch (_err) {
       // Non-fatal — index might fail if better-sqlite3 not available
@@ -33,11 +34,10 @@ function main() {
 
   const now = new Date();
   const iso = now.toISOString();
+  const ts = iso.replace(/[:.]/g, '-');
 
-  // Write pre-compact episode
   const episodesDir = path.join(baseDir, 'episodes');
   try {
-    const ts = iso.replace(/[:.]/g, '-');
     const episodePath = path.join(episodesDir, `pre-compact-${ts}.md`);
     const content = [
       '---',
@@ -60,6 +60,81 @@ function main() {
     fs.appendFileSync(logPath, entry, 'utf8');
   } catch (_err) { /* log file may not exist */ }
 
+  // Build compaction snapshot (#17)
+  const diaryDir = path.join(baseDir, 'diary');
+  try {
+    const sections = [];
+
+    try {
+      const dbPath = path.join(baseDir, 'mindlore.db');
+      const db = openDatabase(dbPath, { readonly: true });
+      if (db) {
+        try {
+          const episodes = db.prepare(
+            "SELECT kind, summary FROM episodes WHERE created_at > datetime('now', '-4 hours') ORDER BY created_at DESC LIMIT 20"
+          ).all();
+          if (episodes.length > 0) {
+            const grouped = {};
+            for (const ep of episodes) {
+              const kind = ep.kind || 'other';
+              if (!grouped[kind]) grouped[kind] = [];
+              grouped[kind].push(ep.summary);
+            }
+            sections.push('## Session Episodes');
+            for (const [kind, items] of Object.entries(grouped)) {
+              sections.push(`### ${kind}`);
+              for (const item of items) sections.push(`- ${item}`);
+            }
+          }
+        } finally {
+          db.close();
+        }
+      }
+    } catch (_err) { /* graceful skip */ }
+
+    try {
+      const { execSync } = require('child_process');
+      const diffStat = execSync('git diff --stat HEAD 2>/dev/null || echo ""', {
+        encoding: 'utf8', timeout: 2000, windowsHide: true,
+      }).trim();
+      if (diffStat) {
+        sections.push('## Changed Files (uncommitted)', '```', diffStat, '```');
+      }
+    } catch (_err) { /* no git */ }
+
+    try {
+      const plansDir = path.join(process.cwd(), '.claude', 'plans');
+      if (fs.existsSync(plansDir)) {
+        const plans = fs.readdirSync(plansDir).filter(f => f.endsWith('.md'));
+        if (plans.length > 0) {
+          const latestPlan = plans.sort().pop();
+          sections.push(`## Active Plan: ${latestPlan}`);
+        }
+      }
+    } catch (_err) { /* skip */ }
+
+    if (sections.length > 0) {
+      const snapshotContent = [
+        '---',
+        'type: compaction-snapshot',
+        `date: ${iso.slice(0, 10)}`,
+        `project: ${path.basename(process.cwd())}`,
+        '---',
+        '',
+        ...sections,
+      ].join('\n');
+      fs.writeFileSync(path.join(diaryDir, `compaction-snapshot-${ts}.md`), snapshotContent);
+    }
+
+    const snapshots = fs.readdirSync(diaryDir)
+      .filter(f => f.startsWith('compaction-snapshot-'))
+      .sort();
+    while (snapshots.length > 5) {
+      const oldest = snapshots.shift();
+      if (oldest) fs.unlinkSync(path.join(diaryDir, oldest));
+    }
+  } catch (_err) { /* snapshot is best-effort */ }
+
   process.stdout.write('[Mindlore: pre-compact FTS5 flush complete]\n');
 }
 

package/hooks/mindlore-search.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getAllDbs, openDatabase, extractHeadings, readHookStdin, extractKeywords, sanitizeKeyword, readConfig, loadSqliteVecCjs, hasVecTableCjs, hookLog, incrementRecallCount, getDaemonPortFile, withTelemetry } = require('./lib/mindlore-common.cjs');
+const { getAllDbs, openDatabase, extractHeadings, readHookStdin, extractKeywords, sanitizeKeyword, readConfig, loadSqliteVecCjs, hasVecTableCjs, hookLog, incrementRecallCount, getDaemonPortFile, withTelemetry, fixVersionTokens } = require('./lib/mindlore-common.cjs');
 
 const { execFileSync } = require('child_process');
 
@@ -33,7 +33,7 @@ function requestEmbeddingSync(query) {
     const clientScript = path.join(__dirname, '..', 'scripts', 'lib', 'daemon-client.js');
     if (!fs.existsSync(clientScript)) return null;
     const result = execFileSync(process.execPath, [clientScript, portFile, query, '300'], {
-      timeout: 500, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+      timeout: 500, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
     });
     const parsed = JSON.parse(result.trim());
     return parsed.type === 'embedding' ? parsed.embedding : null;
@@ -122,11 +122,21 @@ function searchDb(dbPath, keywords) {
     const sanitized = keywords.map(sanitizeKeyword).filter(Boolean);
     if (sanitized.length === 0) { db.close(); return results; }
 
-    const ftsQuery = sanitized.join(' OR ');
-    const rows = db.prepare(
+    const ftsQuery = fixVersionTokens(sanitized.join(' OR '));
+    const project = path.basename(process.cwd());
+
+    // v0.6.1: Project-scoped search with global fallback
+    let rows = db.prepare(
       `SELECT path, slug, description, category, title, tags, rank
-       FROM mindlore_fts WHERE mindlore_fts MATCH ? ORDER BY rank LIMIT ?`
-    ).all(ftsQuery, MAX_RESULTS * 2);
+       FROM mindlore_fts WHERE project = ? AND mindlore_fts MATCH ? ORDER BY rank LIMIT ?`
+    ).all(project, ftsQuery, MAX_RESULTS * 2);
+
+    if (rows.length === 0) {
+      rows = db.prepare(
+        `SELECT path, slug, description, category, title, tags, rank
+         FROM mindlore_fts WHERE mindlore_fts MATCH ? ORDER BY rank LIMIT ?`
+      ).all(ftsQuery, MAX_RESULTS * 2);
+    }
 
     for (const r of rows) {
       results.push({
@@ -237,17 +247,16 @@ function main() {
   let totalUsed = 0;
   for (const r of relevant) {
     if (totalUsed >= totalChars) break;
-    const meta = r.meta || {};
     const relativePath = path.relative(r.baseDir, r.path).replace(/\\/g, '/');
 
     const headings = r.headings || [];
 
-    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 category = r.category || path.dirname(relativePath).split('/')[0];
+    const title = r.title || r.slug || path.basename(r.path, '.md');
+    const description = r.description || '';
 
     const headingStr = headings.length > 0 ? `\nBasliklar: ${headings.join(', ')}` : '';
-    const tagsStr = meta.tags ? `\nTags: ${meta.tags}` : '';
+    const tagsStr = r.tags ? `\nTags: ${r.tags}` : '';
     const entry = `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${tagsStr}${headingStr}`;
     const truncated = entry.slice(0, perResultChars);
     totalUsed += truncated.length;

package/hooks/mindlore-session-end.cjs

@@ -54,6 +54,7 @@ if (process.argv.includes('--worker')) {
         execFileSync(nodeExe, [scriptPath, ...args], {
           timeout: timeoutMs,
           env: { ...process.env, MINDLORE_HOME: baseDir },
+          windowsHide: true,
         });
         hookLog('session-end', 'info', label + ' completed');
       } catch (err) {
@@ -112,6 +113,7 @@ function getRecentGitInfo() {
       encoding: 'utf8',
       timeout: 5000,
       stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
     }).trim();
     if (!raw) return { commits: [], changedFiles: [] };
 
@@ -219,6 +221,20 @@ function main() {
     fs.appendFileSync(logPath, logEntry, 'utf8');
   }
 
+  // Raw accumulation warning
+  try {
+    const rawDir = path.join(baseDir, 'raw');
+    const sourcesDir = path.join(baseDir, 'sources');
+    if (fs.existsSync(rawDir) && fs.existsSync(sourcesDir)) {
+      const rawFiles = fs.readdirSync(rawDir).filter(f => f.endsWith('.md'));
+      const sourceFiles = new Set(fs.readdirSync(sourcesDir).filter(f => f.endsWith('.md')));
+      const unpromoted = rawFiles.filter(f => !sourceFiles.has(f)).length;
+      if (unpromoted >= 5) {
+        process.stdout.write(`[Mindlore] ${unpromoted} raw dosya promote bekliyor — \`/mindlore-maintain triage\` ile listele\n`);
+      }
+    }
+  } catch (_err) { /* graceful skip */ }
+
   // Heavy ops: detach into child process so CC can exit immediately.
   // Fixes "Hook cancelled" when CC kills the hook before completion.
   // See: https://github.com/anthropics/claude-code/issues/41577
@@ -234,6 +250,7 @@ function main() {
       detached: true,
       stdio: 'ignore',
       cwd: process.cwd(),
+      windowsHide: true,
     });
     child.unref();
   } catch (_err) {
@@ -433,29 +450,25 @@ function syncObsidian(baseDir) {
     const destBase = path.join(vaultPath, 'mindlore');
     let exported = 0;
 
-    for (const dir of EXPORT_DIRS) {
-      const srcDir = path.join(baseDir, dir);
-      if (!fs.existsSync(srcDir)) continue;
-
-      const destDir = path.join(destBase, dir);
+    function walkAndExport(srcDir, destDir) {
+      if (!fs.existsSync(srcDir)) return;
       fs.mkdirSync(destDir, { recursive: true });
-
-      for (const file of fs.readdirSync(srcDir).filter(f => f.endsWith('.md') && !f.startsWith('_'))) {
-        if (exportMdFile(path.join(srcDir, file), path.join(destDir, file), convertFn)) exported++;
-      }
-
-      // One-level subdirectories (e.g. diary/mindlore/)
       for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-        if (!entry.isDirectory() || entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
-        const subSrc = path.join(srcDir, entry.name);
-        const subDest = path.join(destDir, entry.name);
-        fs.mkdirSync(subDest, { recursive: true });
-        for (const file of fs.readdirSync(subSrc).filter(f => f.endsWith('.md') && !f.startsWith('_'))) {
-          if (exportMdFile(path.join(subSrc, file), path.join(subDest, file), convertFn)) exported++;
+        if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+          walkAndExport(srcPath, destPath);
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          if (exportMdFile(srcPath, destPath, convertFn)) exported++;
         }
       }
     }
 
+    for (const dir of EXPORT_DIRS) {
+      walkAndExport(path.join(baseDir, dir), path.join(destBase, dir));
+    }
+
     for (const rootFile of ['INDEX.md', 'log.md']) {
       const srcPath = path.join(baseDir, rootFile);
       if (!fs.existsSync(srcPath)) continue;
@@ -490,7 +503,7 @@ function syncGlobalRepo() {
   if (!fs.existsSync(gitDir)) return;
 
   const git = resolveGitBin();
-  const execOpts = (timeout) => ({ cwd: gDir, encoding: 'utf8', timeout, stdio: 'pipe' });
+  const execOpts = (timeout) => ({ cwd: gDir, encoding: 'utf8', timeout, stdio: 'pipe', windowsHide: true });
 
   // Check for changes
   const status = execSync(`"${git}" status --porcelain`, execOpts(5000)).trim();
@@ -502,7 +515,7 @@ function syncGlobalRepo() {
 
   // Push — graceful fail if no remote or offline
   try {
-    execSync(`"${git}" push`, execOpts(15000));
+    execSync(`"${git}" push`, execOpts(30000));
   } catch (_pushErr) {
     hookLog('session-end', 'warn', 'git push failed (offline?): ' + (_pushErr?.message ?? '').slice(0, 100));
   }