engrm 0.4.0 → 0.4.1

package/dist/hooks/post-tool-use.js

@@ -2357,6 +2357,24 @@ function extractFilesFromEvent(event) {
   }
   return { files_modified: [filePath] };
 }
+function incrementObserverSaveCount(sessionId) {
+  try {
+    const state = readState(sessionId);
+    if (state) {
+      state.saveCount = (state.saveCount ?? 0) + 1;
+      writeState(sessionId, state);
+    } else {
+      if (!existsSync3(OBSERVER_DIR)) {
+        mkdirSync2(OBSERVER_DIR, { recursive: true });
+      }
+      writeState(sessionId, {
+        observerSessionId: "",
+        eventCount: 0,
+        saveCount: 1
+      });
+    }
+  } catch {}
+}
 
 // src/capture/recall.ts
 var VEC_DISTANCE_THRESHOLD = 0.25;
@@ -2663,6 +2681,7 @@ async function main() {
           const detected = detectProject(event.cwd);
           const project = db.getProjectByCanonicalId(detected.canonical_id);
           const recall = await recallPastFix(db, sig, project?.id ?? null);
+          incrementRecallMetrics(event.session_id, recall.found);
           if (recall.found) {
             const projectLabel = recall.projectName ? ` (from ${recall.projectName})` : "";
             console.error(`
@@ -2693,6 +2712,7 @@ async function main() {
         });
         if (observed) {
           await saveObservation(db, config, observed);
+          incrementObserverSaveCount(event.session_id);
           saved = true;
         }
       } catch {}
@@ -2709,6 +2729,7 @@ async function main() {
           session_id: event.session_id,
           cwd: event.cwd
         });
+        incrementObserverSaveCount(event.session_id);
       }
     }
   } finally {
@@ -2744,6 +2765,27 @@ function extractScanText(event) {
       return null;
   }
 }
+function incrementRecallMetrics(sessionId, hit) {
+  try {
+    const { existsSync: existsSync4, readFileSync: readFileSync4, writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = __require("node:fs");
+    const { join: join4 } = __require("node:path");
+    const { homedir: homedir3 } = __require("node:os");
+    const dir = join4(homedir3(), ".engrm", "observer-sessions");
+    const path = join4(dir, `${sessionId}.json`);
+    let state = {};
+    if (existsSync4(path)) {
+      state = JSON.parse(readFileSync4(path, "utf-8"));
+    } else {
+      if (!existsSync4(dir))
+        mkdirSync3(dir, { recursive: true });
+    }
+    state.recallAttempts = (state.recallAttempts || 0) + 1;
+    if (hit) {
+      state.recallHits = (state.recallHits || 0) + 1;
+    }
+    writeFileSync3(path, JSON.stringify(state), "utf-8");
+  } catch {}
+}
 main().catch(() => {
   process.exit(0);
 });

package/dist/hooks/session-start.js

@@ -3,6 +3,11 @@
 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, networkInterfaces } from "node:os";
@@ -1493,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"],
@@ -1508,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;
@@ -1556,13 +1635,13 @@ function recommendPacks(stacks, installedPacks) {
 }
 
 // src/config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2, hostname as hostname2, networkInterfaces as networkInterfaces2 } from "node:os";
-import { join as join5 } from "node:path";
-import { createHash as createHash2 } from "node:crypto";
-var CONFIG_DIR2 = join5(homedir2(), ".engrm");
-var SETTINGS_PATH2 = join5(CONFIG_DIR2, "settings.json");
-var DB_PATH2 = join5(CONFIG_DIR2, "engrm.db");
+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;
 }
@@ -1583,7 +1662,7 @@ function generateDeviceId2() {
       break;
   }
   const material = `${host}:${mac || "no-mac"}`;
-  const suffix = createHash2("sha256").update(material).digest("hex").slice(0, 8);
+  const suffix = createHash3("sha256").update(material).digest("hex").slice(0, 8);
   return `${host}-${suffix}`;
 }
 function createDefaultConfig2() {
@@ -1633,10 +1712,10 @@ function createDefaultConfig2() {
   };
 }
 function loadConfig2() {
-  if (!existsSync5(SETTINGS_PATH2)) {
+  if (!existsSync6(SETTINGS_PATH2)) {
     throw new Error(`Config not found at ${SETTINGS_PATH2}. Run 'engrm init --manual' to configure.`);
   }
-  const raw = readFileSync4(SETTINGS_PATH2, "utf-8");
+  const raw = readFileSync5(SETTINGS_PATH2, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -1694,14 +1773,14 @@ function loadConfig2() {
   };
 }
 function saveConfig(config) {
-  if (!existsSync5(CONFIG_DIR2)) {
-    mkdirSync2(CONFIG_DIR2, { recursive: true });
+  if (!existsSync6(CONFIG_DIR2)) {
+    mkdirSync3(CONFIG_DIR2, { recursive: true });
   }
-  writeFileSync2(SETTINGS_PATH2, JSON.stringify(config, null, 2) + `
+  writeFileSync3(SETTINGS_PATH2, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function configExists2() {
-  return existsSync5(SETTINGS_PATH2);
+  return existsSync6(SETTINGS_PATH2);
 }
 function asString2(value, fallback) {
   return typeof value === "string" ? value : fallback;
@@ -2103,58 +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);
         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);
 });

package/dist/hooks/stop.js

@@ -1689,7 +1689,24 @@ function detectStacks(filePaths) {
 }
 
 // src/telemetry/beacon.ts
-function buildBeacon(db, config, sessionId) {
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function readObserverState(sessionId) {
+  try {
+    const statePath = join3(homedir2(), ".engrm", "observer-sessions", `${sessionId}.json`);
+    if (!existsSync2(statePath))
+      return { eventCount: 0, saveCount: 0 };
+    const state = JSON.parse(readFileSync2(statePath, "utf-8"));
+    return {
+      eventCount: typeof state.eventCount === "number" ? state.eventCount : 0,
+      saveCount: typeof state.saveCount === "number" ? state.saveCount : 0
+    };
+  } catch {
+    return { eventCount: 0, saveCount: 0 };
+  }
+}
+function buildBeacon(db, config, sessionId, metrics) {
   const session = db.getSessionMetrics(sessionId);
   if (!session)
     return null;
@@ -1716,6 +1733,28 @@ function buildBeacon(db, config, sessionId) {
     const row = db.getSessionMetrics(sessionId);
     riskScore = typeof row?.risk_score === "number" ? row.risk_score : 0;
   } catch {}
+  let configHash;
+  let configChanged;
+  let configFingerprintDetail;
+  try {
+    const fpPath = join3(homedir2(), ".engrm", "config-fingerprint.json");
+    if (existsSync2(fpPath)) {
+      const fp = JSON.parse(readFileSync2(fpPath, "utf-8"));
+      configHash = fp.config_hash;
+      configChanged = fp.config_changed;
+      configFingerprintDetail = JSON.stringify({
+        claude_md_hash: fp.claude_md_hash,
+        memory_md_hash: fp.memory_md_hash,
+        engrm_json_hash: fp.engrm_json_hash,
+        memory_file_count: fp.memory_file_count,
+        client_version: fp.client_version
+      });
+    }
+  } catch {}
+  const observerState = readObserverState(sessionId);
+  const observerEvents = observerState.eventCount;
+  const observerObservations = observerState.saveCount;
+  const observerSkips = Math.max(0, observerEvents - observerObservations);
   return {
     device_id: config.device_id,
     agent: session.agent ?? "claude-code",
@@ -1725,13 +1764,22 @@ function buildBeacon(db, config, sessionId) {
     tool_calls_count: session.tool_calls_count ?? 0,
     files_touched_count: session.files_touched_count ?? 0,
     searches_performed: session.searches_performed ?? 0,
-    observer_events: 0,
-    observer_observations: 0,
-    observer_skips: 0,
+    observer_events: observerEvents,
+    observer_observations: observerObservations,
+    observer_skips: observerSkips,
     sentinel_used: false,
     risk_score: riskScore,
     stacks_detected: stacks,
-    client_version: "0.4.0"
+    client_version: "0.4.0",
+    context_observations_injected: metrics?.contextObsInjected ?? 0,
+    context_total_available: metrics?.contextTotalAvailable ?? 0,
+    recall_attempts: metrics?.recallAttempts ?? 0,
+    recall_hits: metrics?.recallHits ?? 0,
+    search_count: metrics?.searchCount ?? 0,
+    search_results_total: metrics?.searchResultsTotal ?? 0,
+    config_hash: configHash,
+    config_changed: configChanged,
+    config_fingerprint_detail: configFingerprintDetail
   };
 }
 async function sendBeacon(config, beacon) {
@@ -1753,8 +1801,8 @@ async function sendBeacon(config, beacon) {
 
 // src/storage/projects.ts
 import { execSync } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { basename as basename2, join as join3 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { basename as basename2, join as join4 } from "node:path";
 function normaliseGitRemoteUrl(remoteUrl) {
   let url = remoteUrl.trim();
   url = url.replace(/^(?:https?|ssh|git):\/\//, "");
@@ -1809,11 +1857,11 @@ function getGitRemoteUrl(directory) {
   }
 }
 function readProjectConfigFile(directory) {
-  const configPath = join3(directory, ".engrm.json");
-  if (!existsSync2(configPath))
+  const configPath = join4(directory, ".engrm.json");
+  if (!existsSync3(configPath))
     return null;
   try {
-    const raw = readFileSync2(configPath, "utf-8");
+    const raw = readFileSync3(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed["project_id"] !== "string" || !parsed["project_id"]) {
       return null;
@@ -1856,9 +1904,9 @@ function detectProject(directory) {
 }
 
 // src/capture/transcript.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
-import { join as join4 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 
 // src/tools/save.ts
 import { relative, isAbsolute } from "node:path";
@@ -2430,15 +2478,15 @@ function toRelativePath(filePath, projectRoot) {
 // src/capture/transcript.ts
 function resolveTranscriptPath(sessionId, cwd) {
   const encodedCwd = cwd.replace(/\//g, "-");
-  return join4(homedir2(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
+  return join5(homedir3(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
 }
 function readTranscript(sessionId, cwd) {
   const path = resolveTranscriptPath(sessionId, cwd);
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return [];
   let raw;
   try {
-    raw = readFileSync3(path, "utf-8");
+    raw = readFileSync4(path, "utf-8");
   } catch {
     return [];
   }
@@ -2679,7 +2727,8 @@ async function main() {
     await pushOnce(db, config);
     try {
       if (event.session_id) {
-        const beacon = buildBeacon(db, config, event.session_id);
+        const metrics = readSessionMetrics(event.session_id);
+        const beacon = buildBeacon(db, config, event.session_id, metrics);
         if (beacon) {
           await sendBeacon(config, beacon);
         }
@@ -2803,6 +2852,55 @@ function detectUnsavedPlans(message) {
   }
   return hints;
 }
+function readSessionMetrics(sessionId) {
+  const { existsSync: existsSync5, readFileSync: readFileSync5, unlinkSync } = __require("node:fs");
+  const { join: join6 } = __require("node:path");
+  const { homedir: homedir4 } = __require("node:os");
+  const result = {};
+  try {
+    const obsPath = join6(homedir4(), ".engrm", "observer-sessions", `${sessionId}.json`);
+    if (existsSync5(obsPath)) {
+      const state = JSON.parse(readFileSync5(obsPath, "utf-8"));
+      if (typeof state.recallAttempts === "number")
+        result.recallAttempts = state.recallAttempts;
+      if (typeof state.recallHits === "number")
+        result.recallHits = state.recallHits;
+    }
+  } catch {}
+  try {
+    const hookPath = join6(homedir4(), ".engrm", "hook-session-metrics.json");
+    if (existsSync5(hookPath)) {
+      const hookMetrics = JSON.parse(readFileSync5(hookPath, "utf-8"));
+      if (typeof hookMetrics.contextObsInjected === "number")
+        result.contextObsInjected = hookMetrics.contextObsInjected;
+      if (typeof hookMetrics.contextTotalAvailable === "number")
+        result.contextTotalAvailable = hookMetrics.contextTotalAvailable;
+      try {
+        unlinkSync(hookPath);
+      } catch {}
+    }
+  } catch {}
+  try {
+    const mcpPath = join6(homedir4(), ".engrm", "mcp-session-metrics.json");
+    if (existsSync5(mcpPath)) {
+      const metrics = JSON.parse(readFileSync5(mcpPath, "utf-8"));
+      if (typeof metrics.contextObsInjected === "number" && metrics.contextObsInjected > 0) {
+        result.contextObsInjected = metrics.contextObsInjected;
+      }
+      if (typeof metrics.contextTotalAvailable === "number" && metrics.contextTotalAvailable > 0) {
+        result.contextTotalAvailable = metrics.contextTotalAvailable;
+      }
+      if (typeof metrics.searchCount === "number")
+        result.searchCount = metrics.searchCount;
+      if (typeof metrics.searchResultsTotal === "number")
+        result.searchResultsTotal = metrics.searchResultsTotal;
+      try {
+        unlinkSync(mcpPath);
+      } catch {}
+    }
+  } catch {}
+  return result;
+}
 main().catch(() => {
   process.exit(0);
 });

package/dist/server.js

@@ -16471,6 +16471,9 @@ function loadPack(name) {
 }
 
 // src/server.ts
+import { existsSync as existsSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 if (!configExists()) {
   console.error("Engrm is not configured. Run: engrm init --manual");
   process.exit(1);
@@ -16479,6 +16482,23 @@ var config2 = loadConfig();
 var db = new MemDatabase(getDbPath());
 var contextServed = false;
 var _lastSearchSessionId = null;
+var sessionMetrics = {
+  contextObsInjected: 0,
+  contextTotalAvailable: 0,
+  recallAttempts: 0,
+  recallHits: 0,
+  searchCount: 0,
+  searchResultsTotal: 0
+};
+var MCP_METRICS_PATH = join4(homedir2(), ".engrm", "mcp-session-metrics.json");
+function persistSessionMetrics() {
+  try {
+    const dir = join4(homedir2(), ".engrm");
+    if (!existsSync4(dir))
+      mkdirSync2(dir, { recursive: true });
+    writeFileSync2(MCP_METRICS_PATH, JSON.stringify(sessionMetrics), "utf-8");
+  } catch {}
+}
 var _detectedAgent = null;
 function getDetectedAgent() {
   if (_detectedAgent)
@@ -16591,6 +16611,9 @@ server.tool("search", "Search memory for observations", {
 }, async (params) => {
   const result = await searchObservations(db, params);
   _lastSearchSessionId = "active";
+  sessionMetrics.searchCount++;
+  sessionMetrics.searchResultsTotal += result.total;
+  persistSessionMetrics();
   if (result.total === 0) {
     return {
       content: [
@@ -16846,6 +16869,9 @@ server.tool("session_context", "Load project memory for this session", {
     };
   }
   contextServed = true;
+  sessionMetrics.contextObsInjected = context.observations.length;
+  sessionMetrics.contextTotalAvailable = context.total_active;
+  persistSessionMetrics();
   return {
     content: [
       {
@@ -16874,3 +16900,6 @@ main().catch((error48) => {
   db.close();
   process.exit(1);
 });
+export {
+  sessionMetrics
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engrm",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Cross-device, team-shared memory layer for AI coding agents",
   "type": "module",
   "main": "dist/server.js",