mindlore 0.7.0 → 0.7.1

package/hooks/mindlore-session-end.cjs

@@ -1,119 +1,91 @@
 #!/usr/bin/env node
-'use strict';
-
-/**
- * mindlore-session-end — SessionEnd hook
- *
- * Writes a basic delta file to diary/ with session timestamp.
- * v0.1: minimal delta (timestamp + marker)
- * v0.2: structured delta with stats, decisions, learnings
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { execFileSync, spawn } = require('child_process');
-const { safeWriteFile, safeWriteJson } = require('../dist/scripts/lib/secure-io.js');
-const { findMindloreDir, globalDir, getProjectName, openDatabase, ensureEpisodesTable, hasEpisodesTable, insertBareEpisode, insertFtsRow, hookLog, SHARED_EXPORT_DIRS, resolveWin32Bin, withTelemetry, getUnpromotedRawFiles, cleanupExpiredInjectLog } = require('./lib/mindlore-common.cjs');
-
-const EXPORT_DIRS = SHARED_EXPORT_DIRS;
-
-// --worker mode: heavy ops run in detached child process (survives parent exit)
-if (process.argv.includes('--worker')) {
-  hookLog('session-end', 'info', 'worker started, pid=' + process.pid);
-  const dataPath = process.argv[process.argv.indexOf('--worker') + 1];
+"use strict";
+
+// hooks/src/mindlore-session-end.cjs
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var { execFileSync, spawn } = require("child_process");
+var { safeWriteFile, safeWriteJson } = require("./lib/secure-io.cjs");
+var { findMindloreDir, globalDir, getProjectName, openDatabase, ensureEpisodesTable, hasEpisodesTable, insertBareEpisode, insertFtsRow, hookLog, SHARED_EXPORT_DIRS, resolveWin32Bin, withTelemetry, getUnpromotedRawFiles, cleanupExpiredInjectLog } = require("./lib/mindlore-common.cjs");
+var EXPORT_DIRS = SHARED_EXPORT_DIRS;
+if (process.argv.includes("--worker")) {
+  hookLog("session-end", "info", "worker started, pid=" + process.pid);
+  const dataPath = process.argv[process.argv.indexOf("--worker") + 1];
   let payload;
   try {
-    const raw = fs.readFileSync(dataPath, 'utf8');
+    const raw = fs.readFileSync(dataPath, "utf8");
     fs.unlinkSync(dataPath);
     payload = JSON.parse(raw);
   } catch (_err) {
-    hookLog('session-end', 'error', 'payload read failed: ' + (_err?.message ?? _err));
+    hookLog("session-end", "error", "payload read failed: " + (_err?.message ?? _err));
     process.exit(0);
   }
   const { baseDir, project, commits, changedFiles, reads } = payload;
-
   async function safeRunAsync(fn, label) {
     try {
       await fn();
-      hookLog('session-end', 'info', label + ' OK');
+      hookLog("session-end", "info", label + " OK");
     } catch (e) {
-      hookLog('session-end', 'error', label + ' FAIL: ' + e?.message);
+      hookLog("session-end", "error", label + " FAIL: " + e?.message);
     }
   }
-
   (async () => {
-    // Episode writes share DB — run sequentially first
-    await safeRunAsync(() => writeBareEpisode(baseDir, project, commits, changedFiles, reads), 'episode');
-    await safeRunAsync(() => writeEpisodeFile(baseDir, project, commits, changedFiles, reads), 'episode-file');
-
+    await safeRunAsync(() => writeBareEpisode(baseDir, project, commits, changedFiles, reads), "episode");
+    await safeRunAsync(() => writeEpisodeFile(baseDir, project, commits, changedFiles, reads), "episode-file");
+    const nodeExe = resolveWin32Bin("node") || process.execPath;
     function runSyncScript(scriptName, args, timeoutMs, label) {
-      const scriptPath = path.join(__dirname, '..', 'dist', 'scripts', scriptName);
-      if (!fs.existsSync(scriptPath)) return;
-      const nodeExe = resolveWin32Bin('node') || process.execPath;
+      const cjsName = scriptName.replace(/\.js$/, ".cjs");
+      const scriptPath = [path.join(__dirname, cjsName), path.join(__dirname, "..", "dist", "scripts", scriptName)].find((p) => fs.existsSync(p));
+      if (!scriptPath) return;
       try {
         execFileSync(nodeExe, [scriptPath, ...args], {
           timeout: timeoutMs,
           env: { ...process.env, MINDLORE_HOME: baseDir },
-          windowsHide: true,
+          windowsHide: true
         });
-        hookLog('session-end', 'info', label + ' completed');
+        hookLog("session-end", "info", label + " completed");
       } catch (err) {
-        hookLog('session-end', 'warn', `${label} failed: ${err?.message || err}`);
+        hookLog("session-end", "warn", `${label} failed: ${err?.message || err}`);
       }
     }
-
-    await safeRunAsync(() => runSyncScript('cc-memory-bulk-sync.js', ['--auto'], 10000, 'CC memory sync'), 'cc-memory-sync');
-    await safeRunAsync(() => runSyncScript('cc-session-sync.js', [], 30000, 'CC session sync'), 'cc-session-sync');
-
-    // Raw accumulation warning (moved from main to worker — off hot path)
+    await safeRunAsync(() => runSyncScript("cc-memory-bulk-sync.js", ["--auto"], 1e4, "CC memory sync"), "cc-memory-sync");
+    await safeRunAsync(() => runSyncScript("cc-session-sync.js", [], 3e4, "CC session sync"), "cc-session-sync");
     await safeRunAsync(() => {
       const unpromoted = getUnpromotedRawFiles(baseDir);
       if (unpromoted.length >= 5) {
-        hookLog('session-end', 'info', `${unpromoted.length} raw files unpromoted`);
+        hookLog("session-end", "info", `${unpromoted.length} raw files unpromoted`);
       }
-    }, 'raw-check');
-
-    // Obsidian + git-sync are independent — run in parallel
+    }, "raw-check");
     await Promise.allSettled([
-      safeRunAsync(() => syncObsidian(baseDir), 'obsidian'),
-      safeRunAsync(() => syncGlobalRepo(), 'git-sync'),
+      safeRunAsync(() => syncObsidian(baseDir), "obsidian"),
+      safeRunAsync(() => syncGlobalRepo(), "git-sync")
     ]);
-
-    hookLog('session-end', 'info', 'worker done');
+    hookLog("session-end", "info", "worker done");
     process.exit(0);
   })();
 }
-
 function formatDate(date) {
   const y = date.getFullYear();
-  const m = String(date.getMonth() + 1).padStart(2, '0');
-  const d = String(date.getDate()).padStart(2, '0');
-  const h = String(date.getHours()).padStart(2, '0');
-  const min = String(date.getMinutes()).padStart(2, '0');
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
   return `${y}-${m}-${d}-${h}${min}`;
 }
-
-/**
- * Get recent commits and changed files in a single git call.
- * Returns { commits: string[], changedFiles: string[] }
- */
 function getRecentGitInfo() {
   try {
-    // --name-only includes file names after each commit entry
-    const raw = execFileSync('git', ['log', '--oneline', '-5', '--name-only'], {
-      encoding: 'utf8',
-      timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      windowsHide: true,
+    const raw = execFileSync("git", ["log", "--oneline", "-5", "--name-only"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
     }).trim();
     if (!raw) return { commits: [], changedFiles: [] };
-
     const commits = [];
-    const fileSet = new Set();
-    for (const line of raw.split('\n')) {
+    const fileSet = /* @__PURE__ */ new Set();
+    for (const line of raw.split("\n")) {
       if (!line) continue;
-      // Commit lines start with a short hash (7+ hex chars)
       if (/^[0-9a-f]{7,}\s/.test(line)) {
         commits.push(line);
       } else {
@@ -125,386 +97,293 @@ function getRecentGitInfo() {
     return { commits: [], changedFiles: [] };
   }
 }
-
 function getSessionReads(baseDir) {
-  const readsPath = path.join(baseDir, 'diary', `_session-reads-${getProjectName()}.json`);
+  const readsPath = path.join(baseDir, "diary", `_session-reads-${getProjectName()}.json`);
   if (!fs.existsSync(readsPath)) return null;
   try {
-    const data = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
+    const data = JSON.parse(fs.readFileSync(readsPath, "utf8"));
     const count = Object.keys(data).length;
     const repeats = Object.values(data).filter((v) => {
-      if (typeof v === 'number') return v > 1;
-      if (v && typeof v === 'object') return (v.count || 0) > 1;
+      if (typeof v === "number") return v > 1;
+      if (v && typeof v === "object") return (v.count || 0) > 1;
       return false;
     }).length;
-    // Clean up session file
     fs.unlinkSync(readsPath);
     return { count, repeats };
   } catch (_err) {
     return null;
   }
 }
-
 function main() {
   const baseDir = findMindloreDir();
   if (!baseDir) return;
-
-  const diaryDir = path.join(baseDir, 'diary');
+  const diaryDir = path.join(baseDir, "diary");
   if (!fs.existsSync(diaryDir)) {
     fs.mkdirSync(diaryDir, { recursive: true });
   }
-
-  const now = new Date();
+  const now = /* @__PURE__ */ new Date();
   const dateStr = formatDate(now);
   const deltaPath = path.join(diaryDir, `delta-${dateStr}.md`);
-
-  // Don't overwrite existing delta (idempotent)
   if (fs.existsSync(deltaPath)) return;
-
-  // Gather structured data (single git call)
   const { commits, changedFiles } = getRecentGitInfo();
   const reads = getSessionReads(baseDir);
-
   const project = getProjectName();
-
   const sections = [
-    '---',
+    "---",
     `slug: delta-${dateStr}`,
-    'type: diary',
+    "type: diary",
     `date: ${now.toISOString().slice(0, 10)}`,
     `project: ${project}`,
-    '---',
-    '',
-    `# Session Delta — ${dateStr}`,
-    '',
-    `Session ended: ${now.toISOString()}`,
+    "---",
+    "",
+    `# Session Delta \u2014 ${dateStr}`,
+    "",
+    `Session ended: ${now.toISOString()}`
   ];
-
-  // Commits section
-  sections.push('', '## Commits');
+  sections.push("", "## Commits");
   if (commits.length > 0) {
     for (const c of commits) sections.push(`- ${c}`);
   } else {
-    sections.push('- _(no commits)_');
+    sections.push("- _(no commits)_");
   }
-
-  // Changed files section
-  sections.push('', '## Changed Files');
+  sections.push("", "## Changed Files");
   if (changedFiles.length > 0) {
     for (const f of changedFiles) sections.push(`- ${f}`);
   } else {
-    sections.push('- _(no file changes)_');
+    sections.push("- _(no file changes)_");
   }
-
-  // Read stats (from read-guard, if active)
   if (reads) {
-    sections.push('', '## Read Stats');
+    sections.push("", "## Read Stats");
     sections.push(`- ${reads.count} files read, ${reads.repeats} repeated reads`);
   }
-
-  sections.push('');
-
-  safeWriteFile(deltaPath, sections.join('\n'));
-
-  // Append to log.md
-  const logPath = path.join(baseDir, 'log.md');
+  sections.push("");
+  safeWriteFile(deltaPath, sections.join("\n"));
+  const logPath = path.join(baseDir, "log.md");
   if (fs.existsSync(logPath)) {
-    const logEntry = `| ${now.toISOString().slice(0, 10)} | session-end | delta-${dateStr}.md |\n`;
-    fs.appendFileSync(logPath, logEntry, 'utf8');
+    const logEntry = `| ${now.toISOString().slice(0, 10)} | session-end | delta-${dateStr}.md |
+`;
+    fs.appendFileSync(logPath, logEntry, "utf8");
   }
-
-  // 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
   try {
     const workerData = JSON.stringify({ baseDir, project, commits, changedFiles, reads });
     const tmpFile = path.join(os.tmpdir(), `mindlore-worker-${Date.now()}.json`);
     safeWriteFile(tmpFile, workerData);
-    // Use system node instead of process.execPath — CC's embedded Node
-    // may not work as a standalone binary for detached worker processes.
-    // Resolve full path to avoid shell:true deprecation warning on Windows.
-    const nodeBin = resolveWin32Bin('node');
-    const child = spawn(nodeBin, [__filename, '--worker', tmpFile], {
+    const nodeBin = resolveWin32Bin("node");
+    const child = spawn(nodeBin, [__filename, "--worker", tmpFile], {
       detached: true,
-      stdio: 'ignore',
+      stdio: "ignore",
       cwd: process.cwd(),
-      windowsHide: true,
+      windowsHide: true
     });
     child.unref();
   } catch (_err) {
-    // Fallback: run inline if spawn fails
     writeBareEpisode(baseDir, project, commits, changedFiles, reads);
     writeEpisodeFile(baseDir, project, commits, changedFiles, reads);
     syncObsidian(baseDir);
     syncGlobalRepo();
   }
 }
-
-/**
- * Write a bare session episode to the episodes table.
- * Deterministic — no LLM needed. Captures commits, files, read stats.
- */
 function writeBareEpisode(baseDir, project, commits, changedFiles, reads) {
   try {
-    const dbPath = path.join(baseDir, 'mindlore.db');
+    const dbPath = path.join(baseDir, "mindlore.db");
     const db = openDatabase(dbPath);
     if (!db) return;
-
     if (!hasEpisodesTable(db)) {
       ensureEpisodesTable(db);
     }
-
-    const commitList = commits.length > 0 ? commits.join(', ') : 'no commits';
+    const commitList = commits.length > 0 ? commits.join(", ") : "no commits";
     const fileCount = changedFiles.length;
     const summary = `Session: ${commitList} (${fileCount} files)`;
-
     const bodyParts = [];
     if (commits.length > 0) {
-      bodyParts.push('## Commits\n' + commits.map(c => `- ${c}`).join('\n'));
+      bodyParts.push("## Commits\n" + commits.map((c) => `- ${c}`).join("\n"));
     }
     if (changedFiles.length > 0) {
-      bodyParts.push('## Changed Files\n' + changedFiles.map(f => `- ${f}`).join('\n'));
+      bodyParts.push("## Changed Files\n" + changedFiles.map((f) => `- ${f}`).join("\n"));
     }
     if (reads) {
-      bodyParts.push(`## Read Stats\n- ${reads.count} files read, ${reads.repeats} repeated`);
+      bodyParts.push(`## Read Stats
+- ${reads.count} files read, ${reads.repeats} repeated`);
     }
-
     const entities = changedFiles.slice(0, 10);
-    const body = bodyParts.join('\n\n') || null;
+    const body = bodyParts.join("\n\n") || null;
     const truncatedSummary = summary.slice(0, 300);
-
-    // Atomic: episode + FTS5 mirror in single transaction
     const writeBoth = db.transaction(() => {
       const epId = insertBareEpisode(db, {
-        kind: 'session',
-        scope: 'project',
-        project: project,
+        kind: "session",
+        scope: "project",
+        project,
         summary: truncatedSummary,
-        body: body,
-        tags: 'session',
+        body,
+        tags: "session",
         entities: entities.length > 0 ? entities : null,
-        source: 'hook',
+        source: "hook"
       });
-
-      // FTS5 mirror — episode searchable via mindlore-search hook
       try {
         insertFtsRow(db, {
           path: `episodes/${epId}`,
           slug: `ep-${epId}`,
           description: truncatedSummary,
-          type: 'episode',
-          category: 'episodes',
+          type: "episode",
+          category: "episodes",
           title: truncatedSummary,
-          content: [truncatedSummary, body ?? ''].join('\n').trim(),
-          tags: 'session',
+          content: [truncatedSummary, body ?? ""].join("\n").trim(),
+          tags: "session",
           quality: null,
-          dateCaptured: new Date().toISOString().slice(0, 10),
-          project: project,
+          dateCaptured: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+          project
         });
       } catch (_ftsErr) {
-        // FTS5 mirror optional — don't break the transaction
       }
     });
     writeBoth();
-
-    // TTL cleanup for episode_inject_log (R4)
-    try { cleanupExpiredInjectLog(db); } catch (_err) { /* cleanup is optional */ }
-
+    try {
+      cleanupExpiredInjectLog(db);
+    } catch (_err) {
+    }
     db.close();
   } catch (err) {
-    hookLog('session-end', 'error', `episode write failed: ${err?.message ?? err}`);
+    hookLog("session-end", "error", `episode write failed: ${err?.message ?? err}`);
   }
 }
-
-/**
- * Write episode as .md file to diary/{project}/ for human-readable browsing.
- * Complements the DB episode — same content, different medium.
- */
 function writeEpisodeFile(baseDir, project, commits, changedFiles, reads) {
-  const projDir = path.join(baseDir, 'diary', project || 'unknown');
+  const projDir = path.join(baseDir, "diary", project || "unknown");
   if (!fs.existsSync(projDir)) fs.mkdirSync(projDir, { recursive: true });
-
-  const now = process.env.MINDLORE_EPISODE_TS ? new Date(process.env.MINDLORE_EPISODE_TS) : new Date();
+  const now = process.env.MINDLORE_EPISODE_TS ? new Date(process.env.MINDLORE_EPISODE_TS) : /* @__PURE__ */ new Date();
   const ts = formatDate(now);
   const filePath = path.join(projDir, `episode-${ts}.md`);
-  if (fs.existsSync(filePath)) return; // idempotent
-
+  if (fs.existsSync(filePath)) return;
   const lines = [
-    '---',
+    "---",
     `slug: episode-${ts}`,
-    'type: episode',
+    "type: episode",
     `date: ${now.toISOString().slice(0, 10)}`,
-    `project: ${project || 'unknown'}`,
-    '---',
-    '',
-    `# Episode — ${ts}`,
-    '',
+    `project: ${project || "unknown"}`,
+    "---",
+    "",
+    `# Episode \u2014 ${ts}`,
+    ""
   ];
-
   if (commits.length > 0) {
-    lines.push('## Commits');
+    lines.push("## Commits");
     for (const c of commits) lines.push(`- ${c}`);
-    lines.push('');
+    lines.push("");
   }
-
   if (changedFiles.length > 0) {
-    lines.push('## Changed Files');
+    lines.push("## Changed Files");
     for (const f of changedFiles) lines.push(`- ${f}`);
-    lines.push('');
+    lines.push("");
   }
-
   if (reads) {
-    lines.push('## Read Stats');
+    lines.push("## Read Stats");
     lines.push(`- ${reads.count} files read, ${reads.repeats} repeated`);
-    lines.push('');
+    lines.push("");
   }
-
   if (commits.length === 0 && changedFiles.length === 0) {
-    lines.push('_Read-only session — no commits or file changes._');
-    lines.push('');
+    lines.push("_Read-only session \u2014 no commits or file changes._");
+    lines.push("");
   }
-
-  safeWriteFile(filePath, lines.join('\n'));
+  safeWriteFile(filePath, lines.join("\n"));
 }
-
-let _obsidianHelpersCache = undefined; // undefined = not yet attempted
-/**
- * Load obsidian-helpers from compiled dist (single source of truth for wikilink conversion).
- * Returns null if helpers not available (e.g. dev environment without build).
- * Result is cached — require() runs at most once per process.
- */
+var _obsidianHelpersCache = void 0;
 function getObsidianHelpers() {
-  if (_obsidianHelpersCache !== undefined) return _obsidianHelpersCache;
+  if (_obsidianHelpersCache !== void 0) return _obsidianHelpersCache;
   try {
     const hookDir = __dirname;
     const pkgRoot = path.dirname(hookDir);
-    const helpersPath = path.join(pkgRoot, 'dist', 'scripts', 'lib', 'obsidian-helpers.js');
+    const helpersPath = path.join(pkgRoot, "dist", "scripts", "lib", "obsidian-helpers.js");
     _obsidianHelpersCache = require(helpersPath);
     return _obsidianHelpersCache;
   } catch (err) {
-    if (process.env.MINDLORE_DEBUG === '1') {
-      process.stderr.write(`[mindlore] obsidian-helpers not available: ${err.message}\n`);
+    if (process.env.MINDLORE_DEBUG === "1") {
+      process.stderr.write(`[mindlore] obsidian-helpers not available: ${err.message}
+`);
     }
     _obsidianHelpersCache = null;
     return null;
   }
 }
-
-/**
- * Export a single .md file to Obsidian vault with wikilink conversion.
- * Uses obsidian-helpers.convertToWikilinks for consistent behavior.
- * Returns true if file was exported.
- */
 function exportMdFile(srcPath, destPath, convertFn) {
   try {
     const destStat = fs.statSync(destPath);
     const srcStat = fs.statSync(srcPath);
     if (srcStat.mtimeMs <= destStat.mtimeMs) return false;
   } catch (_err) {
-    // dest doesn't exist — proceed with export
   }
-  let content = fs.readFileSync(srcPath, 'utf8');
+  let content = fs.readFileSync(srcPath, "utf8");
   content = convertFn(content);
-  fs.writeFileSync(destPath, content, 'utf8');
+  fs.writeFileSync(destPath, content, "utf8");
   return true;
 }
-
-/**
- * Auto-export .md files to Obsidian vault if configured.
- * Skips if no vault configured, vault missing, or nothing changed since last export.
- */
 function syncObsidian(baseDir) {
   try {
-    const configPath = path.join(baseDir, 'config.json');
-    if (!fs.existsSync(configPath)) return;
-
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    const vaultPath = config?.obsidian?.vault;
-    if (!vaultPath || typeof vaultPath !== 'string') return;
-    if (!fs.existsSync(vaultPath)) return;
-
-    const helpers = getObsidianHelpers();
-    // Fallback regex if helpers unavailable (strips path prefixes like the canonical version)
-    const convertFn = helpers?.convertToWikilinks
-      ?? ((c) => c.replace(/\[([^\]]+)\]\((?:\.\.?\/)?(?:[\w-]+\/)*([^/)]+)\.md\)/g, '[[$2]]'));
-
-    const destBase = path.join(vaultPath, 'mindlore');
-    let exported = 0;
-
-    function walkAndExport(srcDir, destDir) {
+    let walkAndExport = function(srcDir, destDir) {
       if (!fs.existsSync(srcDir)) return;
       fs.mkdirSync(destDir, { recursive: true });
       for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-        if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+        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')) {
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
           if (exportMdFile(srcPath, destPath, convertFn)) exported++;
         }
       }
-    }
-
+    };
+    const configPath = path.join(baseDir, "config.json");
+    if (!fs.existsSync(configPath)) return;
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const vaultPath = config?.obsidian?.vault;
+    if (!vaultPath || typeof vaultPath !== "string") return;
+    if (!fs.existsSync(vaultPath)) return;
+    const helpers = getObsidianHelpers();
+    const convertFn = helpers?.convertToWikilinks ?? ((c) => c.replace(/\[([^\]]+)\]\((?:\.\.?\/)?(?:[\w-]+\/)*([^/)]+)\.md\)/g, "[[$2]]"));
+    const destBase = path.join(vaultPath, "mindlore");
+    let exported = 0;
     for (const dir of EXPORT_DIRS) {
       walkAndExport(path.join(baseDir, dir), path.join(destBase, dir));
     }
-
-    for (const rootFile of ['INDEX.md', 'log.md']) {
+    for (const rootFile of ["INDEX.md", "log.md"]) {
       const srcPath = path.join(baseDir, rootFile);
       if (!fs.existsSync(srcPath)) continue;
       fs.mkdirSync(destBase, { recursive: true });
       if (exportMdFile(srcPath, path.join(destBase, rootFile), convertFn)) exported++;
     }
-
-    hookLog('session-end', 'info', `obsidian exported=${exported}, dirs=${EXPORT_DIRS.length}, vault=${vaultPath}`);
+    hookLog("session-end", "info", `obsidian exported=${exported}, dirs=${EXPORT_DIRS.length}, vault=${vaultPath}`);
     if (exported > 0) {
-      config.obsidian.lastExport = new Date().toISOString();
+      config.obsidian.lastExport = (/* @__PURE__ */ new Date()).toISOString();
       config.obsidian.lastExportCount = exported;
       safeWriteJson(configPath, config);
     }
   } catch (err) {
-    hookLog('session-end', 'error', `obsidian internal: ${err?.message ?? err}`);
-    throw err; // re-throw so safeRun logs FAIL
+    hookLog("session-end", "error", `obsidian internal: ${err?.message ?? err}`);
+    throw err;
   }
 }
-
-/**
- * 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 resolveGitBin() {
-  return resolveWin32Bin('git');
+  return resolveWin32Bin("git");
 }
-
 function syncGlobalRepo() {
   const gDir = globalDir();
-  const gitDir = path.join(gDir, '.git');
+  const gitDir = path.join(gDir, ".git");
   if (!fs.existsSync(gitDir)) return;
-
   const git = resolveGitBin();
-  const execOpts = (timeout) => ({ cwd: gDir, encoding: 'utf8', timeout, stdio: 'pipe', windowsHide: true });
-
-  // Check for changes
-  const status = execFileSync(git, ['status', '--porcelain'], execOpts(5000)).trim();
-  if (!status) return; // nothing to commit
-
-  execFileSync(git, ['add', '*.md', 'mindlore.db', 'diary/', 'sources/', 'domains/', 'analyses/', 'decisions/', 'raw/', 'connections/', 'insights/', 'learnings/'], execOpts(10000));
-  const now = new Date().toISOString().slice(0, 19);
-  execFileSync(git, ['commit', '-m', `mindlore auto-sync ${now}`], execOpts(15000));
-
-  // Push — graceful fail if no remote or offline
+  const execOpts = (timeout) => ({ cwd: gDir, encoding: "utf8", timeout, stdio: "pipe", windowsHide: true });
+  const status = execFileSync(git, ["status", "--porcelain"], execOpts(5e3)).trim();
+  if (!status) return;
+  execFileSync(git, ["add", "*.md", "mindlore.db", "diary/", "sources/", "domains/", "analyses/", "decisions/", "raw/", "connections/", "insights/", "learnings/"], execOpts(1e4));
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
+  execFileSync(git, ["commit", "-m", `mindlore auto-sync ${now}`], execOpts(15e3));
   try {
-    execFileSync(git, ['push'], execOpts(30000));
+    execFileSync(git, ["push"], execOpts(3e4));
   } catch (_pushErr) {
-    hookLog('session-end', 'warn', 'git push failed (offline?): ' + (_pushErr?.message ?? '').slice(0, 100));
+    hookLog("session-end", "warn", "git push failed (offline?): " + (_pushErr?.message ?? "").slice(0, 100));
   }
 }
-
-if (!process.argv.includes('--worker')) {
-  withTelemetry('mindlore-session-end', main).catch(err => {
-    hookLog('mindlore-session-end', 'error', err?.message ?? String(err));
+if (!process.argv.includes("--worker")) {
+  withTelemetry("mindlore-session-end", main).catch((err) => {
+    hookLog("mindlore-session-end", "error", err?.message ?? String(err));
     process.exit(0);
   });
 }