@cogmem/engram 0.0.0 → 0.2.0

package/README.md

@@ -1,7 +1,5 @@
 # engram
 
-**Human memory for artificial minds.**
-
 > **Note:** This is an experiment in cognitive memory architecture. It's a research prototype, not production software.
 
 Every AI agent today has amnesia. They process, respond, and forget. engram fixes this — not with a smarter key-value store, but with a cognitive memory system modeled on how the human brain actually forms, stores, recalls, and forgets information.
@@ -167,7 +165,7 @@ Add to your MCP client configuration (e.g., Claude Code `settings.json`):
   "mcpServers": {
     "engram": {
       "command": "bunx",
-      "args": ["@cogmem/engram-mcp"]
+      "args": ["-p", "@cogmem/engram", "engram-mcp"]
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogmem/engram",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "description": "Human memory for artificial minds — a cognitive memory system modeled on neuroscience",
   "type": "module",
   "exports": {

package/src/config/defaults.ts

@@ -14,6 +14,9 @@ export interface CognitiveConfig {
   reconsolidationBlendRate: number;
   chunkingSimilarityThreshold: number;
   semanticExtractionThreshold: number;
+  temporalContextWindow: number;
+  recallSpreadingDepth: number;
+  workingMemoryPrimingWeight: number;
   dbPath: string;
 }
 
@@ -33,6 +36,9 @@ export const DEFAULT_CONFIG: CognitiveConfig = {
   reconsolidationBlendRate: 0.1,
   chunkingSimilarityThreshold: 0.6,
   semanticExtractionThreshold: 3,
+  temporalContextWindow: 10,
+  recallSpreadingDepth: 3,
+  workingMemoryPrimingWeight: 0.5,
   dbPath: "~/.engram/memory.db",
 };
 

package/src/core/associations.ts

@@ -1,9 +1,21 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
-import type { Association, AssociationType, Memory } from "./memory.ts";
+import type { Association, AssociationType, Emotion, Memory } from "./memory.ts";
 import { generateId } from "./memory.ts";
 import { extractKeywords } from "./search.ts";
 
+type ArousalTier = "high" | "medium" | "low";
+
+const AROUSAL_TIERS: Record<Emotion, ArousalTier> = {
+  anxiety: "high",
+  surprise: "high",
+  joy: "medium",
+  frustration: "medium",
+  satisfaction: "low",
+  curiosity: "low",
+  neutral: "low",
+};
+
 export function formAssociation(
   storage: EngramStorage,
   sourceId: string,
@@ -36,33 +48,62 @@ export function strengthenAssociation(
 export function formTemporalAssociations(
   storage: EngramStorage,
   memory: Memory,
-  windowMs: number = 300000,
+  config: CognitiveConfig,
   now?: number,
 ): Association[] {
   const currentTime = now ?? Date.now();
-  const allMemories = storage.getAllMemories();
   const formed: Association[] = [];
 
-  for (const other of allMemories) {
-    if (other.id === memory.id) continue;
+  if (memory.context) {
+    const contextMemories = storage
+      .getMemoriesByContext(memory.context, undefined, config.temporalContextWindow)
+      .filter((m) => m.id !== memory.id)
+      .sort((a, b) => b.encodedAt - a.encodedAt);
+
+    for (let i = 0; i < contextMemories.length; i++) {
+      const other = contextMemories[i]!;
+      const positionGap = i + 1;
+      const strength = 1 / (1 + positionGap);
 
-    const timeDiff = Math.abs(memory.encodedAt - other.encodedAt);
-    if (timeDiff <= windowMs) {
       const existing = storage.getAssociationsFrom(memory.id);
       const alreadyLinked = existing.some((a) => a.targetId === other.id);
       if (alreadyLinked) continue;
 
-      const strength = 1 - timeDiff / windowMs;
       const assoc = formAssociation(
         storage,
         memory.id,
         other.id,
         "temporal",
-        Math.max(0.1, strength * 0.8),
+        Math.max(0.1, strength),
         currentTime,
       );
       formed.push(assoc);
     }
+  } else {
+    const windowMs = 300000;
+    const allMemories = storage.getAllMemories();
+
+    for (const other of allMemories) {
+      if (other.id === memory.id) continue;
+
+      const timeDiff = Math.abs(memory.encodedAt - other.encodedAt);
+      if (timeDiff <= windowMs) {
+        const existing = storage.getAssociationsFrom(memory.id);
+        const alreadyLinked = existing.some((a) => a.targetId === other.id);
+        if (alreadyLinked) continue;
+
+        const strength = 1 - timeDiff / windowMs;
+        const assoc = formAssociation(
+          storage,
+          memory.id,
+          other.id,
+          "temporal",
+          Math.max(0.1, strength * 0.8),
+          currentTime,
+        );
+        formed.push(assoc);
+      }
+    }
   }
 
   return formed;
@@ -111,6 +152,86 @@ export function formSemanticAssociations(
   return formed;
 }
 
+export function formEmotionalAssociations(
+  storage: EngramStorage,
+  memory: Memory,
+  now?: number,
+): Association[] {
+  if (memory.emotion === "neutral" || memory.emotionWeight <= 0.3) return [];
+
+  const currentTime = now ?? Date.now();
+  const allMemories = storage.getAllMemories();
+  const formed: Association[] = [];
+  const memoryTier = AROUSAL_TIERS[memory.emotion];
+
+  for (const other of allMemories) {
+    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;
+
+    let strength: number;
+    if (memory.emotion === other.emotion) {
+      strength = 1 - Math.abs(memory.emotionWeight - other.emotionWeight);
+    } else if (AROUSAL_TIERS[other.emotion] === memoryTier) {
+      strength = 0.3 * (1 - Math.abs(memory.emotionWeight - other.emotionWeight));
+    } else {
+      continue;
+    }
+
+    if (strength < 0.1) continue;
+
+    const assoc = formAssociation(storage, memory.id, other.id, "emotional", strength, currentTime);
+    formed.push(assoc);
+  }
+
+  return formed;
+}
+
+export function formCausalAssociations(
+  storage: EngramStorage,
+  memory: Memory,
+  config: CognitiveConfig,
+  now?: number,
+): Association[] {
+  if (!memory.context) return [];
+
+  const currentTime = now ?? Date.now();
+  const contextMemories = storage
+    .getMemoriesByContext(memory.context, undefined, config.temporalContextWindow)
+    .filter((m) => m.id !== memory.id && m.encodedAt < memory.encodedAt)
+    .sort((a, b) => b.encodedAt - a.encodedAt);
+
+  const formed: Association[] = [];
+
+  for (let i = 0; i < contextMemories.length; i++) {
+    const source = contextMemories[i]!;
+    const sequenceGap = i + 1;
+    const strength = 1 / (1 + sequenceGap);
+
+    const existing = storage.getAssociations(memory.id);
+    const alreadyLinked = existing.some(
+      (a) =>
+        a.type === "causal" &&
+        ((a.sourceId === source.id && a.targetId === memory.id) ||
+          (a.sourceId === memory.id && a.targetId === source.id)),
+    );
+    if (alreadyLinked) continue;
+
+    const assoc = formAssociation(storage, source.id, memory.id, "causal", strength, currentTime);
+    formed.push(assoc);
+  }
+
+  return formed;
+}
+
 export function recordCoRecall(
   storage: EngramStorage,
   memoryIds: string[],
@@ -147,7 +268,7 @@ export function getSpreadingActivationTargets(
   storage: EngramStorage,
   sourceId: string,
   config: CognitiveConfig,
-  maxDepth: number = 2,
+  maxDepth: number = config.recallSpreadingDepth,
 ): { memoryId: string; activationBoost: number; depth: number }[] {
   const visited = new Set<string>([sourceId]);
   const results: { memoryId: string; activationBoost: number; depth: number }[] = [];

package/src/core/consolidation.ts

@@ -3,7 +3,12 @@ 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 } from "./associations.ts";
+import {
+  formSemanticAssociations,
+  formTemporalAssociations,
+  formEmotionalAssociations,
+  formCausalAssociations,
+} from "./associations.ts";
 import { encode } from "./encoder.ts";
 import { extractKeywords, tokenize } from "./search.ts";
 
@@ -63,10 +68,12 @@ export function consolidate(
 
   const remainingMemories = storage.getAllMemories();
   for (const memory of remainingMemories) {
-    const temporalAssocs = formTemporalAssociations(storage, memory, 300000, currentTime);
+    const temporalAssocs = formTemporalAssociations(storage, memory, config, currentTime);
     const semanticAssocs = formSemanticAssociations(storage, memory, currentTime);
+    const emotionalAssocs = formEmotionalAssociations(storage, memory, currentTime);
+    const causalAssocs = formCausalAssociations(storage, memory, config, currentTime);
 
-    for (const assoc of [...temporalAssocs, ...semanticAssocs]) {
+    for (const assoc of [...temporalAssocs, ...semanticAssocs, ...emotionalAssocs, ...causalAssocs]) {
       result.associationsDiscovered++;
       result.discoveredAssociationPairs.push([assoc.sourceId, assoc.targetId]);
     }

package/src/core/encoder.ts

@@ -4,6 +4,7 @@ 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";
 
 export function encode(
   storage: EngramStorage,
@@ -43,5 +44,8 @@ export function encode(
     storage.logAccess(id, "encode", currentTime);
   });
 
+  formEmotionalAssociations(storage, memory, currentTime);
+  formCausalAssociations(storage, memory, config, currentTime);
+
   return memory;
 }

package/src/core/memory.ts

@@ -29,6 +29,8 @@ export const AssociationType = {
   Temporal: "temporal",
   Semantic: "semantic",
   CoRecall: "co-recall",
+  Emotional: "emotional",
+  Causal: "causal",
 } as const;
 export type AssociationType = (typeof AssociationType)[keyof typeof AssociationType];
 

package/src/core/recall.ts

@@ -2,6 +2,8 @@ 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 { getSpreadingActivationTargets } from "./associations.ts";
+import { getWorkingMemoryIds } from "./working-memory.ts";
 
 export function recall(
   storage: EngramStorage,
@@ -20,15 +22,17 @@ export function recall(
   const limit = options?.limit ?? 10;
   const associative = options?.associative ?? true;
 
-  const candidateMap = new Map<string, Memory>();
+  const seedIds = new Set<string>();
+
+  const wmIds = getWorkingMemoryIds(storage);
+  for (const id of wmIds) seedIds.add(id);
 
   const ftsIds = storage.searchFTS(cue, limit * 2);
-  for (const id of ftsIds) {
-    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;
-    candidateMap.set(m.id, m);
+  for (const id of ftsIds) seedIds.add(id);
+
+  if (options?.context) {
+    const contextMatches = storage.getMemoriesByContext(options.context, options?.type, limit * 2);
+    for (const m of contextMatches) seedIds.add(m.id);
   }
 
   const allCandidates = options?.type
@@ -42,6 +46,32 @@ export function recall(
 
   const sorted = filtered.sort((a, b) => b.activation - a.activation);
   for (const m of sorted.slice(0, limit)) {
+    seedIds.add(m.id);
+  }
+
+  const candidateIds = new Set<string>(seedIds);
+  const graphBoosts = new Map<string, number>();
+
+  if (associative) {
+    for (const seedId of seedIds) {
+      const targets = getSpreadingActivationTargets(storage, seedId, config);
+      const isWmSeed = wmIds.includes(seedId);
+      const primingWeight = isWmSeed ? config.workingMemoryPrimingWeight : 1.0;
+
+      for (const t of targets) {
+        candidateIds.add(t.memoryId);
+        const existing = graphBoosts.get(t.memoryId) ?? 0;
+        graphBoosts.set(t.memoryId, existing + t.activationBoost * primingWeight);
+      }
+    }
+  }
+
+  const candidateMap = new Map<string, Memory>();
+  for (const id of candidateIds) {
+    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;
     candidateMap.set(m.id, m);
   }
 
@@ -52,8 +82,8 @@ export function recall(
   for (const memory of candidateMap.values()) {
     const timestamps = storage.getAccessTimestamps(memory.id);
 
-    let spreadingSum = 0;
-    if (associative) {
+    let spreadingSum = graphBoosts.get(memory.id) ?? 0;
+    if (associative && spreadingSum === 0) {
       const assocFrom = storage.getAssociationsFrom(memory.id);
       const assocTo = storage.getAssociationsTo(memory.id);
       const allAssocs = [...assocFrom, ...assocTo];

package/src/core/working-memory.ts

@@ -54,6 +54,13 @@ export function clearFocus(storage: EngramStorage): number {
   return count;
 }
 
+export function getWorkingMemoryIds(storage: EngramStorage): string[] {
+  return storage
+    .getWorkingMemory()
+    .filter((s) => s.memoryRef !== null)
+    .map((s) => s.memoryRef!);
+}
+
 export function focusUtilization(
   storage: EngramStorage,
   config: CognitiveConfig,

package/src/index.ts

@@ -10,11 +10,14 @@ export {
   getFocus,
   clearFocus,
   focusUtilization,
+  getWorkingMemoryIds,
 } from "./core/working-memory.ts";
 export {
   formAssociation,
   formTemporalAssociations,
   formSemanticAssociations,
+  formEmotionalAssociations,
+  formCausalAssociations,
   recordCoRecall,
   getSpreadingActivationTargets,
 } from "./core/associations.ts";

package/src/mcp/server.ts

@@ -17,11 +17,7 @@ server.registerTool(
   "memory_store",
   {
     title: "Store Memory",
-    description: `Store memories. Requires "action" field.
-
-Actions:
-- action:"encode" — Create a new memory. Params: content (required), type? (semantic|episodic|procedural, default semantic), emotion? (neutral|curiosity|surprise|anxiety|satisfaction|frustration|confusion|excitement|calm|urgency), emotionWeight? (0-1), context? (e.g. "project:acme")
-- action:"reconsolidate" — Update an existing memory during recall. Params: id (required), newContext?, currentEmotion?, currentEmotionWeight?`,
+    description: `Actions: encode(content) — store memory | encode_batch(memories[]) — store multiple | reconsolidate(id) — update during recall. Optional: type, emotion, emotionWeight, context.`,
     inputSchema: z.discriminatedUnion("action", [
       z.object({
         action: z.literal("encode"),
@@ -31,6 +27,22 @@ Actions:
         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"),
+        memories: z
+          .array(
+            z.object({
+              content: z.string(),
+              type: z.nativeEnum(MemoryType).optional(),
+              emotion: z.nativeEnum(Emotion).optional(),
+              emotionWeight: z.number().min(0).max(1).optional(),
+              context: z.string().optional(),
+            }),
+          )
+          .min(1)
+          .max(50)
+          .describe("Array of memories to encode"),
+      }),
       z.object({
         action: z.literal("reconsolidate"),
         id: z.string().describe("Memory ID to update"),
@@ -47,26 +59,30 @@ server.registerTool(
   "memory_recall",
   {
     title: "Recall Memories",
-    description: `Retrieve memories. Requires "action" field.
-
-Actions:
-- action:"recall" — Cue-based retrieval with spreading activation. Params: cue (required), limit? (default 5), type? (semantic|episodic|procedural), context?, associative? (default true), verbose?
-- action:"inspect" — Examine a specific memory's full lifecycle. Params: id (required, full ID or prefix)
-- action:"stats" — Memory system overview (counts, working memory usage, last consolidation). No extra params.`,
+    description: `Actions: recall(cue) — cue-based retrieval | list — browse without activation effects | inspect(id) — full lifecycle | stats — system overview. Optional: limit, type, context, format, verbose.`,
     inputSchema: z.discriminatedUnion("action", [
       z.object({
-        action: z.literal("recall").optional().default("recall"),
+        action: z.literal("recall"),
         cue: z.string().describe("Recall cue"),
         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)"),
         verbose: z.boolean().optional().describe("Full fields"),
+        format: z.enum(["full", "content", "ids"]).optional().describe("Response format (default: full)"),
       }),
       z.object({
         action: z.literal("inspect"),
         id: z.string().describe("Memory ID or prefix"),
       }),
+      z.object({
+        action: z.literal("list"),
+        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)"),
+      }),
       z.object({
         action: z.literal("stats"),
       }),
@@ -79,14 +95,7 @@ server.registerTool(
   "memory_manage",
   {
     title: "Manage Memory",
-    description: `Memory maintenance. Requires "action" field.
-
-Actions:
-- action:"consolidate" — Run sleep cycle (strengthen, prune, extract patterns, discover links). No extra params.
-- action:"focus_push" — Push to working memory buffer. Params: content (required), memoryRef?
-- action:"focus_pop" — Remove most recent item from working memory. No extra params.
-- action:"focus_get" — View current working memory contents. No extra params.
-- action:"focus_clear" — Clear all working memory. No extra params.`,
+    description: `Actions: consolidate — run sleep cycle | recall_to_focus(cue) — recall and load to working memory | focus_push(content) — push to buffer | focus_pop — pop newest | focus_get — view buffer | focus_clear — empty buffer.`,
     inputSchema: z.discriminatedUnion("action", [
       z.object({
         action: z.literal("consolidate"),
@@ -105,6 +114,13 @@ Actions:
       z.object({
         action: z.literal("focus_clear"),
       }),
+      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)"),
+        type: z.nativeEnum(MemoryType).optional().describe("Filter by type"),
+        context: z.string().optional().describe("Filter by context"),
+      }),
     ]),
   },
   async (args) => handleManage(engine, args),

package/src/mcp/tools.ts

@@ -1,7 +1,7 @@
 import type { CognitiveConfig } from "../config/defaults.ts";
 import type { EngramStorage } from "../storage/sqlite.ts";
 import type { EngramEngine } from "../core/engine.ts";
-import { isValidMemoryType } from "../core/memory.ts";
+import { isValidMemoryType, MemoryType, Emotion } from "../core/memory.ts";
 import { encode } from "../core/encoder.ts";
 import { recall } from "../core/recall.ts";
 import {
@@ -38,6 +38,8 @@ export function handleStore(
   switch (args.action) {
     case "encode":
       return handleEncode(engine.storage, engine.config, args as any, engine.projectContext);
+    case "encode_batch":
+      return handleEncodeBatch(engine.storage, engine.config, args as any, engine.projectContext);
     case "reconsolidate":
       return handleReconsolidate(engine.storage, engine.config, args as any);
     default:
@@ -55,6 +57,8 @@ export function handleRecall(
       return handleRecallQuery(engine.storage, engine.config, args as any, engine.projectContext);
     case "inspect":
       return handleInspect(engine.storage, args as any);
+    case "list":
+      return handleList(engine.storage, args as any, engine.projectContext);
     case "stats":
       return handleStats(engine.storage, engine.config);
     default:
@@ -77,6 +81,8 @@ export function handleManage(
       return handleFocusGet(engine.storage, engine.config);
     case "focus_clear":
       return handleFocusClear(engine.storage);
+    case "recall_to_focus":
+      return handleRecallToFocus(engine.storage, engine.config, args as any, engine.projectContext);
     default:
       return errorResult(`Unknown manage action: ${args.action}`);
   }
@@ -96,12 +102,12 @@ function handleEncode(
 ): ToolResult {
   const typeStr = args.type ?? "semantic";
   if (!isValidMemoryType(typeStr)) {
-    return errorResult(`Invalid type: ${typeStr}. Must be episodic, semantic, or procedural.`);
+    return errorResult(`Invalid type '${typeStr}'. Valid: ${Object.values(MemoryType).join(", ")}`);
   }
 
   const emotionStr = args.emotion ?? "neutral";
   if (!isValidEmotion(emotionStr)) {
-    return errorResult(`Invalid emotion: ${emotionStr}.`);
+    return errorResult(`Invalid emotion '${emotionStr}'. Valid: ${Object.values(Emotion).join(", ")}`);
   }
 
   const memory = encode(
@@ -116,17 +122,58 @@ function handleEncode(
     config,
   );
 
-  return textResult(
-    JSON.stringify({
-      id: memory.id,
-      type: memory.type,
-      content: memory.content,
-      activation: memory.activation,
-      emotion: memory.emotion,
-      emotionWeight: memory.emotionWeight,
-      context: memory.context,
-    }),
-  );
+  return textResult(JSON.stringify({ id: memory.id }));
+}
+
+function handleEncodeBatch(
+  storage: EngramStorage,
+  config: CognitiveConfig,
+  args: {
+    memories: Array<{
+      content: string;
+      type?: string;
+      emotion?: string;
+      emotionWeight?: number;
+      context?: string;
+    }>;
+  },
+  defaultContext?: string | null,
+): ToolResult {
+  const ids: string[] = [];
+  const errors: string[] = [];
+
+  storage.transaction(() => {
+    for (let i = 0; i < args.memories.length; i++) {
+      const m = args.memories[i]!;
+      const typeStr = m.type ?? "semantic";
+      if (!isValidMemoryType(typeStr)) {
+        errors.push(`[${i}] Invalid type '${typeStr}'`);
+        continue;
+      }
+      const emotionStr = m.emotion ?? "neutral";
+      if (!isValidEmotion(emotionStr)) {
+        errors.push(`[${i}] Invalid emotion '${emotionStr}'`);
+        continue;
+      }
+      const memory = encode(
+        storage,
+        {
+          content: m.content,
+          type: typeStr,
+          emotion: emotionStr,
+          emotionWeight: m.emotionWeight,
+          context: m.context ?? defaultContext ?? undefined,
+        },
+        config,
+      );
+      ids.push(memory.id);
+    }
+  });
+
+  if (errors.length > 0) {
+    return textResult(JSON.stringify({ stored: ids, errors }));
+  }
+  return textResult(JSON.stringify({ stored: ids }));
 }
 
 function handleRecallQuery(
@@ -139,6 +186,7 @@ function handleRecallQuery(
     context?: string;
     associative?: boolean;
     verbose?: boolean;
+    format?: "full" | "content" | "ids";
   },
   defaultContext?: string | null,
 ): ToolResult {
@@ -155,6 +203,15 @@ function handleRecallQuery(
     return textResult("No memories found above retrieval threshold.");
   }
 
+  const format = args.format ?? "full";
+
+  if (format === "ids") {
+    return textResult(JSON.stringify(results.map((r) => r.memory.id)));
+  }
+  if (format === "content") {
+    return textResult(JSON.stringify(results.map((r) => r.memory.content)));
+  }
+
   const formatted = args.verbose
     ? results.map((r) => ({
         id: r.memory.id,
@@ -178,6 +235,56 @@ function handleRecallQuery(
   return textResult(JSON.stringify(formatted));
 }
 
+function handleList(
+  storage: EngramStorage,
+  args: {
+    type?: string;
+    context?: string;
+    limit?: number;
+    offset?: number;
+    format?: "full" | "content" | "ids";
+  },
+  defaultContext?: string | null,
+): ToolResult {
+  const limit = args.limit ?? 20;
+  const offset = args.offset ?? 0;
+  const typeFilter = args.type && isValidMemoryType(args.type) ? args.type : undefined;
+  const context = args.context ?? defaultContext ?? undefined;
+
+  let results;
+  if (context) {
+    results = storage.getMemoriesByContext(context, typeFilter, limit + offset);
+  } else {
+    results = storage.getAllMemories(typeFilter).slice(0, limit + offset);
+  }
+  results = results.slice(offset, offset + limit);
+
+  if (results.length === 0) {
+    return textResult("No memories found.");
+  }
+
+  const format = args.format ?? "full";
+
+  if (format === "ids") {
+    return textResult(JSON.stringify(results.map((m) => m.id)));
+  }
+  if (format === "content") {
+    return textResult(JSON.stringify(results.map((m) => m.content)));
+  }
+
+  return textResult(
+    JSON.stringify(
+      results.map((m) => ({
+        id: m.id,
+        content: m.content,
+        type: m.type,
+        context: m.context,
+        activation: m.activation,
+      })),
+    ),
+  );
+}
+
 function handleFocusPush(
   storage: EngramStorage,
   config: CognitiveConfig,
@@ -222,6 +329,34 @@ function handleFocusClear(storage: EngramStorage): ToolResult {
   return textResult(`Cleared ${count} items from working memory.`);
 }
 
+function handleRecallToFocus(
+  storage: EngramStorage,
+  config: CognitiveConfig,
+  args: { cue: string; limit?: number; type?: string; context?: string },
+  defaultContext?: string | null,
+): ToolResult {
+  const typeFilter = args.type && isValidMemoryType(args.type) ? args.type : undefined;
+  const limit = args.limit ?? 3;
+
+  const results = recall(storage, args.cue, config, {
+    limit,
+    type: typeFilter,
+    context: args.context ?? defaultContext ?? undefined,
+    associative: true,
+  });
+
+  const loaded: string[] = [];
+  for (const r of results) {
+    pushFocus(storage, r.memory.content, config, {
+      memoryRef: r.memory.id,
+    });
+    loaded.push(r.memory.id);
+  }
+
+  const { used, capacity } = focusUtilization(storage, config);
+  return textResult(JSON.stringify({ loaded, focus: { used, capacity } }));
+}
+
 function handleConsolidate(storage: EngramStorage, config: CognitiveConfig): ToolResult {
   const result = consolidate(storage, config);
   const chunks = discoverChunks(storage, config);
@@ -324,9 +459,6 @@ function handleReconsolidate(
   return textResult(
     JSON.stringify({
       id: updated.id,
-      content: updated.content,
-      emotion: updated.emotion,
-      emotionWeight: updated.emotionWeight,
       context: updated.context,
       reconsolidationCount: updated.reconsolidationCount,
     }),