@cogmem/engram 0.2.1 → 0.3.1

package/src/core/activation.ts

@@ -4,7 +4,7 @@ import type { CognitiveConfig } from "../config/defaults.ts";
 export function baseLevelActivation(
   accessTimestamps: number[],
   now: number,
-  decayRate: number,
+  decayRate: number
 ): number {
   if (accessTimestamps.length === 0) return -Infinity;
 
@@ -18,13 +18,20 @@ export function baseLevelActivation(
 }
 
 // S_ji = S - ln(fan_j)
-export function spreadingActivationStrength(maxStrength: number, fanCount: number): number {
+export function spreadingActivationStrength(
+  maxStrength: number,
+  fanCount: number
+): number {
   if (fanCount <= 0) return 0;
   return Math.max(0, maxStrength - Math.log(fanCount));
 }
 
 // A_i = B_i + Σ(W_j · S_ji) + ε
-export function totalActivation(baseLevel: number, spreadingSum: number, noise: number): number {
+export function totalActivation(
+  baseLevel: number,
+  spreadingSum: number,
+  noise: number
+): number {
   return baseLevel + spreadingSum + noise;
 }
 
@@ -44,7 +51,7 @@ export function canRetrieve(activation: number, threshold: number): boolean {
 export function retrievalLatency(
   activation: number,
   latencyFactor: number,
-  latencyExponent: number,
+  latencyExponent: number
 ): number {
   return latencyFactor * Math.exp(-latencyExponent * activation);
 }
@@ -57,19 +64,44 @@ export function computeActivation(
     spreadingSum?: number;
     noiseOverride?: number;
     emotionWeight?: number;
-  },
-): { activation: number; baseLevel: number; spreading: number; noise: number; latency: number } {
-  const baseLevel = baseLevelActivation(accessTimestamps, now, config.decayRate);
+  }
+): {
+  activation: number;
+  baseLevel: number;
+  spreading: number;
+  noise: number;
+  latency: number;
+} {
+  const baseLevel = baseLevelActivation(
+    accessTimestamps,
+    now,
+    config.decayRate
+  );
 
   const emotionBoost = options?.emotionWeight
     ? Math.log(1 + options.emotionWeight * config.emotionalBoostFactor)
     : 0;
 
   const spreading = options?.spreadingSum ?? 0;
-  const noise = options?.noiseOverride ?? activationNoise(config.activationNoise);
+  const noise =
+    options?.noiseOverride ?? activationNoise(config.activationNoise);
 
-  const activation = totalActivation(baseLevel + emotionBoost, spreading, noise);
-  const latency = retrievalLatency(activation, config.latencyFactor, config.latencyExponent);
+  const activation = totalActivation(
+    baseLevel + emotionBoost,
+    spreading,
+    noise
+  );
+  const latency = retrievalLatency(
+    activation,
+    config.latencyFactor,
+    config.latencyExponent
+  );
 
-  return { activation, baseLevel: baseLevel + emotionBoost, spreading, noise, latency };
+  return {
+    activation,
+    baseLevel: baseLevel + emotionBoost,
+    spreading,
+    noise,
+    latency,
+  };
 }

package/src/core/associations.ts

@@ -113,28 +113,27 @@ export function formSemanticAssociations(
   storage: EngramStorage,
   memory: Memory,
   now?: number,
+  preloadedMemories?: Memory[],
 ): Association[] {
   const currentTime = now ?? Date.now();
   const keywords = extractKeywords(memory.content);
   if (keywords.length === 0) return [];
 
-  const allMemories = storage.getAllMemories();
+  const candidates = preloadedMemories ?? storage.getAllMemories();
+  const existing = storage.getAssociations(memory.id);
+  const linkedSet = new Set(
+    existing.flatMap((a) => [`${a.sourceId}:${a.targetId}`, `${a.targetId}:${a.sourceId}`]),
+  );
   const formed: Association[] = [];
 
-  for (const other of allMemories) {
+  for (const other of candidates) {
     if (other.id === memory.id) continue;
 
     const otherKeywords = extractKeywords(other.content);
     const overlap = keywords.filter((k) => otherKeywords.includes(k));
 
     if (overlap.length > 0) {
-      const existing = storage.getAssociations(memory.id);
-      const alreadyLinked = existing.some(
-        (a) =>
-          (a.sourceId === memory.id && a.targetId === other.id) ||
-          (a.sourceId === other.id && a.targetId === memory.id),
-      );
-      if (alreadyLinked) continue;
+      if (linkedSet.has(`${memory.id}:${other.id}`)) continue;
 
       const strength = overlap.length / Math.max(keywords.length, otherKeywords.length);
       const assoc = formAssociation(
@@ -146,6 +145,8 @@ export function formSemanticAssociations(
         currentTime,
       );
       formed.push(assoc);
+      linkedSet.add(`${memory.id}:${other.id}`);
+      linkedSet.add(`${other.id}:${memory.id}`);
     }
   }
 
@@ -156,26 +157,26 @@ export function formEmotionalAssociations(
   storage: EngramStorage,
   memory: Memory,
   now?: number,
+  preloadedMemories?: Memory[],
 ): Association[] {
   if (memory.emotion === "neutral" || memory.emotionWeight <= 0.3) return [];
 
   const currentTime = now ?? Date.now();
-  const allMemories = storage.getAllMemories();
+  const candidates = preloadedMemories ?? storage.getAllMemories();
+  const existing = storage.getAssociations(memory.id);
+  const emotionalLinks = new Set(
+    existing
+      .filter((a) => a.type === "emotional")
+      .flatMap((a) => [`${a.sourceId}:${a.targetId}`, `${a.targetId}:${a.sourceId}`]),
+  );
   const formed: Association[] = [];
   const memoryTier = AROUSAL_TIERS[memory.emotion];
 
-  for (const other of allMemories) {
+  for (const other of candidates) {
     if (other.id === memory.id) continue;
     if (other.emotion === "neutral" || other.emotionWeight <= 0.3) continue;
 
-    const existing = storage.getAssociations(memory.id);
-    const alreadyLinked = existing.some(
-      (a) =>
-        a.type === "emotional" &&
-        ((a.sourceId === memory.id && a.targetId === other.id) ||
-          (a.sourceId === other.id && a.targetId === memory.id)),
-    );
-    if (alreadyLinked) continue;
+    if (emotionalLinks.has(`${memory.id}:${other.id}`)) continue;
 
     let strength: number;
     if (memory.emotion === other.emotion) {
@@ -190,6 +191,8 @@ export function formEmotionalAssociations(
 
     const assoc = formAssociation(storage, memory.id, other.id, "emotional", strength, currentTime);
     formed.push(assoc);
+    emotionalLinks.add(`${memory.id}:${other.id}`);
+    emotionalLinks.add(`${other.id}:${memory.id}`);
   }
 
   return formed;

package/src/core/chunking.ts

@@ -62,7 +62,10 @@ class UnionFind {
   }
 }
 
-export function discoverChunks(storage: EngramStorage, config: CognitiveConfig): Chunk[] {
+export function discoverChunks(
+  storage: EngramStorage,
+  config: CognitiveConfig
+): Chunk[] {
   const allMemories = storage.getAllMemories();
   const memoryMap = new Map<string, Memory>();
   const uf = new UnionFind();
@@ -77,7 +80,8 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
     const associations = storage.getAssociations(memory.id);
     for (const assoc of associations) {
       if (assoc.strength < config.chunkingSimilarityThreshold) continue;
-      const otherId = assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
+      const otherId =
+        assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
       if (!memoryMap.has(otherId)) continue;
       uf.union(memory.id, otherId);
     }
@@ -89,7 +93,10 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
 
     const members = memberIds.map((id) => memoryMap.get(id)!);
     const chunkId = generateId();
-    const keywords = extractKeywords(members.map((m) => m.content).join(" "), 3);
+    const keywords = extractKeywords(
+      members.map((m) => m.content).join(" "),
+      3
+    );
     const label = keywords.join(" + ") || "chunk";
 
     for (const member of members) {
@@ -103,6 +110,9 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
   return chunks;
 }
 
-export function getChunkMembers(storage: EngramStorage, chunkId: string): Memory[] {
+export function getChunkMembers(
+  storage: EngramStorage,
+  chunkId: string
+): Memory[] {
   return storage.getAllMemories().filter((m) => m.chunkId === chunkId);
 }

package/src/core/consolidation.ts

@@ -1,8 +1,5 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
-import type { Memory, ConsolidationLog } from "./memory.ts";
-import { generateId } from "./memory.ts";
-import { refreshActivations } from "./forgetting.ts";
 import {
   formSemanticAssociations,
   formTemporalAssociations,
@@ -10,6 +7,9 @@ import {
   formCausalAssociations,
 } from "./associations.ts";
 import { encode } from "./encoder.ts";
+import { refreshActivations } from "./forgetting.ts";
+import type { Memory, ConsolidationLog } from "./memory.ts";
+import { generateId } from "./memory.ts";
 import { extractKeywords, tokenize } from "./search.ts";
 
 export interface ConsolidationResult {
@@ -69,11 +69,26 @@ export function consolidate(
   const remainingMemories = storage.getAllMemories();
   for (const memory of remainingMemories) {
     const temporalAssocs = formTemporalAssociations(storage, memory, config, currentTime);
-    const semanticAssocs = formSemanticAssociations(storage, memory, currentTime);
-    const emotionalAssocs = formEmotionalAssociations(storage, memory, currentTime);
+    const semanticAssocs = formSemanticAssociations(
+      storage,
+      memory,
+      currentTime,
+      remainingMemories,
+    );
+    const emotionalAssocs = formEmotionalAssociations(
+      storage,
+      memory,
+      currentTime,
+      remainingMemories,
+    );
     const causalAssocs = formCausalAssociations(storage, memory, config, currentTime);
 
-    for (const assoc of [...temporalAssocs, ...semanticAssocs, ...emotionalAssocs, ...causalAssocs]) {
+    for (const assoc of [
+      ...temporalAssocs,
+      ...semanticAssocs,
+      ...emotionalAssocs,
+      ...causalAssocs,
+    ]) {
       result.associationsDiscovered++;
       result.discoveredAssociationPairs.push([assoc.sourceId, assoc.targetId]);
     }

package/src/core/encoder.ts

@@ -1,10 +1,10 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
-import type { Memory, EncodeInput } from "./memory.ts";
-import { generateMemoryId } from "./memory.ts";
-import { defaultEmotionWeight } from "./emotional-tag.ts";
 import { baseLevelActivation } from "./activation.ts";
 import { formEmotionalAssociations, formCausalAssociations } from "./associations.ts";
+import { defaultEmotionWeight } from "./emotional-tag.ts";
+import type { Memory, EncodeInput } from "./memory.ts";
+import { generateMemoryId } from "./memory.ts";
 
 export function encode(
   storage: EngramStorage,

package/src/core/engine.ts

@@ -1,8 +1,9 @@
+import { execSync } from "node:child_process";
+import { basename } from "node:path";
+
 import type { CognitiveConfig } from "../config/defaults.ts";
 import { loadConfig } from "../config/defaults.ts";
 import { EngramStorage } from "../storage/sqlite.ts";
-import { execSync } from "node:child_process";
-import { basename } from "node:path";
 
 export function detectProjectContext(): string | null {
   try {

package/src/core/forgetting.ts

@@ -3,7 +3,10 @@ import type { EngramStorage } from "../storage/sqlite.ts";
 import { baseLevelActivation } from "./activation.ts";
 
 // R(t) = e^{-t/S}
-export function ebbinghausRetention(timeSinceLastRecall: number, strength: number): number {
+export function ebbinghausRetention(
+  timeSinceLastRecall: number,
+  strength: number
+): number {
   if (strength <= 0) return 0;
   return Math.exp(-timeSinceLastRecall / strength);
 }
@@ -12,7 +15,7 @@ export function memoryStrength(
   recallCount: number,
   emotionWeight: number,
   associationCount: number,
-  emotionalBoostFactor: number,
+  emotionalBoostFactor: number
 ): number {
   const recallStrength = 1 + recallCount * 0.8;
   const emotionalStrength = 1 + emotionWeight * emotionalBoostFactor;
@@ -23,7 +26,7 @@ export function memoryStrength(
 export function refreshActivations(
   storage: EngramStorage,
   config: CognitiveConfig,
-  now?: number,
+  now?: number
 ): { updated: number; atRisk: number } {
   const currentTime = now ?? Date.now();
   const memories = storage.getAllMemories();
@@ -34,7 +37,11 @@ export function refreshActivations(
     if (memory.type === "procedural") continue;
 
     const timestamps = storage.getAccessTimestamps(memory.id);
-    const newActivation = baseLevelActivation(timestamps, currentTime, config.decayRate);
+    const newActivation = baseLevelActivation(
+      timestamps,
+      currentTime,
+      config.decayRate
+    );
 
     const emotionBoost =
       memory.emotionWeight > 0

package/src/core/memory.ts

@@ -32,7 +32,8 @@ export const AssociationType = {
   Emotional: "emotional",
   Causal: "causal",
 } as const;
-export type AssociationType = (typeof AssociationType)[keyof typeof AssociationType];
+export type AssociationType =
+  (typeof AssociationType)[keyof typeof AssociationType];
 
 export const AccessType = {
   Encode: "encode",

package/src/core/procedural-store.ts

@@ -1,7 +1,7 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
-import type { Memory } from "./memory.ts";
 import { encode } from "./encoder.ts";
+import type { Memory } from "./memory.ts";
 
 export function encodeProcedural(
   storage: EngramStorage,

package/src/core/recall.ts

@@ -1,8 +1,11 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
-import type { Memory, RecallResult } from "./memory.ts";
-import { computeActivation, spreadingActivationStrength } from "./activation.ts";
+import {
+  computeActivation,
+  spreadingActivationStrength,
+} from "./activation.ts";
 import { getSpreadingActivationTargets } from "./associations.ts";
+import type { Memory, RecallResult } from "./memory.ts";
 import { getWorkingMemoryIds } from "./working-memory.ts";
 
 export function recall(
@@ -16,7 +19,7 @@ export function recall(
     context?: string;
     now?: number;
     deterministic?: boolean;
-  },
+  }
 ): RecallResult[] {
   const now = options?.now ?? Date.now();
   const limit = options?.limit ?? 10;
@@ -31,21 +34,20 @@ export function recall(
   for (const id of ftsIds) seedIds.add(id);
 
   if (options?.context) {
-    const contextMatches = storage.getMemoriesByContext(options.context, options?.type, limit * 2);
+    const contextMatches = storage.getMemoriesByContext(
+      options.context,
+      options?.type,
+      limit * 2
+    );
     for (const m of contextMatches) seedIds.add(m.id);
   }
 
-  const allCandidates = options?.type
-    ? storage.getAllMemories(options.type)
-    : storage.getAllMemories();
-
-  let filtered = allCandidates;
-  if (options?.context) {
-    filtered = filtered.filter((m) => m.context?.startsWith(options.context!));
-  }
-
-  const sorted = filtered.sort((a, b) => b.activation - a.activation);
-  for (const m of sorted.slice(0, limit)) {
+  const topByActivation = storage.getTopMemoriesByActivation(
+    limit,
+    options?.type,
+    options?.context
+  );
+  for (const m of topByActivation) {
     seedIds.add(m.id);
   }
 
@@ -61,7 +63,10 @@ export function recall(
       for (const t of targets) {
         candidateIds.add(t.memoryId);
         const existing = graphBoosts.get(t.memoryId) ?? 0;
-        graphBoosts.set(t.memoryId, existing + t.activationBoost * primingWeight);
+        graphBoosts.set(
+          t.memoryId,
+          existing + t.activationBoost * primingWeight
+        );
       }
     }
   }
@@ -71,7 +76,11 @@ export function recall(
     const m = storage.getMemory(id);
     if (!m) continue;
     if (options?.type && m.type !== options.type) continue;
-    if (options?.context && (!m.context || !m.context.startsWith(options.context))) continue;
+    if (
+      options?.context &&
+      (!m.context || !m.context.startsWith(options.context))
+    )
+      continue;
     candidateMap.set(m.id, m);
   }
 
@@ -89,9 +98,13 @@ export function recall(
       const allAssocs = [...assocFrom, ...assocTo];
 
       for (const assoc of allAssocs) {
-        const otherId = assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
+        const otherId =
+          assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
         const fanCount = storage.getFanCount(otherId);
-        const strength = spreadingActivationStrength(config.maxSpreadingActivation, fanCount);
+        const strength = spreadingActivationStrength(
+          config.maxSpreadingActivation,
+          fanCount
+        );
         spreadingSum += assoc.strength * strength;
       }
     }

package/src/core/reconsolidation.ts

@@ -12,7 +12,7 @@ export function reconsolidate(
   storage: EngramStorage,
   memory: Memory,
   recallContext: ReconsolidationContext,
-  config: CognitiveConfig,
+  config: CognitiveConfig
 ): Memory {
   const blendRate = config.reconsolidationBlendRate;
 
@@ -24,7 +24,10 @@ export function reconsolidate(
     memory.context = recallContext.newContext;
   }
 
-  if (recallContext.currentEmotion && recallContext.currentEmotion !== memory.emotion) {
+  if (
+    recallContext.currentEmotion &&
+    recallContext.currentEmotion !== memory.emotion
+  ) {
     const blendedWeight =
       memory.emotionWeight * (1 - blendRate) +
       (recallContext.currentEmotionWeight ?? 0.5) * blendRate;

package/src/core/working-memory.ts

@@ -6,7 +6,7 @@ export function pushFocus(
   storage: EngramStorage,
   content: string,
   config: CognitiveConfig,
-  options?: { memoryRef?: string; now?: number },
+  options?: { memoryRef?: string; now?: number }
 ): { slot: WorkingMemorySlot; evicted: WorkingMemorySlot | null } {
   const now = options?.now ?? Date.now();
   const currentSlots = storage.getWorkingMemory();
@@ -14,7 +14,9 @@ export function pushFocus(
   let evicted: WorkingMemorySlot | null = null;
 
   if (currentSlots.length >= config.workingMemoryCapacity) {
-    const oldest = currentSlots.reduce((min, s) => (s.pushedAt < min.pushedAt ? s : min));
+    const oldest = currentSlots.reduce((min, s) =>
+      s.pushedAt < min.pushedAt ? s : min
+    );
     evicted = oldest;
     storage.removeWorkingMemorySlot(oldest.slot);
   }
@@ -38,7 +40,9 @@ export function popFocus(storage: EngramStorage): WorkingMemorySlot | null {
   const slots = storage.getWorkingMemory();
   if (slots.length === 0) return null;
 
-  const newest = slots.reduce((max, s) => (s.pushedAt > max.pushedAt ? s : max));
+  const newest = slots.reduce((max, s) =>
+    s.pushedAt > max.pushedAt ? s : max
+  );
 
   storage.removeWorkingMemorySlot(newest.slot);
   return newest;
@@ -63,7 +67,7 @@ export function getWorkingMemoryIds(storage: EngramStorage): string[] {
 
 export function focusUtilization(
   storage: EngramStorage,
-  config: CognitiveConfig,
+  config: CognitiveConfig
 ): { used: number; capacity: number; utilization: number } {
   const used = storage.getWorkingMemoryCount();
   return {

package/src/mcp/server.ts

@@ -2,6 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod/v4";
+
 import { EngramEngine } from "../core/engine.ts";
 import { MemoryType, Emotion } from "../core/memory.ts";
 import { handleStore, handleRecall, handleManage } from "./tools.ts";
@@ -22,10 +23,21 @@ server.registerTool(
       z.object({
         action: z.literal("encode"),
         content: z.string().describe("Memory content"),
-        type: z.nativeEnum(MemoryType).optional().describe("Memory type (default: semantic)"),
+        type: z
+          .nativeEnum(MemoryType)
+          .optional()
+          .describe("Memory type (default: semantic)"),
         emotion: z.nativeEnum(Emotion).optional().describe("Emotional tag"),
-        emotionWeight: z.number().min(0).max(1).optional().describe("Emotion intensity 0-1"),
-        context: z.string().optional().describe("Context tag (e.g. project:acme)"),
+        emotionWeight: z
+          .number()
+          .min(0)
+          .max(1)
+          .optional()
+          .describe("Emotion intensity 0-1"),
+        context: z
+          .string()
+          .optional()
+          .describe("Context tag (e.g. project:acme)"),
       }),
       z.object({
         action: z.literal("encode_batch"),
@@ -37,7 +49,7 @@ server.registerTool(
               emotion: z.nativeEnum(Emotion).optional(),
               emotionWeight: z.number().min(0).max(1).optional(),
               context: z.string().optional(),
-            }),
+            })
           )
           .min(1)
           .max(50)
@@ -47,12 +59,20 @@ server.registerTool(
         action: z.literal("reconsolidate"),
         id: z.string().describe("Memory ID to update"),
         newContext: z.string().optional().describe("New context to blend"),
-        currentEmotion: z.nativeEnum(Emotion).optional().describe("Current emotional state"),
-        currentEmotionWeight: z.number().min(0).max(1).optional().describe("Emotion intensity"),
+        currentEmotion: z
+          .nativeEnum(Emotion)
+          .optional()
+          .describe("Current emotional state"),
+        currentEmotionWeight: z
+          .number()
+          .min(0)
+          .max(1)
+          .optional()
+          .describe("Emotion intensity"),
       }),
     ]),
   },
-  async (args) => handleStore(engine, args),
+  async (args) => handleStore(engine, args)
 );
 
 server.registerTool(
@@ -67,9 +87,15 @@ server.registerTool(
         limit: z.number().optional().describe("Max results (default: 5)"),
         type: z.nativeEnum(MemoryType).optional().describe("Filter by type"),
         context: z.string().optional().describe("Filter by context"),
-        associative: z.boolean().optional().describe("Spreading activation (default: true)"),
+        associative: z
+          .boolean()
+          .optional()
+          .describe("Spreading activation (default: true)"),
         verbose: z.boolean().optional().describe("Full fields"),
-        format: z.enum(["full", "content", "ids"]).optional().describe("Response format (default: full)"),
+        format: z
+          .enum(["full", "content", "ids"])
+          .optional()
+          .describe("Response format (default: full)"),
       }),
       z.object({
         action: z.literal("inspect"),
@@ -80,15 +106,21 @@ server.registerTool(
         type: z.nativeEnum(MemoryType).optional().describe("Filter by type"),
         context: z.string().optional().describe("Filter by context prefix"),
         limit: z.number().optional().describe("Max results (default: 20)"),
-        offset: z.number().optional().describe("Skip first N results (default: 0)"),
-        format: z.enum(["full", "content", "ids"]).optional().describe("Response format (default: full)"),
+        offset: z
+          .number()
+          .optional()
+          .describe("Skip first N results (default: 0)"),
+        format: z
+          .enum(["full", "content", "ids"])
+          .optional()
+          .describe("Response format (default: full)"),
       }),
       z.object({
         action: z.literal("stats"),
       }),
     ]),
   },
-  async (args) => handleRecall(engine, args),
+  async (args) => handleRecall(engine, args)
 );
 
 server.registerTool(
@@ -103,7 +135,10 @@ server.registerTool(
       z.object({
         action: z.literal("focus_push"),
         content: z.string().describe("Content to hold in focus"),
-        memoryRef: z.string().optional().describe("Reference to existing memory ID"),
+        memoryRef: z
+          .string()
+          .optional()
+          .describe("Reference to existing memory ID"),
       }),
       z.object({
         action: z.literal("focus_pop"),
@@ -117,13 +152,16 @@ server.registerTool(
       z.object({
         action: z.literal("recall_to_focus"),
         cue: z.string().describe("Recall cue"),
-        limit: z.number().optional().describe("Max memories to load (default: 3)"),
+        limit: z
+          .number()
+          .optional()
+          .describe("Max memories to load (default: 3)"),
         type: z.nativeEnum(MemoryType).optional().describe("Filter by type"),
         context: z.string().optional().describe("Filter by context"),
       }),
     ]),
   },
-  async (args) => handleManage(engine, args),
+  async (args) => handleManage(engine, args)
 );
 
 async function main() {