engrm 0.3.4 → 0.4.1

package/dist/hooks/session-start.js

@@ -3,11 +3,16 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// hooks/session-start.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
+import { homedir, hostname, networkInterfaces } from "node:os";
 import { join } from "node:path";
-import { randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 var CONFIG_DIR = join(homedir(), ".engrm");
 var SETTINGS_PATH = join(CONFIG_DIR, "settings.json");
 var DB_PATH = join(CONFIG_DIR, "engrm.db");
@@ -16,7 +21,22 @@ function getDbPath() {
 }
 function generateDeviceId() {
   const host = hostname().toLowerCase().replace(/[^a-z0-9-]/g, "");
-  const suffix = randomBytes(4).toString("hex");
+  let mac = "";
+  const ifaces = networkInterfaces();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
+        break;
+      }
+    }
+    if (mac)
+      break;
+  }
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash("sha256").update(material).digest("hex").slice(0, 8);
   return `${host}-${suffix}`;
 }
 function createDefaultConfig() {
@@ -58,7 +78,10 @@ function createDefaultConfig() {
     observer: {
       enabled: true,
       mode: "per_event",
-      model: "haiku"
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
     }
   };
 }
@@ -117,6 +140,9 @@ function loadConfig() {
       enabled: asBool(config["observer"]?.["enabled"], defaults.observer.enabled),
       mode: asObserverMode(config["observer"]?.["mode"], defaults.observer.mode),
       model: asString(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
     }
   };
 }
@@ -1109,7 +1135,7 @@ function estimateTokens(text) {
 }
 function buildSessionContext(db, cwd, options = {}) {
   const opts = typeof options === "number" ? { maxCount: options } : options;
-  const tokenBudget = opts.tokenBudget ?? 800;
+  const tokenBudget = opts.tokenBudget ?? 3000;
   const maxCount = opts.maxCount;
   const detected = detectProject(cwd);
   const project = db.getProjectByCanonicalId(detected.canonical_id);
@@ -1131,6 +1157,12 @@ function buildSessionContext(db, cwd, options = {}) {
        AND superseded_by IS NULL
        ORDER BY quality DESC, created_at_epoch DESC
        LIMIT ?`).all(project.id, MAX_PINNED);
+  const MAX_RECENT = 5;
+  const recent = db.db.query(`SELECT * FROM observations
+       WHERE project_id = ? AND lifecycle IN ('active', 'aging')
+       AND superseded_by IS NULL
+       ORDER BY created_at_epoch DESC
+       LIMIT ?`).all(project.id, MAX_RECENT);
   const candidateLimit = maxCount ?? 50;
   const candidates = db.db.query(`SELECT * FROM observations
        WHERE project_id = ? AND lifecycle IN ('active', 'aging')
@@ -1158,6 +1190,12 @@ function buildSessionContext(db, cwd, options = {}) {
     });
   }
   const seenIds = new Set(pinned.map((o) => o.id));
+  const dedupedRecent = recent.filter((o) => {
+    if (seenIds.has(o.id))
+      return false;
+    seenIds.add(o.id);
+    return true;
+  });
   const deduped = candidates.filter((o) => !seenIds.has(o.id));
   for (const obs of crossProjectCandidates) {
     if (!seenIds.has(obs.id)) {
@@ -1174,8 +1212,8 @@ function buildSessionContext(db, cwd, options = {}) {
     return scoreB - scoreA;
   });
   if (maxCount !== undefined) {
-    const remaining = Math.max(0, maxCount - pinned.length);
-    const all = [...pinned, ...sorted.slice(0, remaining)];
+    const remaining = Math.max(0, maxCount - pinned.length - dedupedRecent.length);
+    const all = [...pinned, ...dedupedRecent, ...sorted.slice(0, remaining)];
     return {
       project_name: project.name,
       canonical_id: project.canonical_id,
@@ -1191,6 +1229,11 @@ function buildSessionContext(db, cwd, options = {}) {
     remainingBudget -= cost;
     selected.push(obs);
   }
+  for (const obs of dedupedRecent) {
+    const cost = estimateObservationTokens(obs, selected.length);
+    remainingBudget -= cost;
+    selected.push(obs);
+  }
   for (const obs of sorted) {
     const cost = estimateObservationTokens(obs, selected.length);
     if (remainingBudget - cost < 0 && selected.length > 0)
@@ -1198,7 +1241,7 @@ function buildSessionContext(db, cwd, options = {}) {
     remainingBudget -= cost;
     selected.push(obs);
   }
-  const summaries = db.getRecentSummaries(project.id, 2);
+  const summaries = db.getRecentSummaries(project.id, 5);
   let securityFindings = [];
   try {
     const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86400;
@@ -1218,7 +1261,7 @@ function buildSessionContext(db, cwd, options = {}) {
   };
 }
 function estimateObservationTokens(obs, index) {
-  const DETAILED_THRESHOLD = 3;
+  const DETAILED_THRESHOLD = 5;
   const titleCost = estimateTokens(`- **[${obs.type}]** ${obs.title} (2026-01-01, q=0.5)`);
   if (index >= DETAILED_THRESHOLD) {
     return titleCost;
@@ -1230,7 +1273,7 @@ function formatContextForInjection(context) {
   if (context.observations.length === 0) {
     return `Project: ${context.project_name} (no prior observations)`;
   }
-  const DETAILED_COUNT = 3;
+  const DETAILED_COUNT = 5;
   const lines = [
     `## Project Memory: ${context.project_name}`,
     `${context.session_count} relevant observation(s) from prior sessions:`,
@@ -1455,9 +1498,83 @@ function detectStacksFromProject(projectRoot, filePaths = []) {
   return { stacks: sorted, primary };
 }
 
+// src/telemetry/config-fingerprint.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var STATE_PATH = join4(homedir2(), ".engrm", "config-fingerprint.json");
+var CLIENT_VERSION = "0.4.0";
+function hashFile(filePath) {
+  try {
+    if (!existsSync4(filePath))
+      return null;
+    const content = readFileSync3(filePath, "utf-8");
+    return createHash2("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function countMemoryFiles(memoryDir) {
+  try {
+    if (!existsSync4(memoryDir))
+      return 0;
+    return readdirSync(memoryDir).filter((f) => f.endsWith(".md")).length;
+  } catch {
+    return 0;
+  }
+}
+function readPreviousFingerprint() {
+  try {
+    if (!existsSync4(STATE_PATH))
+      return null;
+    return JSON.parse(readFileSync3(STATE_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveFingerprint(fp) {
+  try {
+    const dir = join4(homedir2(), ".engrm");
+    if (!existsSync4(dir))
+      mkdirSync2(dir, { recursive: true });
+    writeFileSync2(STATE_PATH, JSON.stringify(fp, null, 2) + `
+`, "utf-8");
+  } catch {}
+}
+function computeAndSaveFingerprint(cwd) {
+  const claudeMdHash = hashFile(join4(cwd, "CLAUDE.md"));
+  const engrmJsonHash = hashFile(join4(cwd, ".engrm.json"));
+  const slug = cwd.replace(/\//g, "-");
+  const memoryDir = join4(homedir2(), ".claude", "projects", slug, "memory");
+  const memoryMdHash = hashFile(join4(memoryDir, "MEMORY.md"));
+  const memoryFileCount = countMemoryFiles(memoryDir);
+  const material = [
+    claudeMdHash ?? "null",
+    memoryMdHash ?? "null",
+    engrmJsonHash ?? "null",
+    String(memoryFileCount),
+    CLIENT_VERSION
+  ].join("+");
+  const configHash = createHash2("sha256").update(material).digest("hex");
+  const previous = readPreviousFingerprint();
+  const configChanged = previous !== null && previous.config_hash !== configHash;
+  const fingerprint = {
+    config_hash: configHash,
+    config_changed: configChanged,
+    claude_md_hash: claudeMdHash,
+    memory_md_hash: memoryMdHash,
+    engrm_json_hash: engrmJsonHash,
+    memory_file_count: memoryFileCount,
+    client_version: CLIENT_VERSION
+  };
+  saveFingerprint(fingerprint);
+  return fingerprint;
+}
+
 // src/packs/recommender.ts
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3 } from "node:fs";
-import { join as join4, basename as basename3, dirname } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "node:fs";
+import { join as join5, basename as basename3, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 var STACK_PACK_MAP = {
   typescript: ["typescript-patterns"],
@@ -1470,20 +1587,20 @@ var STACK_PACK_MAP = {
 };
 function getPacksDir() {
   const thisDir = dirname(fileURLToPath(import.meta.url));
-  return join4(thisDir, "../../packs");
+  return join5(thisDir, "../../packs");
 }
 function listAvailablePacks() {
   const dir = getPacksDir();
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => basename3(f, ".json"));
+  return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => basename3(f, ".json"));
 }
 function loadPack(name) {
-  const packPath = join4(getPacksDir(), `${name}.json`);
-  if (!existsSync4(packPath))
+  const packPath = join5(getPacksDir(), `${name}.json`);
+  if (!existsSync5(packPath))
     return null;
   try {
-    const raw = readFileSync3(packPath, "utf-8");
+    const raw = readFileSync4(packPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1517,6 +1634,202 @@ function recommendPacks(stacks, installedPacks) {
   return recommendations;
 }
 
+// src/config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3, hostname as hostname2, networkInterfaces as networkInterfaces2 } from "node:os";
+import { join as join6 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+var CONFIG_DIR2 = join6(homedir3(), ".engrm");
+var SETTINGS_PATH2 = join6(CONFIG_DIR2, "settings.json");
+var DB_PATH2 = join6(CONFIG_DIR2, "engrm.db");
+function getDbPath2() {
+  return DB_PATH2;
+}
+function generateDeviceId2() {
+  const host = hostname2().toLowerCase().replace(/[^a-z0-9-]/g, "");
+  let mac = "";
+  const ifaces = networkInterfaces2();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
+        break;
+      }
+    }
+    if (mac)
+      break;
+  }
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash3("sha256").update(material).digest("hex").slice(0, 8);
+  return `${host}-${suffix}`;
+}
+function createDefaultConfig2() {
+  return {
+    candengo_url: "",
+    candengo_api_key: "",
+    site_id: "",
+    namespace: "",
+    user_id: "",
+    user_email: "",
+    device_id: generateDeviceId2(),
+    teams: [],
+    sync: {
+      enabled: true,
+      interval_seconds: 30,
+      batch_size: 50
+    },
+    search: {
+      default_limit: 10,
+      local_boost: 1.2,
+      scope: "all"
+    },
+    scrubbing: {
+      enabled: true,
+      custom_patterns: [],
+      default_sensitivity: "shared"
+    },
+    sentinel: {
+      enabled: false,
+      mode: "advisory",
+      provider: "openai",
+      model: "gpt-4o-mini",
+      api_key: "",
+      base_url: "",
+      skip_patterns: [],
+      daily_limit: 100,
+      tier: "free"
+    },
+    observer: {
+      enabled: true,
+      mode: "per_event",
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
+    }
+  };
+}
+function loadConfig2() {
+  if (!existsSync6(SETTINGS_PATH2)) {
+    throw new Error(`Config not found at ${SETTINGS_PATH2}. Run 'engrm init --manual' to configure.`);
+  }
+  const raw = readFileSync5(SETTINGS_PATH2, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${SETTINGS_PATH2}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Config at ${SETTINGS_PATH2} is not a JSON object`);
+  }
+  const config = parsed;
+  const defaults = createDefaultConfig2();
+  return {
+    candengo_url: asString2(config["candengo_url"], defaults.candengo_url),
+    candengo_api_key: asString2(config["candengo_api_key"], defaults.candengo_api_key),
+    site_id: asString2(config["site_id"], defaults.site_id),
+    namespace: asString2(config["namespace"], defaults.namespace),
+    user_id: asString2(config["user_id"], defaults.user_id),
+    user_email: asString2(config["user_email"], defaults.user_email),
+    device_id: asString2(config["device_id"], defaults.device_id),
+    teams: asTeams2(config["teams"], defaults.teams),
+    sync: {
+      enabled: asBool2(config["sync"]?.["enabled"], defaults.sync.enabled),
+      interval_seconds: asNumber2(config["sync"]?.["interval_seconds"], defaults.sync.interval_seconds),
+      batch_size: asNumber2(config["sync"]?.["batch_size"], defaults.sync.batch_size)
+    },
+    search: {
+      default_limit: asNumber2(config["search"]?.["default_limit"], defaults.search.default_limit),
+      local_boost: asNumber2(config["search"]?.["local_boost"], defaults.search.local_boost),
+      scope: asScope2(config["search"]?.["scope"], defaults.search.scope)
+    },
+    scrubbing: {
+      enabled: asBool2(config["scrubbing"]?.["enabled"], defaults.scrubbing.enabled),
+      custom_patterns: asStringArray2(config["scrubbing"]?.["custom_patterns"], defaults.scrubbing.custom_patterns),
+      default_sensitivity: asSensitivity2(config["scrubbing"]?.["default_sensitivity"], defaults.scrubbing.default_sensitivity)
+    },
+    sentinel: {
+      enabled: asBool2(config["sentinel"]?.["enabled"], defaults.sentinel.enabled),
+      mode: asSentinelMode2(config["sentinel"]?.["mode"], defaults.sentinel.mode),
+      provider: asLlmProvider2(config["sentinel"]?.["provider"], defaults.sentinel.provider),
+      model: asString2(config["sentinel"]?.["model"], defaults.sentinel.model),
+      api_key: asString2(config["sentinel"]?.["api_key"], defaults.sentinel.api_key),
+      base_url: asString2(config["sentinel"]?.["base_url"], defaults.sentinel.base_url),
+      skip_patterns: asStringArray2(config["sentinel"]?.["skip_patterns"], defaults.sentinel.skip_patterns),
+      daily_limit: asNumber2(config["sentinel"]?.["daily_limit"], defaults.sentinel.daily_limit),
+      tier: asTier2(config["sentinel"]?.["tier"], defaults.sentinel.tier)
+    },
+    observer: {
+      enabled: asBool2(config["observer"]?.["enabled"], defaults.observer.enabled),
+      mode: asObserverMode2(config["observer"]?.["mode"], defaults.observer.mode),
+      model: asString2(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool2(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
+    }
+  };
+}
+function saveConfig(config) {
+  if (!existsSync6(CONFIG_DIR2)) {
+    mkdirSync3(CONFIG_DIR2, { recursive: true });
+  }
+  writeFileSync3(SETTINGS_PATH2, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function configExists2() {
+  return existsSync6(SETTINGS_PATH2);
+}
+function asString2(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber2(value, fallback) {
+  return typeof value === "number" && !Number.isNaN(value) ? value : fallback;
+}
+function asBool2(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asStringArray2(value, fallback) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : fallback;
+}
+function asScope2(value, fallback) {
+  if (value === "personal" || value === "team" || value === "all")
+    return value;
+  return fallback;
+}
+function asSensitivity2(value, fallback) {
+  if (value === "shared" || value === "personal" || value === "secret")
+    return value;
+  return fallback;
+}
+function asSentinelMode2(value, fallback) {
+  if (value === "advisory" || value === "blocking")
+    return value;
+  return fallback;
+}
+function asLlmProvider2(value, fallback) {
+  if (value === "openai" || value === "anthropic" || value === "ollama" || value === "custom")
+    return value;
+  return fallback;
+}
+function asTier2(value, fallback) {
+  if (value === "free" || value === "vibe" || value === "solo" || value === "pro" || value === "team" || value === "enterprise")
+    return value;
+  return fallback;
+}
+function asObserverMode2(value, fallback) {
+  if (value === "per_event" || value === "per_session")
+    return value;
+  return fallback;
+}
+function asTeams2(value, fallback) {
+  if (!Array.isArray(value))
+    return fallback;
+  return value.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string" && typeof t.name === "string" && typeof t.namespace === "string");
+}
+
 // src/sync/auth.ts
 function getApiKey(config) {
   const envKey = process.env.ENGRM_TOKEN;
@@ -1702,6 +2015,44 @@ function extractNarrative(content) {
 `).trim();
   return narrative.length > 0 ? narrative : null;
 }
+async function pullSettings(client, config) {
+  try {
+    const settings = await client.fetchSettings();
+    if (!settings)
+      return false;
+    let changed = false;
+    if (settings.transcript_analysis !== undefined) {
+      const ta = settings.transcript_analysis;
+      if (typeof ta === "object" && ta !== null) {
+        const taObj = ta;
+        if (taObj.enabled !== undefined && taObj.enabled !== config.transcript_analysis.enabled) {
+          config.transcript_analysis.enabled = !!taObj.enabled;
+          changed = true;
+        }
+      }
+    }
+    if (settings.observer !== undefined) {
+      const obs = settings.observer;
+      if (typeof obs === "object" && obs !== null) {
+        const obsObj = obs;
+        if (obsObj.enabled !== undefined && obsObj.enabled !== config.observer.enabled) {
+          config.observer.enabled = !!obsObj.enabled;
+          changed = true;
+        }
+        if (obsObj.model !== undefined && typeof obsObj.model === "string" && obsObj.model !== config.observer.model) {
+          config.observer.model = obsObj.model;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      saveConfig(config);
+    }
+    return changed;
+  } catch {
+    return false;
+  }
+}
 
 // src/sync/client.ts
 class VectorClient {
@@ -1756,6 +2107,13 @@ class VectorClient {
   async sendTelemetry(beacon) {
     await this.request("POST", "/v1/mem/telemetry", beacon);
   }
+  async fetchSettings() {
+    try {
+      return await this.request("GET", "/v1/mem/user-settings");
+    } catch {
+      return null;
+    }
+  }
   async health() {
     try {
       await this.request("GET", "/health");
@@ -1824,57 +2182,120 @@ async function main() {
   } catch {
     process.exit(0);
   }
+  let syncedCount = 0;
   try {
     if (config.sync.enabled && config.candengo_api_key) {
       try {
-        const client = new VectorClient(config.candengo_url, config.candengo_api_key, config.site_id, config.namespace);
+        const client = new VectorClient(config);
         const pullResult = await pullFromVector(db, client, config, 50);
-        if (pullResult.merged > 0) {
-          console.error(`Engrm: synced ${pullResult.merged} observation(s) from server`);
-        }
+        syncedCount = pullResult.merged;
+        await pullSettings(client, config);
       } catch {}
     }
+    try {
+      computeAndSaveFingerprint(event.cwd);
+    } catch {}
     const context = buildSessionContext(db, event.cwd, {
       tokenBudget: 800,
       scope: config.search.scope
     });
+    if (context) {
+      try {
+        const dir = join7(homedir4(), ".engrm");
+        if (!existsSync7(dir))
+          mkdirSync4(dir, { recursive: true });
+        writeFileSync4(join7(dir, "hook-session-metrics.json"), JSON.stringify({
+          contextObsInjected: context.observations.length,
+          contextTotalAvailable: context.total_active
+        }), "utf-8");
+      } catch {}
+    }
     if (context && context.observations.length > 0) {
-      console.log(formatContextForInjection(context));
-      const parts = [];
-      parts.push(`${context.session_count} observation(s)`);
-      if (context.securityFindings && context.securityFindings.length > 0) {
-        parts.push(`${context.securityFindings.length} security finding(s)`);
-      }
       const remaining = context.total_active - context.session_count;
-      if (remaining > 0) {
-        parts.push(`${remaining} more searchable`);
-      }
+      let msgCount = 0;
       try {
         const readKey = `messages_read_${config.device_id}`;
         const lastReadId = parseInt(db.getSyncState(readKey) ?? "0", 10);
-        const msgCount = db.db.query("SELECT COUNT(*) as c FROM observations WHERE type = 'message' AND id > ? AND lifecycle IN ('active', 'pinned')").get(lastReadId)?.c ?? 0;
-        if (msgCount > 0) {
-          parts.push(`${msgCount} unread message(s)`);
+        msgCount = db.db.query("SELECT COUNT(*) as c FROM observations WHERE type = 'message' AND id > ? AND lifecycle IN ('active', 'pinned')").get(lastReadId)?.c ?? 0;
+      } catch {}
+      const splash = formatSplashScreen({
+        projectName: context.project_name,
+        loaded: context.session_count,
+        available: remaining,
+        securityFindings: context.securityFindings?.length ?? 0,
+        unreadMessages: msgCount,
+        synced: syncedCount
+      });
+      let packLine = "";
+      try {
+        const { stacks } = detectStacksFromProject(event.cwd);
+        if (stacks.length > 0) {
+          const installed = db.getInstalledPacks();
+          const recs = recommendPacks(stacks, installed);
+          if (recs.length > 0) {
+            const names = recs.map((r) => `\`${r.name}\``).join(", ");
+            packLine = `
+Help packs available for your stack: ${names}. ` + `Use the install_pack tool to load curated observations.`;
+          }
         }
       } catch {}
-      console.error(`Engrm: ${parts.join(" \xB7 ")} \u2014 memory loaded`);
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: formatContextForInjection(context) + packLine
+        },
+        systemMessage: splash
+      }));
     }
-    try {
-      const { stacks } = detectStacksFromProject(event.cwd);
-      if (stacks.length > 0) {
-        const installed = db.getInstalledPacks();
-        const recs = recommendPacks(stacks, installed);
-        if (recs.length > 0) {
-          const names = recs.map((r) => `\`${r.name}\``).join(", ");
-          console.log(`
-Help packs available for your stack: ${names}. ` + `Use the install_pack tool to load curated observations.`);
-        }
-      }
-    } catch {}
   } finally {
     db.close();
   }
 }
+var c = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m"
+};
+function formatSplashScreen(data) {
+  const lines = [];
+  lines.push("");
+  lines.push(`${c.cyan}${c.bold}  ______  ____   _  ______  _____   ____    __${c.reset}`);
+  lines.push(`${c.cyan}${c.bold}  |   ___||    \\ | ||   ___||     | |    \\  /  |${c.reset}`);
+  lines.push(`${c.cyan}${c.bold}  |   ___||     \\| ||   |  ||     \\ |     \\/   |${c.reset}`);
+  lines.push(`${c.cyan}${c.bold}  |______||__/\\____||______||__|\\__\\|__/\\__/|__|${c.reset}`);
+  lines.push(`${c.dim}  memory layer for AI agents${c.reset}`);
+  lines.push("");
+  const dot = `${c.dim} \xB7 ${c.reset}`;
+  const statParts = [];
+  statParts.push(`${c.green}${data.loaded}${c.reset} loaded`);
+  if (data.available > 0) {
+    statParts.push(`${c.dim}${data.available.toLocaleString()} searchable${c.reset}`);
+  }
+  if (data.synced > 0) {
+    statParts.push(`${c.cyan}${data.synced} synced${c.reset}`);
+  }
+  lines.push(`  ${c.white}${c.bold}engrm${c.reset}${dot}${statParts.join(dot)}`);
+  const alerts = [];
+  if (data.securityFindings > 0) {
+    alerts.push(`${c.yellow}${data.securityFindings} security finding${data.securityFindings !== 1 ? "s" : ""}${c.reset}`);
+  }
+  if (data.unreadMessages > 0) {
+    alerts.push(`${c.magenta}${data.unreadMessages} unread message${data.unreadMessages !== 1 ? "s" : ""}${c.reset}`);
+  }
+  if (alerts.length > 0) {
+    lines.push(`  ${alerts.join(dot)}`);
+  }
+  lines.push("");
+  lines.push(`  ${c.dim}Dashboard: https://engrm.dev/dashboard${c.reset}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
 main().catch(() => {
   process.exit(0);
 });