@vedtechsolutions/engram-mcp 1.0.4 → 1.0.6

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

@@ -446,16 +446,16 @@ var PROACTIVE_RECALL = {
 var MEMORY_SURFACE = {
   /** Maximum memories surfaced per prompt check */
   MAX_SURFACE_ITEMS: 3,
-  /** Candidate pool fetched from DB (filtered down to MAX_SURFACE_ITEMS) */
-  CANDIDATE_POOL_SIZE: 8,
+  /** Candidate pool fetched from DB (wider pool = more rotation diversity) */
+  CANDIDATE_POOL_SIZE: 15,
   /** Minimum turns before re-surfacing the same memory */
-  MIN_TURNS_BETWEEN_SAME: 8,
+  MIN_TURNS_BETWEEN_SAME: 12,
   /** Minimum domain string length to trigger surface injection */
   MIN_DOMAIN_LENGTH: 2,
   /** Minimum confidence for surface injection */
   MIN_SURFACE_CONFIDENCE: 0.5,
   /** Minimum reinforcement for surface injection (below default 1.0 to allow fresh memories) */
-  MIN_SURFACE_REINFORCEMENT: 0.8
+  MIN_SURFACE_REINFORCEMENT: 0.5
 };
 var RETRIEVAL_FEEDBACK = {
   /** Maximum recalled memory IDs to track (ring buffer) */
@@ -491,6 +491,29 @@ var SCHEMA_SURFACING = {
   /** Maximum instances to sample when generating a description */
   INSTANCE_SAMPLE_COUNT: 5
 };
+var PROCEDURAL_WORKFLOW = {
+  /** Minimum successful commands in sequence to form a workflow */
+  MIN_COMMANDS: 3,
+  /** Maximum commands to track in recent_commands buffer */
+  MAX_TRACKED_COMMANDS: 20,
+  /** Maximum procedural workflows to encode per session */
+  MAX_PER_SESSION: 5,
+  /** Minimum time gap (ms) between workflow encodings to avoid bursts */
+  MIN_ENCODE_GAP_MS: 12e4,
+  /** Workflow pattern keywords — commands matching these form workflow candidates */
+  WORKFLOW_PATTERNS: {
+    build: ["build", "compile", "tsup", "tsc", "webpack", "vite", "esbuild", "rollup", "make"],
+    test: ["test", "vitest", "jest", "pytest", "mocha", "cargo test"],
+    deploy: ["deploy", "publish", "release", "push", "npm publish", "yarn publish", "pnpm publish"],
+    install: ["install", "npm install", "pnpm install", "yarn", "pip install", "cargo add"],
+    lint: ["lint", "eslint", "prettier", "black", "ruff", "clippy"],
+    db: ["migrate", "migration", "seed", "prisma", "alembic", "knex"],
+    docker: ["docker", "compose", "podman"],
+    git: ["git commit", "git push", "git tag", "git merge", "git rebase"]
+  },
+  /** Minimum confidence for encoding */
+  MIN_CONFIDENCE: 0.65
+};
 var CODE_CONTEXT_RECALL = {
   /** Maximum code identifiers to extract from content */
   MAX_CODE_KEYWORDS: 15,
@@ -9664,9 +9687,12 @@ function removeProficiency(model, domain) {
 function computeProficiency(prof, domain) {
   let avgConfidence = 0.5;
   try {
-    const domainMemories = getMemoriesByDomain(domain, 50);
-    if (domainMemories.length > 0) {
-      avgConfidence = domainMemories.reduce((sum, m) => sum + m.confidence, 0) / domainMemories.length;
+    const domainMemories = getMemoriesByDomain(domain, 100);
+    const qualityMemories = domainMemories.filter(
+      (m) => m.type === "semantic" || m.type === "procedural" || m.type === "antipattern" || m.type === "episodic" && isEpisodicData(m.type_data) && m.type_data.lesson && m.type_data.lesson.length > 10
+    );
+    if (qualityMemories.length > 0) {
+      avgConfidence = qualityMemories.reduce((sum, m) => sum + m.confidence, 0) / qualityMemories.length;
     }
   } catch {
   }
@@ -12376,6 +12402,7 @@ export {
   PROACTIVE_RECALL,
   MEMORY_SURFACE,
   RETRIEVAL_FEEDBACK,
+  PROCEDURAL_WORKFLOW,
   CODE_CONTEXT_RECALL,
   DEDUP,
   SCHEMA_LIFECYCLE,
@@ -12627,4 +12654,4 @@ export {
   composeProjectUnderstanding,
   formatMentalModelInjection
 };
-//# sourceMappingURL=chunk-QU7DOPA4.js.map
+//# sourceMappingURL=chunk-V5TTXT4V.js.map

package/dist/hook.js

@@ -28,6 +28,7 @@ import {
   PREWRITE_BLOCKING,
   PRE_COMPACTION,
   PROACTIVE_RECALL,
+  PROCEDURAL_WORKFLOW,
   REASONING_CHAIN,
   REASONING_TRACE,
   RETRIEVAL_FEEDBACK,
@@ -173,7 +174,7 @@ import {
   updateReasoningChain,
   updateSelfModelFromSession,
   updateTask
-} from "./chunk-QU7DOPA4.js";
+} from "./chunk-V5TTXT4V.js";
 
 // src/hook.ts
 import { readFileSync, writeFileSync, existsSync, renameSync, statSync, readdirSync, unlinkSync, appendFileSync, openSync, readSync, closeSync } from "fs";
@@ -1743,7 +1744,11 @@ function composeSessionNarrative(params) {
   if (params.total_turns < SESSION_NARRATIVE.MIN_TURNS_FOR_NARRATIVE) {
     return null;
   }
-  const goal = extractGoal(params);
+  const goal = extractGoal({
+    ...params,
+    cognitive_state: params.cognitive_state,
+    session_files: params.session_files
+  });
   const approach = params.cognitive_state?.current_approach ?? extractApproach(params.conversation);
   const challenges = extractChallenges(params);
   const baseLessons = extractLessons(params);
@@ -1781,6 +1786,13 @@ function composeSessionNarrative(params) {
 }
 function extractGoal(params) {
   if (params.active_task) return params.active_task;
+  if (params.cognitive_state?.current_approach) {
+    return params.cognitive_state.current_approach;
+  }
+  if (params.cognitive_state?.recent_discovery && params.session_files && params.session_files.length > 0) {
+    const topFiles = params.session_files.slice(-3).map((f) => f.split(/[/\\]/).pop() ?? f).join(", ");
+    return `${params.cognitive_state.recent_discovery} (${topFiles})`;
+  }
   if (params.conversation.topic_history.length > 0) {
     return params.conversation.topic_history[0].topic;
   }
@@ -3113,7 +3125,9 @@ function loadWatcherState() {
         recall_misses: raw.recall_misses ?? 0,
         last_status_turn: raw.last_status_turn ?? 0,
         offload_message_sent: raw.offload_message_sent ?? false,
-        summary_injection_mode: raw.summary_injection_mode ?? false
+        summary_injection_mode: raw.summary_injection_mode ?? false,
+        recent_commands: raw.recent_commands ?? [],
+        procedural_encoded_count: raw.procedural_encoded_count ?? 0
       };
     }
   } catch {
@@ -3175,7 +3189,9 @@ function loadWatcherState() {
     recall_misses: 0,
     last_status_turn: 0,
     offload_message_sent: false,
-    summary_injection_mode: false
+    summary_injection_mode: false,
+    recent_commands: [],
+    procedural_encoded_count: 0
   };
 }
 function saveWatcherState(state) {
@@ -4015,6 +4031,77 @@ Output: ${truncate(toolOutput, 500)}`,
     } catch {
     }
   }
+  try {
+    const cmdLower = cmd.toLowerCase();
+    const exitCode = stdinJson?.tool_response_metadata;
+    const cmdSuccess = !isError;
+    state.recent_commands.push({ cmd: truncate(cmd, 200), success: cmdSuccess, time: (/* @__PURE__ */ new Date()).toISOString() });
+    if (state.recent_commands.length > PROCEDURAL_WORKFLOW.MAX_TRACKED_COMMANDS) {
+      state.recent_commands = state.recent_commands.slice(-PROCEDURAL_WORKFLOW.MAX_TRACKED_COMMANDS);
+    }
+    stateChanged = true;
+    if (cmdSuccess && state.procedural_encoded_count < PROCEDURAL_WORKFLOW.MAX_PER_SESSION) {
+      const successCmds = state.recent_commands.filter((c) => c.success);
+      if (successCmds.length >= PROCEDURAL_WORKFLOW.MIN_COMMANDS) {
+        for (const [workflowName, keywords] of Object.entries(PROCEDURAL_WORKFLOW.WORKFLOW_PATTERNS)) {
+          const matching = successCmds.filter((c) => {
+            const cl = c.cmd.toLowerCase();
+            return keywords.some((kw) => cl.includes(kw));
+          });
+          if (matching.length >= PROCEDURAL_WORKFLOW.MIN_COMMANDS) {
+            const steps = matching.slice(-6).map((c, i) => `${i + 1}. ${truncate(c.cmd, 120)}`).join("\n");
+            const content = `${workflowName} workflow (${matching.length} steps):
+${steps}`;
+            const domains = state.active_domain ? [state.active_domain] : [];
+            const existing = findDuplicate(content, "procedural", domains);
+            if (!existing) {
+              createMemory({
+                type: "procedural",
+                content,
+                summary: `${workflowName} workflow: ${matching.slice(-3).map((c) => truncate(c.cmd, 40)).join(" \u2192 ")}`,
+                encoding_strength: 0.7,
+                reinforcement: 1.2,
+                confidence: PROCEDURAL_WORKFLOW.MIN_CONFIDENCE,
+                storage_tier: "short_term",
+                pinned: false,
+                tags: ["workflow", `workflow-${workflowName}`, "auto-encoded"],
+                domains,
+                version: state.active_version,
+                encoding_context: {
+                  project: state.active_project,
+                  project_path: state.active_project_path,
+                  framework: state.active_domain,
+                  version: state.active_version,
+                  files: state.session_files.slice(-5),
+                  task_type: workflowName === "build" ? "building" : null,
+                  error_context: null,
+                  session_id: sessionId,
+                  significance_score: 0.7
+                },
+                type_data: {
+                  kind: "procedural",
+                  steps: matching.map((c) => c.cmd),
+                  preconditions: [],
+                  postconditions: [],
+                  practice_count: 1,
+                  automaticity: 0.3,
+                  variants: [],
+                  skill_metadata: null
+                }
+              });
+              state.procedural_encoded_count++;
+              stateChanged = true;
+              log.info("Auto-encoded procedural workflow", { type: workflowName, steps: matching.length });
+              const matchedTimes = new Set(matching.map((c) => c.time));
+              state.recent_commands = state.recent_commands.filter((c) => !matchedTimes.has(c.time));
+            }
+            break;
+          }
+        }
+      }
+    }
+  } catch {
+  }
   if (stateChanged) {
     saveWatcherState(state);
   }
@@ -4851,7 +4938,9 @@ function handleSessionStart(stdinJson, argFallback) {
     recall_misses: isPostCompact ? prevState?.recall_misses ?? 0 : 0,
     last_status_turn: 0,
     offload_message_sent: false,
-    summary_injection_mode: false
+    summary_injection_mode: false,
+    recent_commands: isPostCompact ? prevState?.recent_commands ?? [] : [],
+    procedural_encoded_count: isPostCompact ? prevState?.procedural_encoded_count ?? 0 : 0
   });
   const source = metadata.source;
   if (!source || source === "startup") {
@@ -6098,7 +6187,8 @@ ${distillLines}`
       }
       const rawCandidates = getTopDomainMemories(surfaceDomain, MEMORY_SURFACE.CANDIDATE_POOL_SIZE, excludeIds, state.active_project ?? void 0);
       const candidates = rawCandidates.filter(
-        (m) => m.confidence >= MEMORY_SURFACE.MIN_SURFACE_CONFIDENCE && m.reinforcement >= MEMORY_SURFACE.MIN_SURFACE_REINFORCEMENT && !isRecallNoise(m.content, m.type, m.tags)
+        (m) => m.confidence >= MEMORY_SURFACE.MIN_SURFACE_CONFIDENCE && m.reinforcement >= MEMORY_SURFACE.MIN_SURFACE_REINFORCEMENT && !isRecallNoise(m.content, m.type, m.tags) && !m.tags.includes("session_narrative")
+        // narratives are for model composition, not surfacing
       );
       const surfaced = selectDiverseSurface(candidates, MEMORY_SURFACE.MAX_SURFACE_ITEMS);
       if (surfaced.length > 0) {
@@ -6184,6 +6274,7 @@ ${distillLines}`
             if (somaticIds.has(m.memory.id)) continue;
             if (isRecallNoise(m.memory.content, m.memory.type, m.memory.tags)) continue;
             if (m.memory.tags.includes("pre-compact")) continue;
+            if (m.memory.tags.includes("session_narrative")) continue;
             const isFailure = m.memory.type === "episodic" && isEpisodicData(m.memory.type_data) && m.memory.type_data.outcome === "negative";
             const prefix = m.somatic_marker ? "[ENGRAM GUT]" : isFailure ? "[ENGRAM CAUTION]" : "[ENGRAM CONTEXT]";
             const outcomeHint = m.memory.type === "episodic" && (m.somatic_marker || isFailure) ? getEpisodicOutcomeHint(m.memory) : "";

package/dist/index.js

@@ -154,7 +154,7 @@ import {
   vaccinate,
   vacuumDatabase,
   validateMultiPerspective
-} from "./chunk-QU7DOPA4.js";
+} from "./chunk-V5TTXT4V.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.4",
+  "version": "1.0.6",
   "description": "Cognitive memory system for AI — persistent, cross-session learning via MCP",
   "type": "module",
   "main": "dist/index.js",