mindlore 0.7.0 → 0.7.1

package/hooks/mindlore-fts5-sync.cjs

@@ -1,49 +1,29 @@
 #!/usr/bin/env node
-'use strict';
-
-/**
- * mindlore-fts5-sync — FileChanged hook (incremental re-index)
- *
- * Handles bulk file changes by checking all .mindlore/ .md files
- * against their content hashes and re-indexing only changed ones.
- *
- * Lightweight complement to mindlore-index.cjs which handles single files.
- * This hook catches cases where multiple files change at once (e.g., git pull).
- */
-
-const fs = require('fs');
-const path = require('path');
-const { DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getActiveMindloreDir, getProjectName, resolveProject, hookLog, withTelemetry, SQL_FTS_SESSIONS_INSERT, isSessionCategory, isInsideMindloreDir } = require('./lib/mindlore-common.cjs');
+"use strict";
 
+// hooks/src/mindlore-fts5-sync.cjs
+var fs = require("fs");
+var path = require("path");
+var { DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getActiveMindloreDir, getProjectName, resolveProject, hookLog, withTelemetry, SQL_FTS_SESSIONS_INSERT, isSessionCategory, isInsideMindloreDir } = require("./lib/mindlore-common.cjs");
 function main() {
-  const filePath = readHookStdin(['path', 'file_path']);
-
+  const filePath = readHookStdin(["path", "file_path"]);
   if (!filePath) return;
   const resolved = path.resolve(filePath);
   if (!isInsideMindloreDir(resolved)) 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;
-
+  if (filePath.endsWith(".md")) return;
   const baseDir = getActiveMindloreDir();
   if (!fs.existsSync(baseDir)) return;
-
   const dbPath = path.join(baseDir, DB_NAME);
   if (!fs.existsSync(dbPath)) return;
-
   const db = openDatabase(dbPath);
   if (!db) return;
-
   const mdFiles = getAllMdFiles(baseDir);
-
-  const allHashes = new Map();
-  for (const row of db.prepare('SELECT path, content_hash FROM file_hashes').all()) {
+  const allHashes = /* @__PURE__ */ new Map();
+  for (const row of db.prepare("SELECT path, content_hash FROM file_hashes").all()) {
     allHashes.set(row.path, row.content_hash);
   }
-
-  const deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
-  const deleteFtsSessions = db.prepare('DELETE FROM mindlore_fts_sessions 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)
@@ -52,27 +32,20 @@ function main() {
       content_hash = excluded.content_hash,
       last_indexed = excluded.last_indexed
   `);
-
-  const now = new Date().toISOString();
-
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const project = getProjectName();
-
     const changedFiles = [];
     for (const file of mdFiles) {
-      const content = fs.readFileSync(file, 'utf8').replace(/\r\n/g, '\n');
+      const content = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
       const hash = sha256(content);
-
       const existingHash = allHashes.get(file);
       if (existingHash === hash) continue;
-
       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);
       changedFiles.push({ file, hash, slug, description, type, category, title, tags, quality, dateCaptured, resolvedProject, body });
     }
-
-    // No file I/O inside — minimize lock hold time
     const transaction = db.transaction(() => {
       for (const item of changedFiles) {
         deleteFts.run(item.file);
@@ -89,10 +62,8 @@ function main() {
   } finally {
     db.close();
   }
-
 }
-
-withTelemetry('mindlore-fts5-sync', main).catch(err => {
-  hookLog('mindlore-fts5-sync', 'error', err?.message ?? String(err));
+withTelemetry("mindlore-fts5-sync", main).catch((err) => {
+  hookLog("mindlore-fts5-sync", "error", err?.message ?? String(err));
   process.exit(0);
 });

package/hooks/mindlore-index.cjs

@@ -1,92 +1,117 @@
 #!/usr/bin/env node
-'use strict';
-
-/**
- * mindlore-index — FileChanged hook
- *
- * When a .md file in .mindlore/ changes, update its FTS5 entry.
- * Reads changed file path from stdin (CC FileChanged event).
- */
-
-const fs = require('fs');
-const path = require('path');
-const { safeMkdir, safeWriteFile } = require('../dist/scripts/lib/secure-io.js');
-const { DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getProjectName, resolveProject, globalDir, hookLog, withTelemetry, isInsideMindloreDir, extractMindloreBaseDir } = require('./lib/mindlore-common.cjs');
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// dist/scripts/lib/privacy-filter.js
+var require_privacy_filter = __commonJS({
+  "dist/scripts/lib/privacy-filter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_PATTERNS = void 0;
+    exports2.redactSecrets = redactSecrets;
+    var REPLACEMENT = "[REDACTED]";
+    var PATTERN_PREFIXES = [
+      { prefix: "sk-", pattern: /sk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}/g },
+      { prefix: "AKIA", pattern: /AKIA[0-9A-Z]{16}/g },
+      { prefix: "ghp_", pattern: /ghp_[A-Za-z0-9]{36,}/g },
+      { prefix: "gho_", pattern: /gho_[A-Za-z0-9]{36,}/g },
+      { prefix: "github_pat_", pattern: /github_pat_[A-Za-z0-9_]{22,}/g },
+      { prefix: "npm_", pattern: /npm_[A-Za-z0-9]{36,}/g },
+      { prefix: "xox", pattern: /xox[bporas]-[A-Za-z0-9-]{10,}/g },
+      { prefix: "eyJ", pattern: /eyJ[a-zA-Z0-9_\-]{20,}\.[a-zA-Z0-9_\-]{20,}\.[a-zA-Z0-9_\-]{20,}/g },
+      { prefix: "AIza", pattern: /AIza[0-9A-Za-z_\-]{30,}/g },
+      { prefix: "sk_live_", pattern: /sk_live_[a-zA-Z0-9]{20,}/g },
+      { prefix: "pk_live_", pattern: /pk_live_[a-zA-Z0-9]{20,}/g },
+      { prefix: "Bearer", pattern: /Bearer\s+[a-zA-Z0-9\-._~+/]+=*/g },
+      { prefix: "-----BEGIN", pattern: /-----BEGIN\s(?:RSA\s|EC\s|DSA\s|OPENSSH\s)?PRIVATE\sKEY-----/g },
+      { prefix: "Basic", pattern: /Basic\s+[a-zA-Z0-9+\/]{16,}={0,2}/g },
+      { prefix: "-----BEGIN CERTIFICATE", pattern: /-----BEGIN\sCERTIFICATE-----/g }
+    ];
+    var NO_PREFIX_PATTERNS = [
+      /(?:postgres|mysql|mongodb|redis|amqp)(?:\+srv)?:\/\/[^\s"']+/g,
+      /(?:PASSWORD|SECRET|TOKEN|API_KEY|PRIVATE_KEY|DATABASE_URL|DB_PASSWORD|AUTH_TOKEN|ACCESS_KEY|SECRET_KEY)=\S+/gi,
+      /(?:api_key|auth_token|access_token|refresh_token|client_secret|private_key|secret_key)\s*[:=]\s*["']?[^\s"',}{]{8,}["']?/gi
+    ];
+    exports2.DEFAULT_PATTERNS = [
+      ...PATTERN_PREFIXES.map((p) => p.pattern),
+      ...NO_PREFIX_PATTERNS
+    ];
+    function redactSecrets(text, extraPatterns) {
+      let result = text;
+      for (const { prefix, pattern } of PATTERN_PREFIXES) {
+        if (result.includes(prefix)) {
+          pattern.lastIndex = 0;
+          result = result.replace(pattern, REPLACEMENT);
+        }
+      }
+      const remaining = extraPatterns ? [...NO_PREFIX_PATTERNS, ...extraPatterns] : NO_PREFIX_PATTERNS;
+      for (const pattern of remaining) {
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, REPLACEMENT);
+      }
+      return result;
+    }
+  }
+});
 
+// hooks/src/mindlore-index.cjs
+var fs = require("fs");
+var path = require("path");
+var { safeMkdir, safeWriteFile } = require("./lib/secure-io.cjs");
+var { DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getProjectName, resolveProject, globalDir, hookLog, withTelemetry, isInsideMindloreDir, extractMindloreBaseDir } = require("./lib/mindlore-common.cjs");
 function invalidateSearchCache(db) {
-  try { db.exec('DELETE FROM search_cache'); } catch (_) { /* table may not exist */ }
+  try {
+    db.exec("DELETE FROM search_cache");
+  } catch (_) {
+  }
 }
-
 function main() {
-  const filePath = readHookStdin(['path', 'file_path']);
+  const filePath = readHookStdin(["path", "file_path"]);
   if (!filePath) return;
-
-  // Only process .md files inside .mindlore/ (resolved path check prevents traversal)
-  if (!filePath.endsWith('.md')) return;
+  if (!filePath.endsWith(".md")) return;
   const resolvedFile = path.resolve(filePath);
   if (!isInsideMindloreDir(resolvedFile)) {
-    // CC memory path (~/.claude/projects/*/memory/*.md) — index to global mindlore DB
-    const isCcMemory = resolvedFile.includes(path.sep + '.claude' + path.sep + 'projects' + path.sep)
-      && resolvedFile.includes(path.sep + 'memory' + path.sep)
-      && resolvedFile.endsWith('.md');
+    const isCcMemory = resolvedFile.includes(path.sep + ".claude" + path.sep + "projects" + path.sep) && resolvedFile.includes(path.sep + "memory" + path.sep) && resolvedFile.endsWith(".md");
     if (!isCcMemory) return;
-
-    // CC memory path — index to global mindlore DB
     indexCcMemory(resolvedFile);
     return;
   }
-
   const fileName = path.basename(filePath);
-
   const baseDir = extractMindloreBaseDir(resolvedFile);
   if (!baseDir) return;
   const dbPath = path.join(baseDir, DB_NAME);
-
   if (!fs.existsSync(dbPath)) return;
-
-  // Catch-up scan: when INDEX.md or log.md triggers, index recently-modified files
-  if (['INDEX.md', 'log.md'].includes(fileName)) {
+  if (["INDEX.md", "log.md"].includes(fileName)) {
     catchUpScan(baseDir, dbPath);
     return;
   }
-
   if (SKIP_FILES.has(fileName)) return;
-
   if (!fs.existsSync(filePath)) {
-    // File was deleted — remove from index
-    const db = openDatabase(dbPath);
-    if (!db) return;
+    const db2 = openDatabase(dbPath);
+    if (!db2) return;
     try {
-      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
-      db.prepare('DELETE FROM file_hashes WHERE path = ?').run(filePath);
-      invalidateSearchCache(db);
+      db2.prepare("DELETE FROM mindlore_fts WHERE path = ?").run(filePath);
+      db2.prepare("DELETE FROM file_hashes WHERE path = ?").run(filePath);
+      invalidateSearchCache(db2);
     } finally {
-      db.close();
+      db2.close();
     }
     return;
   }
-
-  const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  const content = fs.readFileSync(filePath, "utf8").replace(/\r\n/g, "\n");
   const hash = sha256(content);
-
   const db = openDatabase(dbPath);
   if (!db) return;
-
   try {
-    // Check if content changed
-    const existing = db
-      .prepare('SELECT content_hash FROM file_hashes WHERE path = ?')
-      .get(filePath);
-
-    if (existing && existing.content_hash === hash) return; // Unchanged
-
-    // Parse frontmatter for rich FTS5 columns
+    const existing = db.prepare("SELECT content_hash FROM file_hashes WHERE path = ?").get(filePath);
+    if (existing && existing.content_hash === hash) return;
     const { meta, body } = parseFrontmatter(content);
     const { slug, description, type, category, title, tags, quality, dateCaptured, project: ftsProject } = extractFtsMetadata(meta, body, filePath, baseDir);
-
-    // Update FTS5 + hash atomically
     const updateIndex = db.transaction(() => {
-      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+      db.prepare("DELETE FROM mindlore_fts WHERE path = ?").run(filePath);
       insertFtsRow(db, { path: filePath, slug, description, type, category, title, content: body, tags, quality, dateCaptured, project: resolveProject(ftsProject, filePath, getProjectName()) });
       db.prepare(
         `INSERT INTO file_hashes (path, content_hash, last_indexed)
@@ -94,7 +119,7 @@ function main() {
          ON CONFLICT(path) DO UPDATE SET
            content_hash = excluded.content_hash,
            last_indexed = excluded.last_indexed`
-      ).run(filePath, hash, new Date().toISOString());
+      ).run(filePath, hash, (/* @__PURE__ */ new Date()).toISOString());
     });
     updateIndex();
     invalidateSearchCache(db);
@@ -102,54 +127,39 @@ function main() {
     db.close();
   }
 }
-
 function indexCcMemory(filePath) {
-  const CC_MEMORY_CATEGORY = 'cc-memory';
-  // CC memory constants live in TS (scripts/lib/constants.ts) — CJS hooks can't require TS directly
+  const CC_MEMORY_CATEGORY = "cc-memory";
   const globalBase = globalDir();
   const dbPath = path.join(globalBase, DB_NAME);
-
-  const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  const content = fs.readFileSync(filePath, "utf8").replace(/\r\n/g, "\n");
   if (!content.trim()) return;
-
-  // Privacy filter — redact secrets before DB write
   let cleaned = content;
   try {
-    const { redactSecrets } = require('../dist/scripts/lib/privacy-filter.js');
+    const { redactSecrets } = require_privacy_filter();
     cleaned = redactSecrets(content);
   } catch (_err) {
-    // privacy-filter not built — use raw content
   }
-
-  // SHA256 dedup
   const hash = sha256(cleaned);
   const db = openDatabase(dbPath);
   if (!db) return;
-
   try {
-    const existing = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?').get(filePath);
+    const existing = db.prepare("SELECT content_hash FROM file_hashes WHERE path = ?").get(filePath);
     if (existing && existing.content_hash === hash) {
-      return; // unchanged — finally handles db.close()
+      return;
     }
-
     const { meta, body } = parseFrontmatter(cleaned);
-    const memType = String(meta.type || 'unknown');
-
-    // Extract project scope from path: ~/.claude/projects/C--Users-X-proj/memory/
+    const memType = String(meta.type || "unknown");
     const projMatch = filePath.match(/projects[/\\]([^/\\]+)[/\\]memory/);
     const projectScope = projMatch ? projMatch[1] : null;
-
     const ftsData = extractFtsMetadata(meta, body, filePath, globalBase);
-
-    // Update FTS5 + hash atomically
     const updateIndex = db.transaction(() => {
-      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+      db.prepare("DELETE FROM mindlore_fts WHERE path = ?").run(filePath);
       insertFtsRow(db, {
         path: filePath,
         ...ftsData,
         category: CC_MEMORY_CATEGORY,
         type: memType,
-        project: projectScope,
+        project: projectScope
       });
       db.prepare(
         `INSERT INTO file_hashes (path, content_hash, last_indexed, source_type, project_scope)
@@ -159,12 +169,10 @@ function indexCcMemory(filePath) {
            last_indexed = excluded.last_indexed,
            source_type = excluded.source_type,
            project_scope = excluded.project_scope`
-      ).run(filePath, hash, new Date().toISOString(), CC_MEMORY_CATEGORY, projectScope);
+      ).run(filePath, hash, (/* @__PURE__ */ new Date()).toISOString(), CC_MEMORY_CATEGORY, projectScope);
     });
     updateIndex();
-
-    // Copy to ~/.mindlore/memory/{project}/ for git-sync + obsidian
-    const memoryDir = path.join(globalBase, 'memory', projectScope || '_global');
+    const memoryDir = path.join(globalBase, "memory", projectScope || "_global");
     safeMkdir(memoryDir);
     const destPath = path.join(memoryDir, path.basename(filePath));
     safeWriteFile(destPath, cleaned);
@@ -172,37 +180,29 @@ function indexCcMemory(filePath) {
     db.close();
   }
 }
-
 function catchUpScan(baseDir, dbPath) {
-  const CATCH_UP_DIRS = ['raw', 'sources', 'analyses', 'diary'];
-  const fiveMinAgo = Date.now() - 5 * 60 * 1000;
-
+  const CATCH_UP_DIRS = ["raw", "sources", "analyses", "diary"];
+  const fiveMinAgo = Date.now() - 5 * 60 * 1e3;
   const db = openDatabase(dbPath);
   if (!db) return;
-
   try {
     let indexed = 0;
     for (const dir of CATCH_UP_DIRS) {
       const dirPath = path.join(baseDir, dir);
       if (!fs.existsSync(dirPath)) continue;
-
-      const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+      const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
       for (const file of files) {
         const filePath = path.join(dirPath, file);
         const stat = fs.statSync(filePath);
         if (stat.mtimeMs < fiveMinAgo) continue;
-
-        const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+        const content = fs.readFileSync(filePath, "utf8").replace(/\r\n/g, "\n");
         const hash = sha256(content);
-
-        const existing = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?').get(filePath);
+        const existing = db.prepare("SELECT content_hash FROM file_hashes WHERE path = ?").get(filePath);
         if (existing && existing.content_hash === hash) continue;
-
         const { meta, body } = parseFrontmatter(content);
         const ftsData = extractFtsMetadata(meta, body, filePath, baseDir);
-
         const update = db.transaction(() => {
-          db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+          db.prepare("DELETE FROM mindlore_fts WHERE path = ?").run(filePath);
           insertFtsRow(db, { path: filePath, ...ftsData, project: resolveProject(ftsData.project, filePath, getProjectName()) });
           db.prepare(
             `INSERT INTO file_hashes (path, content_hash, last_indexed)
@@ -210,7 +210,7 @@ function catchUpScan(baseDir, dbPath) {
              ON CONFLICT(path) DO UPDATE SET
                content_hash = excluded.content_hash,
                last_indexed = excluded.last_indexed`
-          ).run(filePath, hash, new Date().toISOString());
+          ).run(filePath, hash, (/* @__PURE__ */ new Date()).toISOString());
         });
         update();
         indexed++;
@@ -223,8 +223,7 @@ function catchUpScan(baseDir, dbPath) {
     db.close();
   }
 }
-
-withTelemetry('mindlore-index', main).catch(err => {
-  hookLog('mindlore-index', 'error', err?.message ?? String(err));
+withTelemetry("mindlore-index", main).catch((err) => {
+  hookLog("mindlore-index", "error", err?.message ?? String(err));
   process.exit(0);
 });

package/hooks/mindlore-model-router.cjs

@@ -1,54 +1,42 @@
-'use strict';
-
-/**
- * mindlore-model-router — PreToolUse (Agent) hook
- * Overrides model for [mindlore:SKILL] marked Agent spawns.
- */
-
-const fs = require('fs');
-const { findMindloreDir, readConfig, DEFAULT_MODELS, hookLog, withTelemetrySync } = require('./lib/mindlore-common.cjs');
-
-const SKILL_KEYS = Object.keys(DEFAULT_MODELS).filter((k) => k !== 'default');
-const MARKER_REGEX = new RegExp(`\\[mindlore:(${SKILL_KEYS.join('|')})\\]`);
+"use strict";
 
+// hooks/src/mindlore-model-router.cjs
+var fs = require("fs");
+var { findMindloreDir, readConfig, DEFAULT_MODELS, hookLog, withTelemetrySync } = require("./lib/mindlore-common.cjs");
+var SKILL_KEYS = Object.keys(DEFAULT_MODELS).filter((k) => k !== "default");
+var MARKER_REGEX = new RegExp(`\\[mindlore:(${SKILL_KEYS.join("|")})\\]`);
 function main() {
   const mindloreDir = findMindloreDir();
   if (!mindloreDir) return;
-
   let input;
   try {
-    const raw = fs.readFileSync(0, 'utf8').trim();
+    const raw = fs.readFileSync(0, "utf8").trim();
     if (!raw) return;
     input = JSON.parse(raw);
   } catch (_err) {
     return;
   }
-
-  const toolName = input.tool_name || '';
-  if (toolName !== 'Agent') return;
-
+  const toolName = input.tool_name || "";
+  if (toolName !== "Agent") return;
   const toolInput = input.tool_input || {};
-  const prompt = toolInput.prompt || '';
+  const prompt = toolInput.prompt || "";
   const match = prompt.match(MARKER_REGEX);
   if (!match) return;
-
   const skill = match[1];
-
-  // Resolve model: config.json → config default → hardcoded
   const config = readConfig(mindloreDir);
-  const models = (config && config.models) || {};
+  const models = config && config.models || {};
   const model = models[skill] || models.default || DEFAULT_MODELS[skill] || DEFAULT_MODELS.default;
-
-  const updatedInput = { ...toolInput, model: model };
-
+  const updatedInput = { ...toolInput, model };
   const output = {
     hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      updatedInput: updatedInput,
-    },
+      hookEventName: "PreToolUse",
+      updatedInput
+    }
   };
-
   process.stdout.write(JSON.stringify(output));
 }
-
-try { withTelemetrySync('mindlore-model-router', main); } catch (err) { hookLog('model-router', 'error', err?.message ?? String(err)); }
+try {
+  withTelemetrySync("mindlore-model-router", main);
+} catch (err) {
+  hookLog("model-router", "error", err?.message ?? String(err));
+}

package/hooks/mindlore-post-compact.cjs

@@ -1,69 +1,53 @@
 #!/usr/bin/env node
-'use strict';
-
-/**
- * mindlore-post-compact — PostCompact hook
- *
- * After context compaction, re-inject session context:
- * 1. Read INDEX.md
- * 2. Read latest delta
- * 3. Inject via stdout (same as session-focus)
- *
- * This ensures the agent has knowledge context after compaction.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { findMindloreDir, getLatestDelta, readConfig, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+"use strict";
 
+// hooks/src/mindlore-post-compact.cjs
+var fs = require("fs");
+var path = require("path");
+var { findMindloreDir, getLatestDelta, readConfig, hookLog, withTelemetry } = require("./lib/mindlore-common.cjs");
 function main() {
   const baseDir = findMindloreDir();
   if (!baseDir) return;
-
   const output = [];
-
-  // Re-inject INDEX.md
-  const indexPath = path.join(baseDir, 'INDEX.md');
+  const indexPath = path.join(baseDir, "INDEX.md");
   if (fs.existsSync(indexPath)) {
-    const content = fs.readFileSync(indexPath, 'utf8').trim();
-    output.push(`[Mindlore INDEX (post-compact)]\n${content}`);
+    const content = fs.readFileSync(indexPath, "utf8").trim();
+    output.push(`[Mindlore INDEX (post-compact)]
+${content}`);
   }
-
-  const diaryDir = path.join(baseDir, 'diary');
-
+  const diaryDir = path.join(baseDir, "diary");
   const latestDelta = getLatestDelta(diaryDir);
   if (latestDelta) {
-    const deltaContent = fs.readFileSync(latestDelta, 'utf8').trim();
+    const deltaContent = fs.readFileSync(latestDelta, "utf8").trim();
     const deltaName = path.basename(latestDelta);
-    output.push(`[Mindlore Delta (post-compact): ${deltaName}]\n${deltaContent}`);
+    output.push(`[Mindlore Delta (post-compact): ${deltaName}]
+${deltaContent}`);
   }
-
   try {
-    const snapshots = fs.readdirSync(diaryDir)
-      .filter(f => f.startsWith('compaction-snapshot-'))
-      .sort();
+    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'
+        path.join(diaryDir, latestSnapshot),
+        "utf8"
       ).trim();
-      output.push(`[Mindlore Compaction Resume]\n${snapshotContent}`);
+      output.push(`[Mindlore Compaction Resume]
+${snapshotContent}`);
     }
-  } catch (_err) { /* snapshot best-effort */ }
-
+  } catch (_err) {
+  }
   if (output.length > 0) {
     const config = readConfig(baseDir);
     const budgetConfig = config?.tokenBudget ?? {};
-    const maxInjectChars = (budgetConfig.sessionInject || 2000) * 4;
-    let joined = output.join('\n\n');
+    const maxInjectChars = (budgetConfig.sessionInject || 2e3) * 4;
+    let joined = output.join("\n\n");
     if (joined.length > maxInjectChars) {
-      joined = joined.slice(0, maxInjectChars) + '\n[...truncated by token budget]';
+      joined = joined.slice(0, maxInjectChars) + "\n[...truncated by token budget]";
     }
-    process.stdout.write(joined + '\n');
+    process.stdout.write(joined + "\n");
   }
 }
-
-withTelemetry('mindlore-post-compact', main).catch(err => {
-  hookLog('mindlore-post-compact', 'error', err?.message ?? String(err));
+withTelemetry("mindlore-post-compact", main).catch((err) => {
+  hookLog("mindlore-post-compact", "error", err?.message ?? String(err));
   process.exit(0);
 });