mindlore 0.2.0 → 0.3.0

package/hooks/mindlore-dont-repeat.cjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-dont-repeat — PreToolUse hook (matcher: "Write|Edit")
+ *
+ * Checks code being written against negative rules (DON'T, NEVER, AVOID, YAPMA, etc.)
+ * found in LESSONS files and Mindlore learnings/.
+ *
+ * Sources checked (in order):
+ *   1. ~/.claude/lessons/global.md (global rules)
+ *   2. ./LESSONS.md (project-level rules, if exists)
+ *   3. .mindlore/learnings/*.md (Mindlore learnings, if exists)
+ *
+ * Advisory only (exit 0) — does not block, injects additionalContext warning.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+
+/**
+ * File-persisted pattern cache — survives across process invocations.
+ * Cache file: .mindlore/diary/_pattern-cache.json
+ * Each entry keyed by source file path, stores mtimeMs + extracted patterns.
+ * On hit: stat only, no readFile+parse. On miss: read, parse, update cache.
+ */
+
+let cacheDirty = false;
+
+function readCache(cachePath) {
+  if (!cachePath) return {};
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch (_err) {
+    return {};
+  }
+}
+
+function writeCache(cachePath, cache) {
+  if (!cachePath || !cacheDirty) return;
+  try {
+    fs.writeFileSync(cachePath, JSON.stringify(cache), 'utf8');
+  } catch (_err) { /* write failure is non-fatal */ }
+}
+
+function loadPatterns(filePath, cache) {
+  try {
+    const stat = fs.statSync(filePath);
+    const mtimeMs = stat.mtimeMs;
+    const cached = cache[filePath];
+    if (cached && cached.mtimeMs === mtimeMs) return cached.patterns;
+
+    const patterns = extractNegativePatterns(fs.readFileSync(filePath, 'utf8'));
+    cache[filePath] = { mtimeMs, patterns };
+    cacheDirty = true;
+    return patterns;
+  } catch (_err) {
+    return [];
+  }
+}
+
+function extractNegativePatterns(content) {
+  const patterns = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Multi-language: TR (YAPMA, KRITIK) + EN (DON'T, NEVER, AVOID, DO NOT)
+    const isNegativeRule = /^-\s*(YAPMA|KRITIK|DON'?T|NEVER|AVOID|DO NOT):/i.test(trimmed);
+    if (!isNegativeRule) continue;
+
+    // Extract backtick-quoted code patterns: `pattern`
+    const backtickMatches = trimmed.match(/`([^`]+)`/g);
+    if (backtickMatches) {
+      for (const match of backtickMatches) {
+        const pattern = match.slice(1, -1).trim();
+        // Skip short/generic patterns — too many false positives
+        if (pattern.length < 8) continue;
+        if (/^[^a-zA-Z0-9]+$/.test(pattern)) continue;
+        // Skip single words (too generic: "node", "bash", "any")
+        if (/^\w+$/.test(pattern) && pattern.length < 12) continue;
+        // Skip file extensions and paths
+        if (/^\.\w{1,5}$/.test(pattern)) continue;
+        if (pattern.startsWith('/') || pattern.startsWith('~')) continue;
+        if (pattern.includes('.md') || pattern.includes('.json')) continue;
+        // Skip common false-positive patterns
+        if (/^(node|bash|npm|git|process|require|import|export|const|let|var)$/i.test(pattern)) continue;
+
+        patterns.push({
+          pattern,
+          rule: trimmed.substring(0, 120),
+        });
+      }
+    }
+
+    // Extract "quoted strings" as patterns
+    const quoteMatches = trimmed.match(/"([^"]+)"/g);
+    if (quoteMatches) {
+      for (const match of quoteMatches) {
+        const quoted = match.slice(1, -1).trim();
+        if (quoted.length < 4) continue;
+        patterns.push({
+          pattern: quoted,
+          rule: trimmed.substring(0, 120),
+        });
+      }
+    }
+  }
+
+  return patterns;
+}
+
+function checkContent(content, patterns) {
+  const matches = [];
+  for (const p of patterns) {
+    try {
+      const escaped = p.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const regex = new RegExp(escaped, 'i');
+      if (regex.test(content)) {
+        matches.push(p);
+      }
+    } catch { /* skip invalid patterns */ }
+  }
+  return matches;
+}
+
+function main() {
+  let input = '';
+  const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('error', () => process.exit(0));
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    clearTimeout(stdinTimeout);
+    try {
+      const data = JSON.parse(input || '{}');
+      const toolName = data.tool_name || '';
+
+      if (!['Write', 'Edit'].includes(toolName)) {
+        return process.exit(0);
+      }
+
+      const toolInput = data.tool_input || {};
+      const filePath = toolInput.file_path || '';
+
+      // Skip non-code files
+      if (!filePath) return process.exit(0);
+      const ext = path.extname(filePath).toLowerCase();
+      const codeExts = ['.ts', '.tsx', '.js', '.jsx', '.cjs', '.mjs', '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '.sh', '.yaml', '.yml'];
+      if (!codeExts.includes(ext)) return process.exit(0);
+
+      // Skip rule files themselves
+      const basename = path.basename(filePath);
+      if (basename === 'LESSONS.md' || basename === 'global.md' || basename === 'CLAUDE.md') {
+        return process.exit(0);
+      }
+
+      // Collect content being written (skip old_string — that's code being removed, not added)
+      const allContent = [
+        toolInput.content || '',
+        toolInput.new_string || '',
+      ].join('\n');
+
+      if (allContent.trim().length < 10) return process.exit(0);
+
+      // Load patterns from all sources (file-persisted mtime cache)
+      const mindloreDir = findMindloreDir();
+      const cachePath = mindloreDir ? path.join(mindloreDir, 'diary', '_pattern-cache.json') : null;
+      const cache = readCache(cachePath);
+      const allPatterns = [];
+      const cwd = process.cwd();
+
+      // 1. Global lessons
+      allPatterns.push(...loadPatterns(path.join(os.homedir(), '.claude', 'lessons', 'global.md'), cache));
+
+      // 2. Project LESSONS.md
+      allPatterns.push(...loadPatterns(path.join(cwd, 'LESSONS.md'), cache));
+
+      // 3. Mindlore learnings/ directory
+      if (mindloreDir) {
+        const learningsDir = path.join(mindloreDir, 'learnings');
+        try {
+          const files = fs.readdirSync(learningsDir).filter(f => f.endsWith('.md'));
+          for (const file of files) {
+            allPatterns.push(...loadPatterns(path.join(learningsDir, file), cache));
+          }
+        } catch (_err) { /* learnings/ doesn't exist yet */ }
+      }
+
+      writeCache(cachePath, cache);
+
+      if (allPatterns.length === 0) return process.exit(0);
+
+      // Check content against patterns
+      const matches = checkContent(allContent, allPatterns);
+      if (matches.length === 0) return process.exit(0);
+
+      // Build warning — max 3 matches shown
+      const shown = matches.slice(0, 3);
+      const warning = shown.map(m =>
+        `  - Pattern: \`${m.pattern}\` → ${m.rule}`
+      ).join('\n');
+      const extra = matches.length > 3 ? `\n  ... and ${matches.length - 3} more` : '';
+
+      const msg = `[Mindlore: ${matches.length} dont-repeat rule violation detected]\n${warning}${extra}`;
+
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          additionalContext: msg
+        }
+      }));
+    } catch {
+      // Silent fail
+    }
+    process.exit(0);
+  });
+}
+
+main();

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, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const filePath = readHookStdin(['path', 'file_path']);
@@ -35,11 +35,10 @@ function main() {
   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(SQL_FTS_INSERT);
   const upsertHash = db.prepare(`
     INSERT INTO file_hashes (path, content_hash, last_indexed)
     VALUES (?, ?, ?)
@@ -60,11 +59,10 @@ function main() {
         if (existing && existing.content_hash === hash) continue;
 
         const { meta, body } = parseFrontmatter(content);
-        const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, file, baseDir);
+        const { slug, description, type, category, title, tags, quality, dateCaptured } = extractFtsMetadata(meta, body, file, baseDir);
         deleteFts.run(file);
-        insertFts.run(file, slug, description, type, category, title, body, tags, quality);
+        insertFtsRow(db, { path: file, slug, description, type, category, title, content: body, tags, quality, dateCaptured });
         upsertHash.run(file, hash, now);
-        synced++;
       }
     });
     transaction();
@@ -72,9 +70,8 @@ function main() {
     db.close();
   }
 
-  if (synced > 0) {
-    process.stdout.write(`[Mindlore FTS5 Sync: ${synced} files re-indexed]\n`);
-  }
+  // FileChanged event stdout'u yutulur — log gerekiyorsa dosyaya yaz
+  // process.stdout.write kaldırıldı (kimse görmüyor)
 }
 
 main();

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, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const filePath = readHookStdin(['path', 'file_path']);
@@ -58,11 +58,11 @@ function main() {
 
     // Parse frontmatter for rich FTS5 columns
     const { meta, body } = parseFrontmatter(content);
-    const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, filePath, baseDir);
+    const { slug, description, type, category, title, tags, quality, dateCaptured } = 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, tags, quality);
+    insertFtsRow(db, { path: filePath, slug, description, type, category, title, content: body, tags, quality, dateCaptured });
 
     // Update hash
     db.prepare(

package/hooks/mindlore-post-read.cjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-post-read — PostToolUse hook (matcher: "Read")
+ *
+ * After a file is read, estimate its token count
+ * and store in _session-reads.json for the read-guard to reference.
+ *
+ * Does NOT output anything (pure bookkeeping).
+ * PostToolUse stdout goes to debug log only — no inject needed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+
+const CODE_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go', '.java', '.c', '.cpp', '.h', '.css', '.scss', '.sql', '.sh', '.yaml', '.yml', '.json', '.toml', '.xml', '.cjs', '.mjs']);
+const PROSE_EXTS = new Set(['.md', '.txt', '.rst', '.adoc']);
+
+function estimateTokens(charCount, ext) {
+  const ratio = CODE_EXTS.has(ext) ? 3.5 : PROSE_EXTS.has(ext) ? 4.0 : 3.75;
+  return Math.ceil(charCount / ratio);
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  let input = '';
+  const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('error', () => process.exit(0));
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    clearTimeout(stdinTimeout);
+    try {
+      const data = JSON.parse(input || '{}');
+      const toolInput = data.tool_input || {};
+      const toolOutput = data.tool_output || {};
+
+      const filePath = toolInput.file_path || toolInput.path || '';
+      if (!filePath) return process.exit(0);
+
+      // Skip .mindlore/ internals
+      const resolved = path.resolve(filePath);
+      if (resolved.startsWith(path.resolve(baseDir))) return process.exit(0);
+
+      // Get content length from tool output or read file
+      let charCount = 0;
+      if (toolOutput.content) {
+        charCount = typeof toolOutput.content === 'string'
+          ? toolOutput.content.length
+          : JSON.stringify(toolOutput.content).length;
+      } else {
+        // Fallback: read file size
+        try {
+          const stat = fs.statSync(resolved);
+          charCount = stat.size;
+        } catch { return process.exit(0); }
+      }
+
+      if (charCount === 0) return process.exit(0);
+
+      const ext = path.extname(filePath).toLowerCase();
+      const tokens = estimateTokens(charCount, ext);
+
+      // Update _session-reads.json with token info
+      const diaryDir = path.join(baseDir, 'diary');
+      const readsPath = path.join(diaryDir, '_session-reads.json');
+      let reads = {};
+      if (fs.existsSync(readsPath)) {
+        try { reads = JSON.parse(fs.readFileSync(readsPath, 'utf8')); } catch { reads = {}; }
+      }
+
+      const normalizedPath = path.resolve(filePath);
+      const key = normalizedPath;
+
+      if (typeof reads[key] === 'number') {
+        // Upgrade from old format (just count) to new format (object)
+        reads[key] = { count: reads[key], tokens, chars: charCount };
+      } else if (reads[key] && typeof reads[key] === 'object') {
+        reads[key].tokens = tokens;
+        reads[key].chars = charCount;
+      } else {
+        reads[key] = { count: 1, tokens, chars: charCount };
+      }
+
+      fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
+    } catch {
+      // Silent fail
+    }
+    process.exit(0);
+  });
+}
+
+main();

package/hooks/mindlore-read-guard.cjs

@@ -4,7 +4,7 @@
 /**
  * mindlore-read-guard — PreToolUse hook (if: "Read")
  *
- * OpenWolf repeated-read pattern: detects files read multiple times
+ * Repeated-read detection: detects files read multiple times
  * in the same session and emits a soft warning.
  * Does NOT block (exit 0) — advisory only.
  *
@@ -46,8 +46,24 @@ function main() {
   }
 
   const normalizedPath = path.resolve(filePath);
-  const count = (reads[normalizedPath] || 0) + 1;
-  reads[normalizedPath] = count;
+  const existing = reads[normalizedPath];
+
+  // Support both old format (number) and new format (object with tokens)
+  let count, tokens;
+  if (typeof existing === 'number') {
+    count = existing + 1;
+    tokens = 0;
+    reads[normalizedPath] = { count, tokens: 0, chars: 0 };
+  } else if (existing && typeof existing === 'object') {
+    count = (existing.count || 0) + 1;
+    tokens = existing.tokens || 0;
+    existing.count = count;
+    reads[normalizedPath] = existing;
+  } else {
+    count = 1;
+    tokens = 0;
+    reads[normalizedPath] = { count, tokens: 0, chars: 0 };
+  }
 
   // Write updated reads
   fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
@@ -55,7 +71,14 @@ function main() {
   // 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`);
+    const tokenInfo = tokens > 0 ? ` (~${tokens} token)` : '';
+    const totalWaste = tokens > 0 ? ` Toplam tekrar: ~${tokens * (count - 1)} token.` : '';
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: `[Mindlore: ${basename}${tokenInfo} bu session'da ${count}. kez okunuyor.${totalWaste} Değişiklik yoksa tekrar okumayı atlayabilirsin.]`
+      }
+    }));
   }
 }
 

package/hooks/mindlore-search.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, DB_NAME, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { getAllDbs, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 const MAX_RESULTS = 3;
 const MIN_QUERY_WORDS = 3;
@@ -59,30 +59,20 @@ function extractKeywords(text) {
   return [...new Set(words)].slice(0, 8);
 }
 
-function main() {
-  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
-  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
-
-  const baseDir = findMindloreDir();
-  if (!baseDir) return;
-
-  const dbPath = path.join(baseDir, DB_NAME);
-  if (!fs.existsSync(dbPath)) return;
-
-  const keywords = extractKeywords(userMessage);
-  if (keywords.length < MIN_QUERY_WORDS) return;
-
-  const Database = requireDatabase();
-  if (!Database) return;
-
+/**
+ * Search a single DB and return scored results with their baseDir.
+ */
+function searchDb(dbPath, keywords, Database) {
+  const baseDir = path.dirname(dbPath);
   const db = new Database(dbPath, { readonly: true });
+  const results = [];
 
   try {
-    // 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 ?');
+    const metaStmt = db.prepare(
+      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
+    );
 
     for (const row of allPaths) {
       let hits = 0;
@@ -101,50 +91,81 @@ function main() {
       }
 
       if (hits >= MIN_KEYWORD_HITS) {
-        scores.push({ path: row.path, hits, totalRank });
+        const meta = metaStmt.get(row.path) || {};
+        results.push({ path: row.path, hits, totalRank, baseDir, meta });
       }
     }
+  } catch (_err) {
+    // FTS5 query error — silently skip
+  } finally {
+    db.close();
+  }
 
-    // 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);
+  return results;
+}
 
-    if (relevant.length === 0) return;
+function main() {
+  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
+  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
 
-    // Build rich inject output
-    const metaStmt = db.prepare(
-      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
-    );
+  const dbPaths = getAllDbs();
+  if (dbPaths.length === 0) return;
 
-    const output = [];
-    for (const r of relevant) {
-      const meta = metaStmt.get(r.path) || {};
-      const relativePath = path.relative(baseDir, r.path).replace(/\\/g, '/');
+  const keywords = extractKeywords(userMessage);
+  if (keywords.length < MIN_QUERY_WORDS) return;
 
-      let headings = [];
-      if (fs.existsSync(r.path)) {
-        const content = fs.readFileSync(r.path, 'utf8');
-        headings = extractHeadings(content, 5);
-      }
+  const Database = requireDatabase();
+  if (!Database) return;
 
-      const category = meta.category || path.dirname(relativePath).split('/')[0];
-      const title = meta.title || meta.slug || path.basename(r.path, '.md');
-      const description = meta.description || '';
+  // Layered search: project DB first, global DB second
+  // Project results appear first in output (higher priority)
+  const allScores = [];
+  for (const dbPath of dbPaths) {
+    allScores.push(...searchDb(dbPath, keywords, Database));
+  }
 
-      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}`
-      );
+  // Sort: most keyword hits first, then best rank
+  allScores.sort((a, b) => b.hits - a.hits || a.totalRank - b.totalRank);
+
+  // Deduplicate by full path (project version wins — appears first in sort)
+  const seen = new Set();
+  const unique = [];
+  for (const r of allScores) {
+    const normalized = path.resolve(r.path);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      unique.push(r);
     }
+  }
 
-    if (output.length > 0) {
-      process.stdout.write(output.join('\n\n') + '\n');
+  const relevant = unique.slice(0, MAX_RESULTS);
+  if (relevant.length === 0) return;
+
+  // Build rich inject output
+  const output = [];
+  for (const r of relevant) {
+    const meta = r.meta || {};
+    const relativePath = path.relative(r.baseDir, r.path).replace(/\\/g, '/');
+
+    let headings = [];
+    if (fs.existsSync(r.path)) {
+      const content = fs.readFileSync(r.path, 'utf8');
+      headings = extractHeadings(content, 5);
     }
-  } catch (_err) {
-    // FTS5 query error — silently skip
-  } finally {
-    db.close();
+
+    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.stdout.write(output.join('\n\n') + '\n');
   }
 }
 

package/hooks/mindlore-session-end.cjs

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, globalDir } = require('./lib/mindlore-common.cjs');
 
 function formatDate(date) {
   const y = date.getFullYear();
@@ -129,6 +129,48 @@ function main() {
     const logEntry = `| ${now.toISOString().slice(0, 10)} | session-end | delta-${dateStr}.md |\n`;
     fs.appendFileSync(logPath, logEntry, 'utf8');
   }
+
+  // Git auto-commit + push for global ~/.mindlore/ only
+  syncGlobalRepo();
+}
+
+/**
+ * Auto-commit and push ~/.mindlore/ if it has a .git directory.
+ * Only runs for the global scope — project .mindlore/ is in the project's own git.
+ * Push failure is graceful (offline support).
+ */
+function syncGlobalRepo() {
+  const gDir = globalDir();
+  const gitDir = path.join(gDir, '.git');
+  if (!fs.existsSync(gitDir)) return;
+
+  try {
+    // Check for changes
+    const status = execSync('git status --porcelain', {
+      cwd: gDir,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+
+    if (!status) return; // nothing to commit
+
+    execSync('git add -A', { cwd: gDir, timeout: 5000, stdio: 'pipe' });
+    const now = new Date().toISOString().slice(0, 19);
+    execSync(`git commit -m "mindlore auto-sync ${now}"`, {
+      cwd: gDir,
+      timeout: 10000,
+      stdio: 'pipe',
+    });
+
+    // Push — graceful fail if no remote or offline
+    try {
+      execSync('git push', { cwd: gDir, timeout: 15000, stdio: 'pipe' });
+    } catch (_pushErr) {
+      // Offline or no remote — silently continue
+    }
+  } catch (_err) {
+    // Git not available or commit failed — silently continue
+  }
 }
 
 main();