@vedtechsolutions/engram-mcp 1.0.2 → 1.0.4

package/dist/{chunk-AC6AZCP4.js → chunk-QU7DOPA4.js}

@@ -1710,7 +1710,11 @@ var CONTEXTUAL = {
   /** Penalty multiplier for project mismatch on episodic memories (0.3 = 70% reduction) */
   PROJECT_MISMATCH_PENALTY: 0.3,
   /** Boost for failure experiences with lessons (surfaces "I tried this and it didn't work") */
-  FAILURE_EXPERIENCE_BOOST: 0.2
+  FAILURE_EXPERIENCE_BOOST: 0.2,
+  /** Boost when memory files share the same module directory as current file */
+  MODULE_PROXIMITY_BOOST: 0.2,
+  /** Penalty multiplier when memory files are all from a different module (0.3 = 70% reduction) */
+  MODULE_MISMATCH_PENALTY: 0.3
 };
 var REWARD = {
   /** Seed activation boost for positively-reinforced memories */
@@ -8758,6 +8762,19 @@ function extractCodeContext(code, filePath) {
     identifiers: uniqueTerms
   };
 }
+function extractModuleFromPath(filePath) {
+  const parts = filePath.split(/[/\\]/).filter(Boolean);
+  const markers = ["addons", "custom-addons", "extra-addons", "packages", "apps"];
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (markers.includes(parts[i]) && i + 1 < parts.length) {
+      return parts[i + 1];
+    }
+  }
+  if (parts.length >= 3) {
+    return parts[parts.length - 3];
+  }
+  return null;
+}
 function detectLanguage(code, filePath) {
   if (filePath) {
     const ext = filePath.split(".").pop()?.toLowerCase();
@@ -9033,6 +9050,18 @@ function contextualBoost(memory, context) {
   if (context.current_files.length > 0 && enc.files.length > 0) {
     const overlap = context.current_files.filter((f) => enc.files.includes(f)).length;
     boost += Math.min(overlap * CONTEXTUAL.FILE_BOOST_PER_MATCH, CONTEXTUAL.FILE_BOOST_CAP);
+    if (overlap === 0) {
+      const currentModules = context.current_files.map(extractModuleFromPath).filter(Boolean);
+      const memModules = enc.files.map(extractModuleFromPath).filter(Boolean);
+      if (currentModules.length > 0 && memModules.length > 0) {
+        const moduleOverlap = currentModules.some((m) => memModules.includes(m));
+        if (moduleOverlap) {
+          boost += CONTEXTUAL.MODULE_PROXIMITY_BOOST;
+        } else {
+          return (1 + boost) * CONTEXTUAL.MODULE_MISMATCH_PENALTY;
+        }
+      }
+    }
   }
   if (context.current_error && enc.error_context) {
     const errorKeywords = context.current_error.toLowerCase().split(/\s+/).slice(0, 10);
@@ -12541,6 +12570,7 @@ export {
   computeActivationProfile,
   contextualRecall,
   codeContextRecall,
+  extractModuleFromPath,
   findSimilarDecisions,
   formatDecisionInjection,
   findSimilarChains,
@@ -12597,4 +12627,4 @@ export {
   composeProjectUnderstanding,
   formatMentalModelInjection
 };
-//# sourceMappingURL=chunk-AC6AZCP4.js.map
+//# sourceMappingURL=chunk-QU7DOPA4.js.map

package/dist/hook.js

@@ -79,6 +79,7 @@ import {
   estimateTokens,
   extractErrorFingerprint,
   extractKeywords,
+  extractModuleFromPath,
   findDuplicate,
   findErrorByFingerprint,
   findResolutionForError,
@@ -172,7 +173,7 @@ import {
   updateReasoningChain,
   updateSelfModelFromSession,
   updateTask
-} from "./chunk-AC6AZCP4.js";
+} from "./chunk-QU7DOPA4.js";
 
 // src/hook.ts
 import { readFileSync, writeFileSync, existsSync, renameSync, statSync, readdirSync, unlinkSync, appendFileSync, openSync, readSync, closeSync } from "fs";
@@ -3527,9 +3528,7 @@ function handlePreWrite(toolInput, argFallback) {
     if (filePath) {
       const fileCount = (watcherState.prewrite_file_counts[filePath] ?? 0) + 1;
       watcherState.prewrite_file_counts[filePath] = fileCount;
-      if (fileCount <= CODE_CONTEXT_RECALL.PREWRITE_COOLDOWN_PER_FILE) {
-        skipCodeRecall = fileCount > 1;
-      }
+      skipCodeRecall = fileCount % CODE_CONTEXT_RECALL.PREWRITE_COOLDOWN_PER_FILE !== 1;
       saveWatcherState(watcherState);
     }
     if (!skipCodeRecall && content.length >= CODE_CONTEXT_RECALL.MIN_CONTENT_LENGTH) {
@@ -3540,18 +3539,30 @@ function handlePreWrite(toolInput, argFallback) {
           project: watcherState.active_project
         }, config.retrieval);
         const activeDomain = watcherState.active_domain;
+        const currentModule = filePath ? extractModuleFromPath(filePath) : null;
+        const isModuleMismatch = (mem) => {
+          if (!currentModule) return false;
+          const memFiles = mem.memory.encoding_context?.files;
+          if (!memFiles || memFiles.length === 0) return false;
+          const memModules = memFiles.map(extractModuleFromPath).filter(Boolean);
+          if (memModules.length === 0) return false;
+          return !memModules.includes(currentModule);
+        };
         for (const p of codeResult.patterns) {
           if (p.activation < CODE_CONTEXT_RECALL.MIN_PREWRITE_ACTIVATION) continue;
           if (p.memory.type === "episodic") continue;
           if (activeDomain && p.memory.encoding_context?.framework && p.memory.encoding_context.framework !== activeDomain) continue;
+          if (isModuleMismatch(p)) continue;
           contextLines.push(`[ENGRAM PATTERN] ${truncate(p.memory.content, 200)}`);
         }
         for (const c of codeResult.conventions) {
           if (c.activation < CODE_CONTEXT_RECALL.MIN_PREWRITE_ACTIVATION) continue;
           if (activeDomain && c.memory.encoding_context?.framework && c.memory.encoding_context.framework !== activeDomain) continue;
+          if (isModuleMismatch(c)) continue;
           contextLines.push(`[ENGRAM CONVENTION] ${truncate(c.memory.content, 200)}`);
         }
         for (const p of codeResult.procedural) {
+          if (isModuleMismatch(p)) continue;
           contextLines.push(`[ENGRAM HOW-TO] ${truncate(p.memory.content, 200)}`);
         }
       } catch (e) {
@@ -6817,6 +6828,39 @@ function handlePostCompact(stdinJson) {
     if (!recovery) return;
     const budget = new OutputBudget(OUTPUT_BUDGET.POST_COMPACT_MAX_BYTES);
     const lines = [];
+    const cog = state.cognitive_state;
+    const cogCtx = recovery.working_state?.cognitive_context;
+    const hasAnyCognitive = cog?.current_approach || cog?.active_hypothesis || cog?.recent_discovery || cogCtx?.planned_next_step || recovery.continuation_hint;
+    if (hasAnyCognitive) {
+      const mindLines = ["[Engram] Before compaction, you were:"];
+      if (state.active_task) mindLines.push(`  Task: ${truncate(state.active_task, 200)}`);
+      if (cog?.session_phase) mindLines.push(`  Phase: ${cog.session_phase}`);
+      if (cog?.current_approach) mindLines.push(`  Approach: ${truncate(cog.current_approach, 300)}`);
+      if (cog?.active_hypothesis) mindLines.push(`  Hypothesis: ${truncate(cog.active_hypothesis, 300)}`);
+      if (cog?.recent_discovery) mindLines.push(`  Discovery: ${truncate(cog.recent_discovery, 300)}`);
+      if (cogCtx?.planned_next_step) mindLines.push(`  Next step: ${truncate(cogCtx.planned_next_step, 200)}`);
+      if (cog?.search_intent) mindLines.push(`  Investigating: ${truncate(cog.search_intent, 200)}`);
+      const ruledOut = (state.session_outcomes ?? []).filter((o) => o.includes("\u2192 fail") || o.includes("\u2192 dead end") || o.includes("\u2192 blocked"));
+      if (ruledOut.length > 0) {
+        mindLines.push(`  Already tried (didn't work):`);
+        for (const o of ruledOut.slice(-3)) mindLines.push(`    - ${truncate(o, 150)}`);
+      }
+      const blockers = recovery.working_state?.active_blockers ?? [];
+      if (blockers.length > 0) {
+        mindLines.push(`  Blockers: ${blockers.slice(0, 3).map((b) => truncate(b, 100)).join("; ")}`);
+      }
+      if (state.recent_errors.length > 0) {
+        mindLines.push(`  Recent errors: ${state.recent_errors.slice(-2).map((e) => truncate(e, 100)).join("; ")}`);
+      }
+      if (state.session_files.length > 0) {
+        const files = state.session_files.slice(-8).map((f) => f.split(/[/\\]/).pop() ?? f);
+        mindLines.push(`  Files: ${files.join(", ")}`);
+      }
+      if (recovery.continuation_hint) {
+        mindLines.push(`  Continue: ${truncate(recovery.continuation_hint, 300)}`);
+      }
+      lines.push(mindLines.join("\n"));
+    }
     try {
       const transcriptPath = stdinJson?.transcript_path ?? null;
       if (transcriptPath) {

package/dist/index.js

@@ -154,7 +154,7 @@ import {
   vaccinate,
   vacuumDatabase,
   validateMultiPerspective
-} from "./chunk-AC6AZCP4.js";
+} from "./chunk-QU7DOPA4.js";
 
 // src/index.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vedtechsolutions/engram-mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Cognitive memory system for AI — persistent, cross-session learning via MCP",
   "type": "module",
   "main": "dist/index.js",