@memstack/core 0.2.0 → 0.5.0

package/dist/index.cjs

@@ -47,6 +47,10 @@ var Summarizer = class {
     if (memories.length === 0) {
       throw new MemStackError("VALIDATION_ERROR", "No memories to summarize");
     }
+    const chunkSize = options.chunkSize ?? 50;
+    if (memories.length > chunkSize) {
+      return this._summarizeChunked(memories, options, promptOverride);
+    }
     const sorted = [...memories].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
     const memoryTexts = sorted.map((m) => `[${m.createdAt.toISOString()}] ${m.content}`);
     const system = promptOverride ?? this.defaultPrompt;
@@ -66,6 +70,76 @@ var Summarizer = class {
       );
     }
   }
+  async _summarizeChunked(memories, options, promptOverride) {
+    const chunkSize = options.chunkSize ?? 50;
+    const sorted = [...memories].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    const chunks = [];
+    for (let i = 0; i < sorted.length; i += chunkSize) {
+      chunks.push(sorted.slice(i, i + chunkSize));
+    }
+    let totalTokens = 0;
+    const chunkSummaries = [];
+    for (const chunk of chunks) {
+      const memoryTexts = chunk.map((m) => `[${m.createdAt.toISOString()}] ${m.content}`);
+      const system = promptOverride ?? this.defaultPrompt;
+      const user = memoryTexts.join("\n\n");
+      try {
+        const response = await this.llm.complete({ system, user });
+        chunkSummaries.push(response.text.trim());
+        totalTokens += response.tokens.total;
+      } catch (err) {
+        if (err instanceof MemStackError) throw err;
+        throw new MemStackError(
+          "LLM_ERROR",
+          `Chunked summarization failed: ${err instanceof Error ? err.message : String(err)}`,
+          { retryable: true, details: { cause: err instanceof Error ? err.message : String(err) } }
+        );
+      }
+    }
+    if (chunkSummaries.length === 1) {
+      return { summaryContent: chunkSummaries[0], tokenCount: totalTokens };
+    }
+    const summaryMemories = chunkSummaries.map((content, i) => ({
+      id: `_chunk_summary_${i}`,
+      actorId: sorted[0].actorId,
+      memoryType: "summary",
+      content,
+      importance: 0.5,
+      emotionalValence: 0,
+      tags: ["summary"],
+      createdAt: sorted[sorted.length - 1].createdAt
+    }));
+    const merged = await this._summarizeChunked(summaryMemories, options, promptOverride);
+    return {
+      summaryContent: merged.summaryContent,
+      tokenCount: totalTokens + merged.tokenCount
+    };
+  }
+  async *summarizeStream(memories, options = {}, promptOverride) {
+    if (memories.length === 0) {
+      throw new MemStackError("VALIDATION_ERROR", "No memories to summarize");
+    }
+    if (!this.llm.completeStream) {
+      const result = await this.summarize(memories, options, promptOverride);
+      yield { chunk: result.summaryContent, text: result.summaryContent };
+      return;
+    }
+    const chunkSize = options.chunkSize ?? 50;
+    let toSummarize = memories;
+    if (memories.length > chunkSize) {
+      const chunked = await this._summarizeChunked(memories, options, promptOverride);
+      toSummarize = [{ id: "_chunked", actorId: "summarizer", memoryType: "summary", content: chunked.summaryContent, importance: 0.5, emotionalValence: 0, tags: [], createdAt: /* @__PURE__ */ new Date() }];
+    }
+    const sorted = [...toSummarize].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    const memoryTexts = sorted.map((m) => `[${m.createdAt.toISOString()}] ${m.content}`);
+    const system = promptOverride ?? this.defaultPrompt;
+    const user = memoryTexts.join("\n\n");
+    let fullText = "";
+    for await (const chunk of this.llm.completeStream({ system, user })) {
+      fullText += chunk.text;
+      yield { chunk: chunk.text, text: fullText };
+    }
+  }
 };
 
 // src/memory/Pruner.ts
@@ -83,6 +157,8 @@ var Pruner = class {
         return this.removeByType(memories, strategy);
       case "custom":
         return this.removeCustom(memories, strategy);
+      case "compose":
+        return this.keepCompose(memories, strategy);
       default:
         return memories;
     }
@@ -124,21 +200,36 @@ var Pruner = class {
     if (!strategy.shouldRemove) return memories;
     return memories.filter((m) => !strategy.shouldRemove(m));
   }
+  /** Apply sub-strategies cumulatively: kept memories must pass ALL. */
+  keepCompose(memories, strategy) {
+    if (!strategy.strategies || strategy.strategies.length === 0) {
+      return memories;
+    }
+    let kept = memories;
+    for (const sub of strategy.strategies) {
+      kept = this.execute(kept, sub);
+    }
+    return kept;
+  }
 };
 
 // src/memory/ContextCompiler.ts
 var ContextCompiler = class {
-  /**
-   * Estimate token count from text using a blended heuristic.
-   * Combines word-based (prose) and character-based (code/json) estimates,
-   * taking the max to handle arbitrary content types.
-   */
-  estimateTokens(text) {
+  tokenCounter;
+  importantRatio;
+  constructor(tokenCounter, importantRatio) {
+    this.tokenCounter = tokenCounter ?? this._heuristicTokens.bind(this);
+    this.importantRatio = importantRatio ?? 0.6;
+  }
+  _heuristicTokens(text) {
     const charEst = Math.ceil(text.length / 4);
     const words = text.split(/\s+/).filter((w) => w.length > 0);
     const wordEst = Math.ceil(words.length * 1.3);
     return Math.max(charEst, Math.max(1, wordEst));
   }
+  estimateTokens(text) {
+    return this.tokenCounter(text);
+  }
   /**
    * Truncate text to fit within a token budget, preserving whole words.
    * Appends "..." when content is cut. Falls back to character-based
@@ -175,6 +266,15 @@ var ContextCompiler = class {
     );
     const { recentMemories, importantMemories, systemPrompt } = this.assembleTokenBudgeted(sortedRecent, sortedImportant, maxTokens);
     const tokenEstimate = this.estimateTokens(systemPrompt);
+    if (options.format === "messages") {
+      return {
+        systemPrompt,
+        messages: [{ role: "system", content: systemPrompt }],
+        recentMemories,
+        importantMemories,
+        tokenEstimate
+      };
+    }
     return { systemPrompt, recentMemories, importantMemories, tokenEstimate };
   }
   assembleTokenBudgeted(recent, important, maxTokens) {
@@ -189,7 +289,7 @@ var ContextCompiler = class {
 `;
       const overhead = this.estimateTokens(prefix + suffix);
       let tokens = this.estimateTokens(m.content) + overhead;
-      const remaining = Math.floor(maxTokens * 0.6) - usedTokens;
+      const remaining = Math.floor(maxTokens * this.importantRatio) - usedTokens;
       if (remaining <= 0) break;
       if (tokens > remaining) {
         const contentBudget = Math.max(0, remaining - overhead);
@@ -260,7 +360,6 @@ var ContextCompiler = class {
 };
 
 // src/memory/MemoryStore.ts
-var EMBEDDING_BATCH_SIZE = 2048;
 var MemoryStore = class {
   storage;
   embedding;
@@ -268,6 +367,15 @@ var MemoryStore = class {
   pruner;
   compiler;
   embedOnStore;
+  limits;
+  contentHashIndex = null;
+  initialized = false;
+  async _ensureInit() {
+    if (!this.initialized) {
+      await this.storage.initialize();
+      this.initialized = true;
+    }
+  }
   constructor(config) {
     this.storage = config.storage;
     this.embedding = config.embedding;
@@ -276,31 +384,43 @@ var MemoryStore = class {
       this.summarizer = new Summarizer(config.llm, config.summarizationPrompt);
     }
     this.pruner = new Pruner();
-    this.compiler = new ContextCompiler();
+    this.compiler = new ContextCompiler(config.tokenCounter, config.contextImportantRatio);
+    this.limits = {
+      dedupScan: 1e3,
+      contextScan: 50,
+      summarizeScan: 1e3,
+      pruneScan: 1e4,
+      exportScan: 1e5,
+      purgeScan: 1e5,
+      ...config.limits
+    };
   }
   async store(input) {
+    await this._ensureInit();
     if (input.onConflict === "append") {
+      await this._ensureHashIndex();
       const hash = this._hashContent(input.actorId, input.content);
-      const existing = await this.storage.retrieve({ actorId: input.actorId, limit: 1e3 });
-      const match = existing.find(
-        (m) => this._hashContent(m.actorId, m.content) === hash
-      );
-      if (match) {
-        const mergedTags = [.../* @__PURE__ */ new Set([...match.tags ?? [], ...input.tags ?? []])];
-        const updated = await this.storage.store({
-          id: match.id,
-          actorId: match.actorId,
-          content: match.content,
-          memoryType: match.memoryType,
-          importance: input.importance ?? match.importance,
-          emotionalValence: input.emotionalValence ?? match.emotionalValence,
-          tags: mergedTags,
-          embedding: match.embedding,
-          sourceId: input.sourceId ?? match.sourceId,
-          metadata: { ...match.metadata, ...input.metadata },
-          expiresAt: input.expiresAt ?? match.expiresAt
-        });
-        return updated;
+      const existingId = this.contentHashIndex.get(hash);
+      if (existingId) {
+        const match = await this.storage.get(existingId);
+        if (match) {
+          const mergedTags = [.../* @__PURE__ */ new Set([...match.tags ?? [], ...input.tags ?? []])];
+          const updated = await this.storage.store({
+            id: match.id,
+            actorId: match.actorId,
+            content: match.content,
+            memoryType: match.memoryType,
+            importance: input.importance ?? match.importance,
+            emotionalValence: input.emotionalValence ?? match.emotionalValence,
+            tags: mergedTags,
+            embedding: match.embedding,
+            sourceId: input.sourceId ?? match.sourceId,
+            metadata: { ...match.metadata, ...input.metadata },
+            expiresAt: input.expiresAt ?? match.expiresAt
+          });
+          this.contentHashIndex.set(hash, updated.id);
+          return updated;
+        }
       }
     }
     let withEmbedding = input;
@@ -309,9 +429,15 @@ var MemoryStore = class {
       withEmbedding = { ...input, embedding: embeddings[0] };
     }
     const { onConflict: _, ...clean } = withEmbedding;
-    return this.storage.store(clean);
+    const memory = await this.storage.store(clean);
+    if (this.contentHashIndex !== null) {
+      const hash = this._hashContent(memory.actorId, memory.content);
+      this.contentHashIndex.set(hash, memory.id);
+    }
+    return memory;
   }
   async storeBatch(inputs) {
+    await this._ensureInit();
     const appendInputs = inputs.filter((i) => i.onConflict === "append");
     const normalInputs = inputs.filter((i) => i.onConflict !== "append");
     const results = [];
@@ -319,74 +445,90 @@ var MemoryStore = class {
       results.push(await this.store(input));
     }
     if (normalInputs.length === 0) return results;
+    let stored;
     if (this.embedding && this.embedOnStore) {
-      for (let i = 0; i < normalInputs.length; i += EMBEDDING_BATCH_SIZE) {
-        const batch = normalInputs.slice(i, i + EMBEDDING_BATCH_SIZE);
+      const enrichedResults = [];
+      const batchSize = this.embedding.maxBatchSize ?? 2048;
+      for (let i = 0; i < normalInputs.length; i += batchSize) {
+        const batch = normalInputs.slice(i, i + batchSize);
         const texts = batch.map((inp) => inp.content);
         const embeddings = await this.embedding.embed(texts);
         const enriched = batch.map((input, j) => ({ ...input, embedding: embeddings[j] }));
-        const stored = await this.storage.storeBatch(enriched);
-        results.push(...stored);
+        const batchResults = await this.storage.storeBatch(enriched);
+        enrichedResults.push(...batchResults);
       }
+      stored = enrichedResults;
     } else {
-      const stored = await this.storage.storeBatch(normalInputs);
-      results.push(...stored);
+      stored = await this.storage.storeBatch(normalInputs);
+    }
+    if (this.contentHashIndex !== null) {
+      for (const mem of stored) {
+        const hash = this._hashContent(mem.actorId, mem.content);
+        this.contentHashIndex.set(hash, mem.id);
+      }
     }
+    results.push(...stored);
     return results;
   }
   async get(id) {
+    await this._ensureInit();
     return this.storage.get(id);
   }
   async delete(id) {
+    await this._ensureInit();
     return this.storage.delete(id);
   }
   async deleteMany(ids) {
+    await this._ensureInit();
     return this.storage.deleteMany(ids);
   }
   async touch(id) {
+    await this._ensureInit();
     const memory = await this.storage.get(id);
     if (!memory) throw notFound("Memory", id);
     if (this.storage.touch) {
       return this.storage.touch(id);
     }
-    await this.storage.delete(id);
-    await this.storage.store({
-      actorId: memory.actorId,
-      content: memory.content,
-      memoryType: memory.memoryType,
-      importance: memory.importance,
-      emotionalValence: memory.emotionalValence,
-      tags: memory.tags,
-      embedding: memory.embedding,
-      sourceId: memory.sourceId,
-      metadata: memory.metadata,
-      expiresAt: memory.expiresAt
-    });
   }
   async count(filter) {
+    await this._ensureInit();
     return this.storage.count(filter);
   }
   async retrieve(query) {
+    await this._ensureInit();
     let embedding;
     if (this.embedding && query.query && (query.strategy === "semantic" || query.strategy === "hybrid")) {
       const vecs = await this.embedding.embed([query.query]);
       embedding = vecs[0];
     }
-    return this.storage.retrieve(query, embedding);
+    let results = await this.storage.retrieve(query, embedding);
+    if (query.createdAfter) {
+      results = results.filter((m) => m.createdAt >= query.createdAfter);
+    }
+    if (query.createdBefore) {
+      results = results.filter((m) => m.createdAt <= query.createdBefore);
+    }
+    return results;
   }
   async compileContext(options) {
+    await this._ensureInit();
     const maxTokens = options.maxTokens ?? 2e3;
-    const memories = await this.storage.retrieve({ actorId: options.actorId, limit: 50 });
+    const memories = await this.storage.retrieve({
+      actorId: options.actorId,
+      limit: this.limits.contextScan,
+      strategy: options.retrieveStrategy
+    });
     return this.compiler.compile(memories, { ...options, maxTokens });
   }
   async summarize(options, onError) {
+    await this._ensureInit();
     if (!this.summarizer) {
       throw validationError("No LLM configured for summarization");
     }
     const allMemories = await this.storage.retrieve({
       actorId: options.actorId,
       memoryTypes: options.memoryTypes ?? ["interaction"],
-      limit: 1e3,
+      limit: this.limits.summarizeScan,
       strategy: "recent"
     });
     let toSummarize = allMemories;
@@ -406,7 +548,7 @@ var MemoryStore = class {
     }
     let summaryContent;
     try {
-      const result = await this.summarizer.summarize(toSummarize, options);
+      const result = await this.summarizer.summarize(toSummarize, options, options.prompt);
       summaryContent = result.summaryContent;
     } catch (err) {
       onError?.(err instanceof Error ? err : new Error(String(err)));
@@ -428,8 +570,37 @@ var MemoryStore = class {
     }
     return { summary, deletedCount };
   }
+  async *summarizeStream(options) {
+    await this._ensureInit();
+    if (!this.summarizer) {
+      throw validationError("No LLM configured for summarization");
+    }
+    const allMemories = await this.storage.retrieve({
+      actorId: options.actorId,
+      memoryTypes: options.memoryTypes ?? ["interaction"],
+      limit: this.limits.summarizeScan,
+      strategy: "recent"
+    });
+    let toSummarize = allMemories;
+    if (options.olderThan) {
+      toSummarize = toSummarize.filter((m) => m.createdAt < options.olderThan);
+    }
+    if (options.skipMostRecent) {
+      const sorted = [...toSummarize].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      toSummarize = sorted.slice(0, Math.max(0, sorted.length - options.skipMostRecent));
+    }
+    if (options.targetCount && toSummarize.length > options.targetCount) {
+      const sorted = [...toSummarize].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      toSummarize = sorted.slice(0, options.targetCount);
+    }
+    if (toSummarize.length === 0) {
+      throw validationError("No memories to summarize");
+    }
+    yield* this.summarizer.summarizeStream(toSummarize, options, options.prompt);
+  }
   async prune(strategy) {
-    const allMemories = await this.storage.retrieve({ limit: 1e4 });
+    await this._ensureInit();
+    const allMemories = await this.storage.retrieve({ limit: this.limits.pruneScan });
     const kept = this.pruner.execute(allMemories, strategy);
     const keptIds = new Set(kept.map((k) => k.id));
     const prunedIds = allMemories.filter((m) => !keptIds.has(m.id)).map((m) => m.id);
@@ -440,14 +611,107 @@ var MemoryStore = class {
     return { pruned: prunedIds, count };
   }
   async dryRunPrune(strategy) {
-    const allMemories = await this.storage.retrieve({ limit: 1e4 });
+    await this._ensureInit();
+    const allMemories = await this.storage.retrieve({ limit: this.limits.pruneScan });
     const kept = this.pruner.execute(allMemories, strategy);
     const keptIds = new Set(kept.map((k) => k.id));
     const wouldPrune = allMemories.filter((m) => !keptIds.has(m.id)).map((m) => m.id);
     return { wouldPrune, count: wouldPrune.length };
   }
-  async export() {
-    return this.storage.retrieve({ limit: 1e5 });
+  async export(actorId) {
+    await this._ensureInit();
+    return this.storage.retrieve({ actorId, limit: this.limits.exportScan });
+  }
+  async stats(actorId) {
+    await this._ensureInit();
+    const memories = await this.storage.retrieve({ actorId, limit: this.limits.exportScan });
+    const now = /* @__PURE__ */ new Date();
+    const byType = {};
+    const byActor = {};
+    let totalImportance = 0;
+    let expired = 0;
+    let oldest = null;
+    let newest = null;
+    for (const m of memories) {
+      totalImportance += m.importance;
+      byType[m.memoryType] = (byType[m.memoryType] ?? 0) + 1;
+      const actor = byActor[m.actorId] ?? { count: 0, oldest: m.createdAt, newest: m.createdAt, totalImportance: 0 };
+      actor.count++;
+      actor.totalImportance += m.importance;
+      if (m.createdAt < actor.oldest) actor.oldest = m.createdAt;
+      if (m.createdAt > actor.newest) actor.newest = m.createdAt;
+      byActor[m.actorId] = actor;
+      if (m.expiresAt && m.expiresAt <= now) expired++;
+      if (!oldest || m.createdAt < oldest) oldest = m.createdAt;
+      if (!newest || m.createdAt > newest) newest = m.createdAt;
+    }
+    const byActorFinal = {};
+    for (const [id, a] of Object.entries(byActor)) {
+      byActorFinal[id] = { count: a.count, oldest: a.oldest, newest: a.newest, avgImportance: a.totalImportance / a.count };
+    }
+    return {
+      total: memories.length,
+      expired,
+      oldest,
+      newest,
+      avgImportance: memories.length > 0 ? totalImportance / memories.length : 0,
+      byType,
+      byActor: byActorFinal
+    };
+  }
+  async purgeActor(actorId) {
+    await this._ensureInit();
+    const memories = await this.storage.retrieve({ actorId, limit: this.limits.purgeScan ?? 1e5 });
+    if (memories.length === 0) return 0;
+    return this.storage.deleteMany(memories.map((m) => m.id));
+  }
+  async merge(ids) {
+    await this._ensureInit();
+    if (ids.length < 2) throw validationError("merge requires at least 2 memory IDs");
+    const memories = [];
+    for (const id of ids) {
+      const m = await this.storage.get(id);
+      if (m) memories.push(m);
+    }
+    if (memories.length < 2) throw validationError("At least 2 of the provided IDs must exist");
+    const sorted = memories.sort((a, b) => b.importance - a.importance);
+    const winner = sorted[0];
+    const rest = sorted.slice(1);
+    const mergedContent = [
+      winner.content,
+      "",
+      "--- merged from " + rest.length + " related memories ---",
+      ...rest.map((m) => "- " + m.content)
+    ].join("\n");
+    const mergedTags = [...new Set(memories.flatMap((m) => m.tags))];
+    const mergedMetadata = {
+      ...winner.metadata,
+      mergedFrom: rest.map((m) => m.id)
+    };
+    const updated = await this.storage.store({
+      id: winner.id,
+      actorId: winner.actorId,
+      content: mergedContent,
+      memoryType: winner.memoryType,
+      importance: winner.importance,
+      emotionalValence: winner.emotionalValence,
+      tags: mergedTags,
+      embedding: winner.embedding,
+      sourceId: winner.sourceId,
+      metadata: mergedMetadata,
+      expiresAt: winner.expiresAt
+    });
+    await this.storage.deleteMany(rest.map((m) => m.id));
+    return updated;
+  }
+  async _ensureHashIndex() {
+    if (this.contentHashIndex !== null) return;
+    this.contentHashIndex = /* @__PURE__ */ new Map();
+    const existing = await this.storage.retrieve({ limit: this.limits.dedupScan });
+    for (const m of existing) {
+      const hash = this._hashContent(m.actorId, m.content);
+      this.contentHashIndex.set(hash, m.id);
+    }
   }
   _hashContent(actorId, content) {
     const normalized = `${actorId}::${content.toLowerCase().trim()}`;
@@ -461,7 +725,7 @@ var MemoryStore = class {
 };
 
 // src/adapters/storage/memory.ts
-var InMemoryStorage = class {
+var InMemoryStorageAdapter = class {
   memories = /* @__PURE__ */ new Map();
   async initialize() {
   }
@@ -535,6 +799,12 @@ var InMemoryStorage = class {
       const q = query.query.toLowerCase();
       results = results.filter((m) => m.content.toLowerCase().includes(q));
     }
+    if (query.createdAfter) {
+      results = results.filter((m) => m.createdAt >= query.createdAfter);
+    }
+    if (query.createdBefore) {
+      results = results.filter((m) => m.createdAt <= query.createdBefore);
+    }
     switch (query.strategy) {
       case "recent":
         results.sort((a, b) => b._touchedAt.getTime() - a._touchedAt.getTime());
@@ -586,13 +856,14 @@ var MemStack = class {
   memory;
   config;
   storage;
-  processCount = 0;
+  processCounts = /* @__PURE__ */ new Map();
+  pruneCheckCount = 0;
   constructor(config) {
     if (!config.llm) {
       throw configError("LLM provider is required");
     }
     this.config = config;
-    this.storage = config.storage ?? new InMemoryStorage();
+    this.storage = config.storage ?? new InMemoryStorageAdapter();
     this.memory = new MemoryStore({
       storage: this.storage,
       embedding: config.embedding,
@@ -658,35 +929,34 @@ var MemStack = class {
     };
     const memory = await this.memory.store(memoryInput);
     this.config.hooks?.onMemoryStored?.(memory);
-    this.processCount++;
+    const count = (this.processCounts.get(input.actorId) ?? 0) + 1;
+    this.processCounts.set(input.actorId, count);
     let summaryCreated;
     const threshold = this.config.defaults?.summarizationThreshold ?? 100;
-    if (threshold > 0) {
-      const count = await this.memory.count({ actorId: input.actorId, memoryType: "interaction" });
-      if (count % threshold === 0 && count > 0) {
-        try {
-          const result = await this.memory.summarize(
-            {
-              actorId: input.actorId,
-              memoryTypes: ["interaction"],
-              skipMostRecent: 5,
-              targetCount: Math.min(15, count)
-            },
-            this.config.hooks?.onError ? (err) => this.config.hooks.onError(err, "summarize") : void 0
-          );
-          summaryCreated = result.summary;
-          this.config.hooks?.onSummaryCreated?.(result.summary, result.deletedCount);
-        } catch (err) {
-          this.config.hooks?.onError?.(
-            err instanceof Error ? err : new Error(String(err)),
-            "summarize"
-          );
-        }
+    if (threshold > 0 && count % threshold === 0) {
+      try {
+        const result = await this.memory.summarize(
+          {
+            actorId: input.actorId,
+            memoryTypes: ["interaction"],
+            skipMostRecent: 5,
+            targetCount: Math.min(15, count)
+          },
+          this.config.hooks?.onError ? (err) => this.config.hooks.onError(err, "summarize") : void 0
+        );
+        summaryCreated = result.summary;
+        this.config.hooks?.onSummaryCreated?.(result.summary, result.deletedCount);
+      } catch (err) {
+        this.config.hooks?.onError?.(
+          err instanceof Error ? err : new Error(String(err)),
+          "summarize"
+        );
       }
     }
+    this.pruneCheckCount++;
     const pruneStrategy = this.config.defaults?.pruneStrategy;
     const pruneInterval = this.config.defaults?.pruneInterval ?? 100;
-    if (pruneStrategy && this.processCount % pruneInterval === 0) {
+    if (pruneStrategy && this.pruneCheckCount % pruneInterval === 0) {
       try {
         const pruneResult = await this.memory.prune(pruneStrategy);
         if (pruneResult.count > 0) {
@@ -701,8 +971,8 @@ var MemStack = class {
     }
     return { memory, summaryCreated };
   }
-  async export() {
-    const memories = await this.memory.export();
+  async export(actorId) {
+    const memories = await this.memory.export(actorId);
     return {
       version: 1,
       memories,
@@ -772,14 +1042,16 @@ var MemStack = class {
     return cleaned;
   }
 };
-var DiskStorage = class {
+var DiskStorageAdapter = class {
   dir;
   _writeLocks = /* @__PURE__ */ new Map();
+  _idIndex = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     this.dir = config.storageDir ?? "./memstack-data";
   }
   async initialize() {
     await promises.mkdir(this.dir, { recursive: true });
+    await this._buildIndex();
   }
   generateId() {
     return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
@@ -809,6 +1081,7 @@ var DiskStorage = class {
       } else {
         records.push(memory);
       }
+      this._idIndex.set(memory.id, input.actorId);
       await this._writeFile(input.actorId, records);
     });
     return this._toExternal(memory);
@@ -848,6 +1121,7 @@ var DiskStorage = class {
           } else {
             existing.push(mem);
           }
+          this._idIndex.set(mem.id, actorId);
         }
         await this._writeFile(actorId, existing);
       });
@@ -855,8 +1129,8 @@ var DiskStorage = class {
     return all.map((m) => this._toExternal(m));
   }
   async get(id) {
-    const actorIds = await this._listActors();
-    for (const actorId of actorIds) {
+    const actorId = this._idIndex.get(id);
+    if (actorId) {
       const records = await this._readFile(actorId);
       const record = records.find((r) => r.id === id);
       if (record) {
@@ -864,26 +1138,43 @@ var DiskStorage = class {
         return this._toExternal(record);
       }
     }
+    const actorIds = await this._listActors();
+    for (const aid of actorIds) {
+      const records = await this._readFile(aid);
+      const record = records.find((r) => r.id === id);
+      if (record) {
+        this._idIndex.set(id, aid);
+        if (record.expiresAt && new Date(record.expiresAt) <= /* @__PURE__ */ new Date()) return null;
+        return this._toExternal(record);
+      }
+    }
     return null;
   }
   async delete(id) {
-    const actorIds = await this._listActors();
-    for (const actorId of actorIds) {
-      const records = await this._readFile(actorId);
-      const index = records.findIndex((r) => r.id === id);
-      if (index !== -1) {
-        await this._withWriteLock(actorId, async () => {
-          const fresh = await this._readFile(actorId);
-          const i = fresh.findIndex((r) => r.id === id);
-          if (i !== -1) {
-            fresh.splice(i, 1);
-            await this._writeFile(actorId, fresh);
-          }
-        });
-        return;
+    let actorId = this._idIndex.get(id);
+    if (!actorId) {
+      const actorIds = await this._listActors();
+      for (const aid of actorIds) {
+        const records = await this._readFile(aid);
+        if (records.some((r) => r.id === id)) {
+          actorId = aid;
+          break;
+        }
       }
     }
-    throw notFound("Memory", id);
+    if (!actorId) throw notFound("Memory", id);
+    let deleted = false;
+    await this._withWriteLock(actorId, async () => {
+      const fresh = await this._readFile(actorId);
+      const i = fresh.findIndex((r) => r.id === id);
+      if (i !== -1) {
+        fresh.splice(i, 1);
+        this._idIndex.delete(id);
+        await this._writeFile(actorId, fresh);
+        deleted = true;
+      }
+    });
+    if (!deleted) throw notFound("Memory", id);
   }
   async deleteMany(ids) {
     const idSet = new Set(ids);
@@ -896,6 +1187,9 @@ var DiskStorage = class {
         const filtered = records.filter((r) => !idSet.has(r.id));
         count += before - filtered.length;
         if (before !== filtered.length) {
+          for (const r of records) {
+            if (idSet.has(r.id)) this._idIndex.delete(r.id);
+          }
           await this._writeFile(actorId, filtered);
         }
       });
@@ -978,24 +1272,16 @@ var DiskStorage = class {
     return total;
   }
   async touch(id) {
-    const actorIds = await this._listActors();
-    for (const actorId of actorIds) {
-      const records = await this._readFile(actorId);
-      const found = records.find((r) => r.id === id);
-      if (found) {
-        const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-        await this._withWriteLock(actorId, async () => {
-          const fresh = await this._readFile(actorId);
-          const match = fresh.find((r) => r.id === id);
-          if (match) {
-            match._touchedAt = nowStr;
-            await this._writeFile(actorId, fresh);
-          }
-        });
-        return;
-      }
-    }
-    throw notFound("Memory", id);
+    const actorId = this._idIndex.get(id);
+    if (!actorId) throw notFound("Memory", id);
+    const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+    await this._withWriteLock(actorId, async () => {
+      const fresh = await this._readFile(actorId);
+      const match = fresh.find((r) => r.id === id);
+      if (!match) throw notFound("Memory", id);
+      match._touchedAt = nowStr;
+      await this._writeFile(actorId, fresh);
+    });
   }
   async close() {
     this._writeLocks.clear();
@@ -1048,6 +1334,15 @@ var DiskStorage = class {
       throw storageError(`Failed to list actors: ${err.message}`);
     }
   }
+  async _buildIndex() {
+    const actorIds = await this._listActors();
+    for (const actorId of actorIds) {
+      const records = await this._readFile(actorId);
+      for (const r of records) {
+        this._idIndex.set(r.id, actorId);
+      }
+    }
+  }
   _toExternal(record) {
     const { _touchedAt: _, ...rest } = record;
     return {
@@ -1057,16 +1352,18 @@ var DiskStorage = class {
     };
   }
 };
-
-// src/adapters/storage/redis.ts
-var RedisStorage = class {
-  redis;
-  prefix;
+var MarkdownStorageAdapter = class {
+  dir;
+  oneFilePerActor;
+  _cache = null;
+  _deletedIds = /* @__PURE__ */ new Set();
+  _cacheDirty = true;
   constructor(config) {
-    this.redis = config.redis;
-    this.prefix = config.keyPrefix ?? "memstack";
+    this.dir = config.dir;
+    this.oneFilePerActor = config.oneFilePerActor ?? true;
   }
   async initialize() {
+    await promises.mkdir(this.dir, { recursive: true });
   }
   generateId() {
     return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
@@ -1085,99 +1382,89 @@ var RedisStorage = class {
       sourceId: input.sourceId,
       metadata: input.metadata ?? {},
       expiresAt: input.expiresAt,
-      createdAt: now,
-      _touchedAt: now.toISOString()
+      createdAt: now
     };
-    await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
-    await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
-    await this.redis.sadd(this._actorsSetKey(), memory.actorId);
-    return this._toExternal(memory);
+    const filePath = this._filePath(input.actorId);
+    const block = this._formatBlock(memory);
+    await promises.appendFile(filePath, block, "utf-8");
+    this._cacheDirty = true;
+    return memory;
   }
   async storeBatch(inputs) {
-    let results = [];
-    const now = /* @__PURE__ */ new Date();
+    const results = [];
     for (const input of inputs) {
-      const memory = {
-        id: input.id ?? this.generateId(),
-        actorId: input.actorId,
-        memoryType: input.memoryType ?? "interaction",
-        content: input.content,
-        importance: input.importance ?? 0.5,
-        emotionalValence: input.emotionalValence ?? 0,
-        tags: input.tags ?? [],
-        embedding: input.embedding,
-        sourceId: input.sourceId,
-        metadata: input.metadata ?? {},
-        expiresAt: input.expiresAt,
-        createdAt: now,
-        _touchedAt: now.toISOString()
-      };
-      await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
-      await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
-      await this.redis.sadd(this._actorsSetKey(), memory.actorId);
-      results.push(this._toExternal(memory));
+      results.push(await this.store(input));
     }
     return results;
   }
   async get(id) {
-    const raw = await this.redis.get(this._memKey(id));
-    if (!raw) return null;
-    const record = JSON.parse(raw);
-    if (record.expiresAt && new Date(record.expiresAt) <= /* @__PURE__ */ new Date()) return null;
-    return this._toExternal(record);
+    await this._ensureCache();
+    const memory = this._cache.get(id);
+    if (!memory) return null;
+    if (memory.expiresAt && memory.expiresAt <= /* @__PURE__ */ new Date()) return null;
+    if (this._deletedIds.has(id)) return null;
+    return memory;
   }
   async delete(id) {
-    const raw = await this.redis.get(this._memKey(id));
-    if (!raw) throw notFound("Memory", id);
-    const record = JSON.parse(raw);
-    await this.redis.del(this._memKey(id));
-    await this.redis.srem(this._actorKey(record.actorId), id);
+    await this._ensureCache();
+    const memory = this._cache.get(id);
+    if (!memory || this._deletedIds.has(id)) {
+      throw notFound("Memory", id);
+    }
+    if (memory.expiresAt && memory.expiresAt <= /* @__PURE__ */ new Date()) {
+      throw notFound("Memory", id);
+    }
+    const filePath = this._filePath(memory.actorId);
+    const tombstone = this._formatTombstone(id);
+    await promises.appendFile(filePath, tombstone, "utf-8");
+    this._cacheDirty = true;
   }
   async deleteMany(ids) {
-    let count = 0;
-    const byActor = /* @__PURE__ */ new Map();
+    await this._ensureCache();
+    new Set(ids);
+    const toDelete = [];
     for (const id of ids) {
-      const raw = await this.redis.get(this._memKey(id));
-      if (raw) {
-        const record = JSON.parse(raw);
-        const list = byActor.get(record.actorId) ?? [];
-        list.push(id);
-        byActor.set(record.actorId, list);
+      const memory = this._cache.get(id);
+      if (memory && !this._deletedIds.has(id)) {
+        if (!memory.expiresAt || memory.expiresAt > /* @__PURE__ */ new Date()) {
+          toDelete.push({ id, actorId: memory.actorId });
+        }
       }
     }
-    for (const [actorId, memIds] of byActor) {
-      await this.redis.del(memIds.map((id) => this._memKey(id)));
-      await this.redis.srem(this._actorKey(actorId), ...memIds);
-      count += memIds.length;
+    const byActor = /* @__PURE__ */ new Map();
+    for (const { id, actorId } of toDelete) {
+      const group = byActor.get(actorId) ?? [];
+      group.push(id);
+      byActor.set(actorId, group);
     }
-    return count;
+    for (const [actorId, groupIds] of byActor) {
+      const filePath = this._filePath(actorId);
+      const blocks = groupIds.map((gid) => this._formatTombstone(gid)).join("");
+      await promises.appendFile(filePath, blocks, "utf-8");
+    }
+    this._cacheDirty = true;
+    return toDelete.length;
   }
   async retrieve(query, _embedding) {
-    let allRecords = [];
+    await this._ensureCache();
+    const now = /* @__PURE__ */ new Date();
+    let results = Array.from(this._cache.values()).filter((m) => !this._deletedIds.has(m.id)).filter((m) => !m.expiresAt || m.expiresAt > now);
     if (query.actorId) {
-      allRecords = await this._getActorRecords(query.actorId);
-    } else {
-      const actorIds = await this._listActors();
-      for (const actorId of actorIds) {
-        const records = await this._getActorRecords(actorId);
-        allRecords.push(...records);
-      }
+      results = results.filter((m) => m.actorId === query.actorId);
     }
-    const now = /* @__PURE__ */ new Date();
-    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
     if (query.memoryTypes && query.memoryTypes.length > 0) {
-      results = results.filter((r) => query.memoryTypes.includes(r.memoryType));
+      results = results.filter((m) => query.memoryTypes.includes(m.memoryType));
     }
     if (query.tags && query.tags.length > 0) {
-      results = results.filter((r) => r.tags?.some((t) => query.tags.includes(t)));
+      results = results.filter((m) => m.tags?.some((t) => query.tags.includes(t)));
     }
     if (query.query) {
       const q = query.query.toLowerCase();
-      results = results.filter((r) => r.content.toLowerCase().includes(q));
+      results = results.filter((m) => m.content.toLowerCase().includes(q));
     }
     switch (query.strategy) {
       case "recent":
-        results.sort((a, b) => new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime());
+        results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
         break;
       case "important":
         results.sort((a, b) => b.importance - a.importance);
@@ -1186,97 +1473,472 @@ var RedisStorage = class {
       case "semantic":
       default:
         results.sort(
-          (a, b) => b.importance - a.importance || new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime()
+          (a, b) => b.importance - a.importance || b.createdAt.getTime() - a.createdAt.getTime()
         );
         break;
     }
-    const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-    const toTouch = results.slice(0, query.limit ?? 10);
-    for (const r of toTouch) {
-      r._touchedAt = nowStr;
-      await this.redis.set(this._memKey(r.id), JSON.stringify(r));
-    }
     const limit = query.limit ?? 10;
-    return results.slice(0, limit).map((r) => this._toExternal(r));
+    return results.slice(0, limit);
   }
   async count(filter) {
-    let allRecords = [];
+    await this._ensureCache();
+    const now = /* @__PURE__ */ new Date();
+    let results = Array.from(this._cache.values()).filter((m) => !this._deletedIds.has(m.id)).filter((m) => !m.expiresAt || m.expiresAt > now);
     if (filter?.actorId) {
-      allRecords = await this._getActorRecords(filter.actorId);
-    } else {
-      const actorIds = await this._listActors();
-      for (const actorId of actorIds) {
-        const records = await this._getActorRecords(actorId);
-        allRecords.push(...records);
-      }
+      results = results.filter((m) => m.actorId === filter.actorId);
     }
-    const now = /* @__PURE__ */ new Date();
-    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
     if (filter?.memoryType) {
-      results = results.filter((r) => r.memoryType === filter.memoryType);
+      results = results.filter((m) => m.memoryType === filter.memoryType);
     }
     if (filter?.minImportance !== void 0) {
-      results = results.filter((r) => r.importance >= filter.minImportance);
+      results = results.filter((m) => m.importance >= filter.minImportance);
     }
     return results.length;
   }
   async close() {
+    this._cache = null;
+    this._deletedIds.clear();
+    this._cacheDirty = true;
   }
-  // ── Internal ──
-  _actorsSetKey() {
-    return `${this.prefix}:actors`;
+  async vacuum() {
+    if (this.oneFilePerActor) {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        await this._vacuumFile(this._filePath(actorId));
+      }
+    } else {
+      await this._vacuumFile(this._filePath(""));
+    }
+    this._cacheDirty = true;
   }
-  _actorKey(actorId) {
+  // ── Internal ──
+  _filePath(actorId) {
+    if (!this.oneFilePerActor) {
+      return path.join(this.dir, "memories.md");
+    }
     const safe = actorId.replace(/[^a-zA-Z0-9_\-.,@]/g, "_");
-    return `${this.prefix}:a:${safe}`;
+    return path.join(this.dir, `${safe}.md`);
   }
-  _memKey(id) {
-    return `${this.prefix}:m:${id}`;
+  _formatBlock(memory) {
+    const iso = memory.createdAt.toISOString();
+    const meta = JSON.stringify({
+      id: memory.id,
+      actorId: memory.actorId,
+      memoryType: memory.memoryType,
+      importance: memory.importance,
+      emotionalValence: memory.emotionalValence,
+      tags: memory.tags,
+      embedding: memory.embedding,
+      sourceId: memory.sourceId ?? null,
+      metadata: memory.metadata ?? {},
+      createdAt: memory.createdAt.toISOString(),
+      expiresAt: memory.expiresAt?.toISOString() ?? null
+    });
+    return `## ${iso}
+
+~~~json
+${meta}
+~~~
+
+${memory.content}
+
+---
+`;
   }
-  async _getActorRecords(actorId) {
-    const ids = await this.redis.smembers(this._actorKey(actorId));
-    if (ids.length === 0) return [];
-    const keys = ids.map((id) => this._memKey(id));
-    const raws = await this.redis.mget(...keys);
-    const records = [];
-    for (const raw of raws) {
-      if (raw) {
+  _formatTombstone(id) {
+    const iso = (/* @__PURE__ */ new Date()).toISOString();
+    return `## ${iso}
+
+<!-- deleted: ${id} -->
+
+---
+`;
+  }
+  async _ensureCache() {
+    if (!this._cacheDirty) return;
+    const allMemories = /* @__PURE__ */ new Map();
+    const allDeletedIds = /* @__PURE__ */ new Set();
+    if (this.oneFilePerActor) {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        const { memories, deletedIds } = await this._parseFile(this._filePath(actorId));
+        for (const mem of memories) {
+          allMemories.set(mem.id, mem);
+        }
+        for (const did of deletedIds) {
+          allDeletedIds.add(did);
+        }
+      }
+    } else {
+      const { memories, deletedIds } = await this._parseFile(this._filePath(""));
+      for (const mem of memories) {
+        allMemories.set(mem.id, mem);
+      }
+      for (const did of deletedIds) {
+        allDeletedIds.add(did);
+      }
+    }
+    this._cache = allMemories;
+    this._deletedIds = allDeletedIds;
+    this._cacheDirty = false;
+  }
+  async _parseFile(filePath) {
+    let raw;
+    try {
+      raw = await promises.readFile(filePath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { memories: [], deletedIds: [] };
+      }
+      throw storageError(`Failed to read file ${filePath}: ${err.message}`);
+    }
+    const memories = [];
+    const deletedIds = [];
+    const sections = raw.split("\n---\n");
+    for (const section of sections) {
+      const trimmed = section.trim();
+      if (!trimmed) continue;
+      const cleanBlock = trimmed.replace(/\n---$/, "");
+      const lines = cleanBlock.split("\n");
+      let i = 0;
+      if (!lines[i]?.startsWith("## ")) continue;
+      i++;
+      while (i < lines.length && lines[i].trim() === "") i++;
+      if (i >= lines.length) continue;
+      const tombstoneMatch = lines[i].trim().match(/^<!-- deleted:\s*(\S+)\s*-->/);
+      if (tombstoneMatch) {
+        deletedIds.push(tombstoneMatch[1]);
+        continue;
+      }
+      if (lines[i].trim() !== "~~~json") continue;
+      i++;
+      const jsonLines = [];
+      while (i < lines.length && lines[i].trim() !== "~~~") {
+        jsonLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      let metadata = null;
+      try {
+        metadata = JSON.parse(jsonLines.join("\n"));
+      } catch {
+        continue;
+      }
+      while (i < lines.length && lines[i].trim() === "") i++;
+      const contentLines = [];
+      while (i < lines.length) {
+        contentLines.push(lines[i]);
+        i++;
+      }
+      const content = contentLines.join("\n").trim();
+      if (metadata && typeof metadata.id === "string") {
+        memories.push({
+          id: metadata.id,
+          actorId: metadata.actorId,
+          memoryType: metadata.memoryType ?? "interaction",
+          content,
+          importance: metadata.importance ?? 0.5,
+          emotionalValence: metadata.emotionalValence ?? 0,
+          tags: metadata.tags ?? [],
+          embedding: metadata.embedding,
+          sourceId: metadata.sourceId ?? void 0,
+          metadata: metadata.metadata ?? {},
+          createdAt: new Date(metadata.createdAt),
+          expiresAt: metadata.expiresAt ? new Date(metadata.expiresAt) : void 0
+        });
+      }
+    }
+    return { memories, deletedIds };
+  }
+  async _vacuumFile(filePath) {
+    await this._ensureCache();
+    let raw;
+    try {
+      raw = await promises.readFile(filePath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw storageError(`Failed to read file for vacuum: ${err.message}`);
+    }
+    const sections = raw.split("\n---\n");
+    const kept = [];
+    for (const section of sections) {
+      const trimmed = section.trim();
+      if (!trimmed) continue;
+      const cleanBlock = trimmed.replace(/\n---$/, "");
+      const lines = cleanBlock.split("\n");
+      let i = 0;
+      if (!lines[i]?.startsWith("## ")) {
+        kept.push(trimmed);
+        continue;
+      }
+      i++;
+      while (i < lines.length && lines[i].trim() === "") i++;
+      if (i >= lines.length) {
+        kept.push(trimmed);
+        continue;
+      }
+      const tombstoneMatch = lines[i].trim().match(/^<!-- deleted:\s*(\S+)\s*-->/);
+      if (tombstoneMatch) continue;
+      if (lines[i].trim() !== "~~~json") {
+        kept.push(trimmed);
+        continue;
+      }
+      i++;
+      while (i < lines.length && lines[i].trim() !== "~~~") i++;
+      i++;
+      while (i < lines.length && lines[i].trim() === "") i++;
+      const contentLines = [];
+      while (i < lines.length) {
+        contentLines.push(lines[i]);
+        i++;
+      }
+      try {
+        const jsonStartIdx = lines.findIndex((l) => l.trim() === "~~~json");
+        const jsonEndIdx = lines.findIndex((l, idx) => idx > jsonStartIdx && l.trim() === "~~~");
+        const jsonText = lines.slice(jsonStartIdx + 1, jsonEndIdx).join("\n");
+        const meta = JSON.parse(jsonText);
+        if (this._deletedIds.has(meta.id)) continue;
+      } catch {
+      }
+      const content = contentLines.join("\n").trim();
+      if (content || trimmed.includes("~~~json")) {
+        kept.push(trimmed);
+      }
+    }
+    const output = kept.length > 0 ? kept.join("\n---\n") + "\n---\n" : "";
+    await promises.writeFile(filePath, output, "utf-8");
+  }
+  async _listActors() {
+    try {
+      const entries = await promises.readdir(this.dir);
+      return entries.filter((e) => e.endsWith(".md")).map((e) => e.slice(0, -3));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw storageError(`Failed to list actors: ${err.message}`);
+    }
+  }
+};
+
+// src/adapters/storage/hybrid.ts
+var HybridStorageAdapter = class {
+  cache;
+  durable;
+  writeBoth;
+  readFromCache;
+  syncOnInit;
+  constructor(config) {
+    this.cache = config.cache;
+    this.durable = config.durable;
+    this.writeBoth = config.writeBoth ?? true;
+    this.readFromCache = config.readFromCache ?? true;
+    this.syncOnInit = config.syncOnInit ?? false;
+  }
+  async initialize() {
+    await Promise.all([this.cache.initialize(), this.durable.initialize()]);
+    if (this.syncOnInit) {
+      const results = await this.durable.retrieve({ limit: 1e5 });
+      if (results.length > 0) {
+        await this.cache.storeBatch(results.map((m) => ({
+          actorId: m.actorId,
+          content: m.content,
+          memoryType: m.memoryType,
+          importance: m.importance,
+          emotionalValence: m.emotionalValence,
+          tags: m.tags,
+          embedding: m.embedding,
+          sourceId: m.sourceId,
+          metadata: m.metadata,
+          expiresAt: m.expiresAt,
+          id: m.id
+        }))).catch(() => {
+        });
+      }
+    }
+  }
+  async store(input) {
+    const result = await this.durable.store(input);
+    if (this.writeBoth) {
+      try {
+        await this.cache.store({ ...input, id: result.id });
+      } catch {
+      }
+    }
+    return result;
+  }
+  async storeBatch(inputs) {
+    const results = await this.durable.storeBatch(inputs);
+    if (this.writeBoth) {
+      const cacheInputs = results.map((r, i) => ({
+        ...inputs[i],
+        id: r.id
+      }));
+      try {
+        await this.cache.storeBatch(cacheInputs);
+      } catch {
+      }
+    }
+    return results;
+  }
+  async get(id) {
+    if (this.readFromCache) {
+      const cached = await this.cache.get(id);
+      if (cached) return cached;
+      const result = await this.durable.get(id);
+      if (result) {
         try {
-          records.push(JSON.parse(raw));
+          await this.cache.store({
+            actorId: result.actorId,
+            content: result.content,
+            memoryType: result.memoryType,
+            importance: result.importance,
+            emotionalValence: result.emotionalValence,
+            tags: result.tags,
+            embedding: result.embedding,
+            sourceId: result.sourceId,
+            metadata: result.metadata,
+            expiresAt: result.expiresAt,
+            id: result.id
+          });
         } catch {
         }
       }
+      return result;
     }
-    return records;
+    return this.durable.get(id);
   }
-  async _listActors() {
-    return this.redis.smembers(this._actorsSetKey());
+  async retrieve(query, embedding) {
+    if (this.readFromCache) {
+      const cached = await this.cache.retrieve(query, embedding);
+      if (cached.length > 0) return cached;
+      const results = await this.durable.retrieve(query, embedding);
+      if (results.length > 0) {
+        const inputs = results.map((r) => ({
+          actorId: r.actorId,
+          content: r.content,
+          memoryType: r.memoryType,
+          importance: r.importance,
+          emotionalValence: r.emotionalValence,
+          tags: r.tags,
+          embedding: r.embedding,
+          sourceId: r.sourceId,
+          metadata: r.metadata,
+          expiresAt: r.expiresAt,
+          id: r.id
+        }));
+        try {
+          await this.cache.storeBatch(inputs);
+        } catch {
+        }
+      }
+      return results;
+    }
+    return this.durable.retrieve(query, embedding);
   }
-  _toExternal(record) {
-    const { _touchedAt: _, ...rest } = record;
-    return {
-      ...rest,
-      createdAt: new Date(record.createdAt),
-      expiresAt: record.expiresAt ? new Date(record.expiresAt) : void 0
-    };
+  async delete(id) {
+    const results = await Promise.allSettled([
+      this.cache.delete(id),
+      this.durable.delete(id)
+    ]);
+    const durableResult = results[1];
+    if (durableResult.status === "rejected") {
+      throw durableResult.reason;
+    }
+  }
+  async deleteMany(ids) {
+    const [cacheResult, durableCount] = await Promise.all([
+      this.cache.deleteMany(ids).catch(() => 0),
+      this.durable.deleteMany(ids)
+    ]);
+    return durableCount;
+  }
+  async count(filter) {
+    return this.durable.count(filter);
+  }
+  async touch(id) {
+    if (this.durable.touch) {
+      await this.durable.touch(id);
+    }
+  }
+  async close() {
+    await Promise.all([this.cache.close(), this.durable.close()]);
   }
 };
 
 // src/adapters/storage/postgres.ts
-var PostgresStorage = class {
+var PostgresStorageAdapter = class {
   pool;
   table;
-  autoMigrate;
+  vectorDimensions;
+  _ownsPool = false;
   constructor(config) {
-    this.pool = config.pool;
     this.table = config.tableName ?? "memstack_memories";
     if (!/^[a-zA-Z0-9_]+$/.test(this.table)) {
-      throw new Error(`Invalid table name: "${this.table}". Use only alphanumeric characters and underscores.`);
+      throw configError(`Invalid table name: "${this.table}". Use only alphanumeric characters and underscores.`);
+    }
+    this.vectorDimensions = config.vectorDimensions ?? 1536;
+    if (config.pool) {
+      this.pool = config.pool;
+    } else if (config.connectionString) {
+      this._connectionString = config.connectionString;
+      this._ssl = config.ssl;
+    } else if (config.host || config.database || config.user) {
+      this._connParts = { host: config.host, port: config.port, database: config.database, user: config.user, password: config.password, ssl: config.ssl };
+    } else {
+      throw configError("PostgresStorageAdapter requires a pool, connectionString, or connection details");
     }
-    this.autoMigrate = config.autoMigrate ?? true;
   }
+  _connectionString;
+  _connParts;
+  _ssl;
   async initialize() {
-    if (!this.autoMigrate) return;
+    if (this._connectionString || this._connParts) {
+      this.pool = await this._createPool();
+      this._ownsPool = true;
+    }
+    await this._runMigration();
+  }
+  async _createPool() {
+    const connStr = this._connectionString ?? this._buildConnString();
+    try {
+      const { default: createPostgres } = await import('postgres');
+      const options = {};
+      if (this._ssl) {
+        options.ssl = typeof this._ssl === "object" ? this._ssl : "require";
+      }
+      const sql = createPostgres(connStr, options);
+      return {
+        query: (text, params) => sql.unsafe(text, params).then((r) => ({ rows: r })),
+        end: () => sql.end()
+      };
+    } catch {
+      try {
+        const { Pool } = await import('pg');
+        const pool = new Pool({ connectionString: connStr, ssl: this._ssl });
+        return { query: (text, params) => pool.query(text, params), end: () => pool.end() };
+      } catch {
+        throw configError("connectionString requires 'postgres' (postgres.js) or 'pg' (node-postgres) to be installed");
+      }
+    }
+  }
+  _buildConnString() {
+    const p = this._connParts;
+    const host = p.host ?? "localhost";
+    const port = p.port ?? 5432;
+    const db = p.database ?? "postgres";
+    const user = encodeURIComponent(p.user ?? "postgres");
+    const pw = p.password ? `:${encodeURIComponent(p.password)}` : "";
+    let connStr = `postgres://${user}${pw}@${host}:${port}/${db}`;
+    if (this._ssl) {
+      const sslmode = typeof this._ssl === "object" ? "no-verify" : "require";
+      connStr += `?sslmode=${sslmode}`;
+    }
+    return connStr;
+  }
+  async _runMigration() {
+    try {
+      await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector");
+    } catch {
+    }
     await this.pool.query(`
       CREATE TABLE IF NOT EXISTS ${this.table} (
         id TEXT PRIMARY KEY,
@@ -1286,7 +1948,7 @@ var PostgresStorage = class {
         importance REAL NOT NULL DEFAULT 0.5,
         emotional_valence REAL NOT NULL DEFAULT 0,
         tags JSONB NOT NULL DEFAULT '[]',
-        embedding vector(3072),
+        embedding vector(${this.vectorDimensions}),
         source_id TEXT,
         metadata JSONB NOT NULL DEFAULT '{}',
         expires_at TIMESTAMPTZ,
@@ -1296,7 +1958,9 @@ var PostgresStorage = class {
     `);
     try {
       await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_actor ON ${this.table} (actor_id)`);
-      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_type ON ${this.table} (memory_type)`);
+      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_created ON ${this.table} (created_at DESC)`);
+      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_importance ON ${this.table} (importance DESC)`);
+      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_embedding ON ${this.table} USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64)`);
     } catch {
     }
   }
@@ -1378,6 +2042,11 @@ var PostgresStorage = class {
     );
     return rows.length;
   }
+  async touch(id) {
+    const { rows } = await this.pool.query(`SELECT id FROM ${this.table} WHERE id = $1`, [id]);
+    if (rows.length === 0) throw notFound("Memory", id);
+    await this.pool.query(`UPDATE ${this.table} SET touched_at = NOW() WHERE id = $1`, [id]);
+  }
   async retrieve(query, embedding) {
     const conditions = ["(expires_at IS NULL OR expires_at > NOW())"];
     const params = [];
@@ -1398,6 +2067,14 @@ var PostgresStorage = class {
       conditions.push(`content ILIKE $${paramIdx++}`);
       params.push(`%${query.query}%`);
     }
+    if (query.createdAfter) {
+      conditions.push(`created_at >= $${paramIdx++}`);
+      params.push(query.createdAfter.toISOString());
+    }
+    if (query.createdBefore) {
+      conditions.push(`created_at <= $${paramIdx++}`);
+      params.push(query.createdBefore.toISOString());
+    }
     const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     let orderBy;
     switch (query.strategy) {
@@ -1410,8 +2087,8 @@ var PostgresStorage = class {
       case "hybrid":
       case "semantic":
       default:
-        if (embedding && query.query) {
-          return this._semanticRetrieve(embedding, query, params, where);
+        if (embedding) {
+          return this._semanticRetrieve(embedding, query, params, where, paramIdx);
         }
         orderBy = "importance DESC, touched_at DESC";
         break;
@@ -1422,10 +2099,7 @@ var PostgresStorage = class {
     const { rows } = await this.pool.query(sql, params);
     for (const row of rows.slice(0, limit)) {
       const r = row;
-      await this.pool.query(
-        `UPDATE ${this.table} SET touched_at = NOW() WHERE id = $1`,
-        [r.id]
-      );
+      await this.pool.query(`UPDATE ${this.table} SET touched_at = NOW() WHERE id = $1`, [r.id]);
     }
     return rows.map((r) => this._rowToMemory(r));
   }
@@ -1445,6 +2119,14 @@ var PostgresStorage = class {
       conditions.push(`importance >= $${paramIdx++}`);
       params.push(filter.minImportance);
     }
+    if (filter?.createdAfter) {
+      conditions.push(`created_at >= $${paramIdx++}`);
+      params.push(filter.createdAfter.toISOString());
+    }
+    if (filter?.createdBefore) {
+      conditions.push(`created_at <= $${paramIdx++}`);
+      params.push(filter.createdBefore.toISOString());
+    }
     const where = conditions.join(" AND ");
     const { rows } = await this.pool.query(
       `SELECT COUNT(*) as count FROM ${this.table} WHERE ${where}`,
@@ -1453,22 +2135,32 @@ var PostgresStorage = class {
     return Number(rows[0].count);
   }
   async close() {
+    if (this._ownsPool && this.pool?.end) {
+      await this.pool.end();
+    }
   }
-  // ── Internal ──
-  async _semanticRetrieve(embedding, query, params, baseWhere) {
-    const vecParam = `{${embedding.join(",")}}`;
+  async _semanticRetrieve(embedding, query, params, baseWhere, paramIdx) {
     const limit = query.limit ?? 10;
     const conditions = baseWhere.replace(/^WHERE\s+/i, "");
     const whereClause = conditions ? `WHERE ${conditions} AND embedding IS NOT NULL` : `WHERE embedding IS NOT NULL`;
-    const sql = `
+    const isHybrid = query.strategy === "hybrid";
+    const sql = isHybrid ? `
       SELECT *,
-        (embedding <-> $${params.length + 1}::float8[]::vector) AS distance
+        (embedding <-> $${paramIdx}::float8[]::vector) AS distance,
+        (1.0 - (embedding <-> $${paramIdx}::float8[]::vector) / 2.0 + importance) AS score
+      FROM ${this.table}
+      ${whereClause}
+      ORDER BY score DESC
+      LIMIT $${paramIdx + 1}
+    ` : `
+      SELECT *,
+        (embedding <-> $${paramIdx}::float8[]::vector) AS distance
       FROM ${this.table}
       ${whereClause}
       ORDER BY distance ASC
-      LIMIT $${params.length + 2}
+      LIMIT $${paramIdx + 1}
     `;
-    params.push(vecParam);
+    params.push(embedding);
     params.push(limit);
     const { rows } = await this.pool.query(sql, params);
     for (const row of rows.slice(0, limit)) {
@@ -1495,6 +2187,1515 @@ var PostgresStorage = class {
   }
 };
 
+// src/adapters/storage/redis.ts
+var RedisStorageAdapter = class {
+  redis;
+  prefix;
+  constructor(config) {
+    this.redis = config.redis;
+    this.prefix = config.keyPrefix ?? "memstack";
+  }
+  async initialize() {
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      _touchedAt: now.toISOString()
+    };
+    await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
+    await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
+    await this.redis.sadd(this._actorsSetKey(), memory.actorId);
+    return this._toExternal(memory);
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    const now = /* @__PURE__ */ new Date();
+    for (const input of inputs) {
+      const memory = {
+        id: input.id ?? this.generateId(),
+        actorId: input.actorId,
+        memoryType: input.memoryType ?? "interaction",
+        content: input.content,
+        importance: input.importance ?? 0.5,
+        emotionalValence: input.emotionalValence ?? 0,
+        tags: input.tags ?? [],
+        embedding: input.embedding,
+        sourceId: input.sourceId,
+        metadata: input.metadata ?? {},
+        expiresAt: input.expiresAt,
+        createdAt: now,
+        _touchedAt: now.toISOString()
+      };
+      await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
+      await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
+      await this.redis.sadd(this._actorsSetKey(), memory.actorId);
+      results.push(this._toExternal(memory));
+    }
+    return results;
+  }
+  async get(id) {
+    const raw = await this.redis.get(this._memKey(id));
+    if (!raw) return null;
+    const record = JSON.parse(raw);
+    if (record.expiresAt && new Date(record.expiresAt) <= /* @__PURE__ */ new Date()) return null;
+    return this._toExternal(record);
+  }
+  async delete(id) {
+    const raw = await this.redis.get(this._memKey(id));
+    if (!raw) throw notFound("Memory", id);
+    const record = JSON.parse(raw);
+    await this.redis.del(this._memKey(id));
+    await this.redis.srem(this._actorKey(record.actorId), id);
+  }
+  async deleteMany(ids) {
+    let count = 0;
+    const byActor = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const raw = await this.redis.get(this._memKey(id));
+      if (raw) {
+        const record = JSON.parse(raw);
+        const list = byActor.get(record.actorId) ?? [];
+        list.push(id);
+        byActor.set(record.actorId, list);
+      }
+    }
+    for (const [actorId, memIds] of byActor) {
+      await this.redis.del(memIds.map((id) => this._memKey(id)));
+      await this.redis.srem(this._actorKey(actorId), ...memIds);
+      count += memIds.length;
+    }
+    return count;
+  }
+  async touch(id) {
+    const raw = await this.redis.get(this._memKey(id));
+    if (!raw) throw notFound("Memory", id);
+    const record = JSON.parse(raw);
+    record._touchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.redis.set(this._memKey(id), JSON.stringify(record));
+  }
+  async retrieve(query, _embedding) {
+    let allRecords = [];
+    if (query.actorId) {
+      allRecords = await this._getActorRecords(query.actorId);
+    } else {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        const records = await this._getActorRecords(actorId);
+        allRecords.push(...records);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      results = results.filter((r) => query.memoryTypes.includes(r.memoryType));
+    }
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((r) => r.tags?.some((t) => query.tags.includes(t)));
+    }
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((r) => r.content.toLowerCase().includes(q));
+    }
+    switch (query.strategy) {
+      case "recent":
+        results.sort((a, b) => new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime());
+        break;
+      case "important":
+        results.sort((a, b) => b.importance - a.importance);
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        results.sort(
+          (a, b) => b.importance - a.importance || new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime()
+        );
+        break;
+    }
+    const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+    const toTouch = results.slice(0, query.limit ?? 10);
+    for (const r of toTouch) {
+      r._touchedAt = nowStr;
+      await this.redis.set(this._memKey(r.id), JSON.stringify(r));
+    }
+    const limit = query.limit ?? 10;
+    return results.slice(0, limit).map((r) => this._toExternal(r));
+  }
+  async count(filter) {
+    let allRecords = [];
+    if (filter?.actorId) {
+      allRecords = await this._getActorRecords(filter.actorId);
+    } else {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        const records = await this._getActorRecords(actorId);
+        allRecords.push(...records);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+    if (filter?.memoryType) {
+      results = results.filter((r) => r.memoryType === filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      results = results.filter((r) => r.importance >= filter.minImportance);
+    }
+    return results.length;
+  }
+  async close() {
+  }
+  _actorsSetKey() {
+    return `${this.prefix}:actors`;
+  }
+  _actorKey(actorId) {
+    const safe = actorId.replace(/[^a-zA-Z0-9_\-.,@]/g, "_");
+    return `${this.prefix}:a:${safe}`;
+  }
+  _memKey(id) {
+    return `${this.prefix}:m:${id}`;
+  }
+  async _getActorRecords(actorId) {
+    const ids = await this.redis.smembers(this._actorKey(actorId));
+    if (ids.length === 0) return [];
+    const keys = ids.map((id) => this._memKey(id));
+    const raws = await this.redis.mget(...keys);
+    const records = [];
+    for (const raw of raws) {
+      if (raw) {
+        try {
+          records.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+    }
+    return records;
+  }
+  async _listActors() {
+    return this.redis.smembers(this._actorsSetKey());
+  }
+  _toExternal(record) {
+    const { _touchedAt: _, ...rest } = record;
+    return {
+      ...rest,
+      createdAt: new Date(record.createdAt),
+      expiresAt: record.expiresAt ? new Date(record.expiresAt) : void 0
+    };
+  }
+};
+
+// src/adapters/storage/qdrant.ts
+var QdrantStorageAdapter = class {
+  client;
+  collectionName;
+  vectorSize;
+  _idToQdrant = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.client = config.client;
+    this.collectionName = config.collectionName ?? "memstack";
+    this.vectorSize = config.vectorSize ?? 1536;
+  }
+  async initialize() {
+    try {
+      await this.client.getCollection(this.collectionName);
+    } catch {
+      await this.client.createCollection(this.collectionName, {
+        vectors: { size: this.vectorSize, distance: "Cosine" }
+      });
+    }
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now
+    };
+    const qdrantId = crypto.randomUUID();
+    await this.client.upsert(this.collectionName, {
+      points: [
+        {
+          id: qdrantId,
+          vector: input.embedding ?? new Array(this.vectorSize).fill(0),
+          payload: this._toPayload(memory)
+        }
+      ]
+    });
+    this._idToQdrant.set(memory.id, qdrantId);
+    return memory;
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    const now = /* @__PURE__ */ new Date();
+    const points = [];
+    for (const input of inputs) {
+      const memory = {
+        id: input.id ?? this.generateId(),
+        actorId: input.actorId,
+        memoryType: input.memoryType ?? "interaction",
+        content: input.content,
+        importance: input.importance ?? 0.5,
+        emotionalValence: input.emotionalValence ?? 0,
+        tags: input.tags ?? [],
+        embedding: input.embedding,
+        sourceId: input.sourceId,
+        metadata: input.metadata ?? {},
+        expiresAt: input.expiresAt,
+        createdAt: now
+      };
+      results.push(memory);
+      const qid = crypto.randomUUID();
+      points.push({
+        id: qid,
+        vector: input.embedding ?? new Array(this.vectorSize).fill(0),
+        payload: this._toPayload(memory)
+      });
+      this._idToQdrant.set(memory.id, qid);
+    }
+    await this.client.upsert(this.collectionName, { points });
+    return results;
+  }
+  async get(id) {
+    const qdrantId = this._idToQdrant.get(id);
+    if (qdrantId) {
+      const points = await this.client.retrieve(this.collectionName, { ids: [qdrantId] });
+      if (points && points.length > 0) {
+        const point = points[0];
+        if (point.payload.expiresAt && new Date(point.payload.expiresAt) <= /* @__PURE__ */ new Date()) return null;
+        return this._fromPoint(point);
+      }
+    }
+    return null;
+  }
+  async delete(id) {
+    const qdrantId = this._idToQdrant.get(id);
+    if (!qdrantId) throw notFound("Memory", id);
+    await this.client.delete(this.collectionName, { points: [qdrantId] });
+    this._idToQdrant.delete(id);
+  }
+  async deleteMany(ids) {
+    const qdrantIds = [];
+    for (const id of ids) {
+      const qid = this._idToQdrant.get(id);
+      if (qid) {
+        qdrantIds.push(qid);
+        this._idToQdrant.delete(id);
+      }
+    }
+    if (qdrantIds.length === 0) return 0;
+    await this.client.delete(this.collectionName, { points: qdrantIds });
+    return qdrantIds.length;
+  }
+  async retrieve(query, embedding) {
+    const must = [];
+    if (query.actorId) {
+      must.push({ key: "actorId", match: { value: query.actorId } });
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      must.push({ key: "memoryType", match: { any: query.memoryTypes } });
+    }
+    if (query.tags && query.tags.length > 0) {
+      must.push({ key: "tags", match: { any: query.tags } });
+    }
+    const filter = must.length > 0 ? { must } : void 0;
+    const limit = query.limit ?? 10;
+    if (query.strategy === "semantic" || query.strategy === "hybrid") {
+      const vector2 = embedding ?? new Array(this.vectorSize).fill(0);
+      const results2 = await this.client.search(this.collectionName, {
+        vector: vector2,
+        limit,
+        filter
+      });
+      const points2 = results2;
+      return points2.map((p) => this._fromPoint(p));
+    }
+    const vector = new Array(this.vectorSize).fill(0);
+    const results = await this.client.search(this.collectionName, {
+      vector,
+      limit: 1e4,
+      filter
+    });
+    let points = results;
+    switch (query.strategy) {
+      case "recent":
+        points.sort((a, b) => {
+          const aTime = new Date(a.payload.createdAt).getTime();
+          const bTime = new Date(b.payload.createdAt).getTime();
+          return bTime - aTime;
+        });
+        break;
+      case "important":
+        points.sort((a, b) => b.payload.importance - a.payload.importance);
+        break;
+    }
+    return points.slice(0, limit).map((p) => this._fromPoint(p));
+  }
+  async count(filter) {
+    const must = [];
+    if (filter?.actorId) {
+      must.push({ key: "actorId", match: { value: filter.actorId } });
+    }
+    if (filter?.memoryType) {
+      must.push({ key: "memoryType", match: { value: filter.memoryType } });
+    }
+    if (filter?.minImportance !== void 0) {
+      must.push({ key: "importance", range: { gte: filter.minImportance } });
+    }
+    const filterObj = must.length > 0 ? { must } : void 0;
+    const result = await this.client.count(this.collectionName, filterObj ? { filter: filterObj } : void 0);
+    return result.count;
+  }
+  async close() {
+  }
+  _toPayload(memory) {
+    return {
+      _id: memory.id,
+      actorId: memory.actorId,
+      memoryType: memory.memoryType,
+      importance: memory.importance,
+      emotionalValence: memory.emotionalValence,
+      tags: memory.tags,
+      content: memory.content,
+      metadata: memory.metadata ?? {},
+      createdAt: memory.createdAt.toISOString(),
+      sourceId: memory.sourceId ?? null,
+      expiresAt: memory.expiresAt?.toISOString() ?? null
+    };
+  }
+  _fromPoint(point) {
+    const p = point.payload;
+    return {
+      id: p._id ?? point.id,
+      actorId: p.actorId,
+      memoryType: p.memoryType,
+      content: p.content,
+      importance: p.importance,
+      emotionalValence: p.emotionalValence ?? 0,
+      tags: p.tags ?? [],
+      embedding: point.vector,
+      sourceId: p.sourceId ?? void 0,
+      metadata: p.metadata ?? {},
+      expiresAt: p.expiresAt ? new Date(p.expiresAt) : void 0,
+      createdAt: new Date(p.createdAt)
+    };
+  }
+};
+
+// src/adapters/storage/neo4j.ts
+var Neo4jStorageAdapter = class {
+  driver;
+  database;
+  constructor(config) {
+    this.driver = config.driver;
+    this.database = config.database ?? "neo4j";
+  }
+  async initialize() {
+    const session = this.driver.session({ database: this.database });
+    try {
+      await session.run(
+        "CREATE CONSTRAINT memory_id IF NOT EXISTS FOR (m:Memory) REQUIRE m.id IS UNIQUE"
+      );
+      await session.run(
+        `CREATE VECTOR INDEX memory_embedding IF NOT EXISTS FOR (m:Memory) ON m.embedding
+         OPTIONS { indexConfig: { \`vector.dimensions\`: 1536, \`vector.similarity_function\`: "cosine" } }`
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = input.id ?? this.generateId();
+    const props = {
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      sourceId: input.sourceId ?? null,
+      metadata: JSON.stringify(input.metadata ?? {}),
+      expiresAt: input.expiresAt?.toISOString() ?? null,
+      createdAt: now,
+      embedding: input.embedding ?? null
+    };
+    const { createdAt: _, ...updateProps } = props;
+    const session = this.driver.session({ database: this.database });
+    try {
+      await session.run(
+        "MERGE (m:Memory {id: $id}) ON CREATE SET m += $props ON MATCH SET m += $updateProps",
+        { id, props, updateProps }
+      );
+    } finally {
+      await session.close();
+    }
+    return {
+      id,
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: new Date(now)
+    };
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const result = await session.run(
+        "MATCH (m:Memory {id: $id}) WHERE m.expiresAt IS NULL OR m.expiresAt > datetime() RETURN m",
+        { id }
+      );
+      if (result.records.length === 0) return null;
+      const raw = result.records[0].get("m");
+      const node = raw.properties ?? raw;
+      return this._nodeToMemory(node);
+    } finally {
+      await session.close();
+    }
+  }
+  async delete(id) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const check = await session.run("MATCH (m:Memory {id: $id}) RETURN m.id as id", { id });
+      if (check.records.length === 0) throw notFound("Memory", id);
+      await session.run("MATCH (m:Memory {id: $id}) DETACH DELETE m", { id });
+    } finally {
+      await session.close();
+    }
+  }
+  async deleteMany(ids) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const result = await session.run(
+        "UNWIND $ids AS mid MATCH (m:Memory {id: mid}) DETACH DELETE m RETURN count(m) as deleted",
+        { ids }
+      );
+      const record = result.records[0];
+      if (!record) return 0;
+      return record.get("deleted");
+    } finally {
+      await session.close();
+    }
+  }
+  async retrieve(query, embedding) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const limit = Math.floor(query.limit ?? 10);
+      const strategy = query.strategy ?? "hybrid";
+      if (strategy === "semantic" && embedding) {
+        return this._semanticRetrieve(session, embedding, query, limit);
+      }
+      const strLimit = String(limit);
+      let cypher;
+      const params = {};
+      const hasActor = query.actorId !== void 0;
+      switch (strategy) {
+        case "recent":
+          if (hasActor) {
+            cypher = "MATCH (m:Memory) WHERE m.actorId = $actorId RETURN m ORDER BY m.createdAt DESC LIMIT " + strLimit;
+            params.actorId = query.actorId;
+          } else {
+            cypher = "MATCH (m:Memory) RETURN m ORDER BY m.createdAt DESC LIMIT " + strLimit;
+          }
+          break;
+        case "important":
+          if (hasActor) {
+            cypher = "MATCH (m:Memory) WHERE m.actorId = $actorId RETURN m ORDER BY m.importance DESC LIMIT " + strLimit;
+            params.actorId = query.actorId;
+          } else {
+            cypher = "MATCH (m:Memory) RETURN m ORDER BY m.importance DESC LIMIT " + strLimit;
+          }
+          break;
+        case "hybrid":
+        default:
+          if (embedding) {
+            return this._semanticRetrieve(session, embedding, query, limit);
+          }
+          if (hasActor) {
+            cypher = "MATCH (m:Memory) WHERE m.actorId = $actorId RETURN m ORDER BY m.importance DESC, m.createdAt DESC LIMIT " + strLimit;
+            params.actorId = query.actorId;
+          } else {
+            cypher = "MATCH (m:Memory) RETURN m ORDER BY m.importance DESC, m.createdAt DESC LIMIT " + strLimit;
+          }
+          break;
+      }
+      const result = await session.run(cypher, params);
+      const memories = result.records.map((r) => {
+        const raw = r.get("m");
+        const node = raw.properties ?? raw;
+        return this._nodeToMemory(node);
+      });
+      return this._postFilter(memories, query);
+    } finally {
+      await session.close();
+    }
+  }
+  async count(filter) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const conditions = [];
+      const params = {};
+      if (filter?.actorId) {
+        conditions.push("m.actorId = $actorId");
+        params.actorId = filter.actorId;
+      }
+      if (filter?.memoryType) {
+        conditions.push("m.memoryType = $memoryType");
+        params.memoryType = filter.memoryType;
+      }
+      if (filter?.minImportance !== void 0) {
+        conditions.push("m.importance >= $minImportance");
+        params.minImportance = filter.minImportance;
+      }
+      const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const result = await session.run(
+        `MATCH (m:Memory) ${where} RETURN count(m) as count`,
+        params
+      );
+      const rawCount = result.records[0].get("count");
+      return typeof rawCount === "number" ? rawCount : Number(rawCount);
+    } finally {
+      await session.close();
+    }
+  }
+  async graphQuery(cypher, params) {
+    const session = this.driver.session({ database: this.database });
+    try {
+      const result = await session.run(cypher, params);
+      return result.records.map((r) => {
+        const obj = r.toObject();
+        const mKey = Object.keys(obj).find((k) => obj[k] && typeof obj[k] === "object" && "properties" in obj[k]);
+        if (mKey) {
+          const raw = obj[mKey];
+          const node = raw.properties ?? raw;
+          return this._nodeToMemory(node);
+        }
+        return this._nodeToMemory(obj);
+      });
+    } finally {
+      await session.close();
+    }
+  }
+  async close() {
+    await this.driver.close();
+  }
+  async _semanticRetrieve(session, embedding, query, limit) {
+    const hasActor = query.actorId !== void 0;
+    const strLimit = String(limit);
+    const cypher = hasActor ? `CALL db.index.vector.queryNodes('memory_embedding', ${strLimit}, $embedding) YIELD node, score
+         MATCH (node) WHERE node.actorId = $actorId
+         RETURN node ORDER BY score LIMIT ${strLimit}` : `CALL db.index.vector.queryNodes('memory_embedding', ${strLimit}, $embedding) YIELD node, score
+         RETURN node ORDER BY score LIMIT ${strLimit}`;
+    const params = { embedding };
+    if (hasActor) params.actorId = query.actorId;
+    const result = await session.run(cypher, params);
+    const memories = result.records.map((r) => {
+      const raw = r.get("node");
+      const node = raw.properties ?? raw;
+      return this._nodeToMemory(node);
+    });
+    return this._postFilter(memories, query);
+  }
+  _postFilter(memories, query) {
+    const now = /* @__PURE__ */ new Date();
+    let results = memories.filter((m) => !m.expiresAt || m.expiresAt > now);
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      results = results.filter((m) => query.memoryTypes.includes(m.memoryType));
+    }
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((m) => m.tags?.some((t) => query.tags.includes(t)));
+    }
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((m) => m.content.toLowerCase().includes(q));
+    }
+    return results;
+  }
+  _nodeToMemory(node) {
+    return {
+      id: node.id,
+      actorId: node.actorId,
+      memoryType: node.memoryType ?? "interaction",
+      content: node.content,
+      importance: node.importance ?? 0.5,
+      emotionalValence: node.emotionalValence ?? 0,
+      tags: Array.isArray(node.tags) ? node.tags : [],
+      embedding: node.embedding ?? void 0,
+      sourceId: node.sourceId ?? void 0,
+      metadata: typeof node.metadata === "string" ? JSON.parse(node.metadata) : node.metadata ?? {},
+      expiresAt: node.expiresAt ? new Date(node.expiresAt) : void 0,
+      createdAt: new Date(node.createdAt)
+    };
+  }
+};
+
+// src/adapters/storage/weaviate.ts
+var WeaviateStorageAdapter = class {
+  client;
+  className;
+  _collection = null;
+  _idToWv = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.client = config.client;
+    this.className = config.className ?? "MemstackMemory";
+  }
+  async initialize() {
+    this._collection = this.client.collections.get(this.className);
+  }
+  collection() {
+    if (!this._collection) {
+      this._collection = this.client.collections.get(this.className);
+    }
+    return this._collection;
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now
+    };
+    const wvId = await this.collection().data.insert({
+      id: crypto.randomUUID(),
+      properties: this._toProperties(memory),
+      vectors: input.embedding ?? new Array(1536).fill(0)
+    });
+    this._idToWv.set(memory.id, wvId);
+    return memory;
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const wvId = this._idToWv.get(id);
+    if (!wvId) return null;
+    const obj = await this.collection().query.fetchObjectById(wvId, { includeVector: true });
+    if (!obj) return null;
+    const memory = this._fromProperties(obj.properties, obj.vectors?.default ?? void 0);
+    if (memory.expiresAt && memory.expiresAt <= /* @__PURE__ */ new Date()) return null;
+    return memory;
+  }
+  async delete(id) {
+    const wvId = this._idToWv.get(id);
+    if (!wvId) throw notFound("Memory", id);
+    await this.collection().data.deleteById(wvId);
+    this._idToWv.delete(id);
+  }
+  async deleteMany(ids) {
+    let count = 0;
+    for (const id of ids) {
+      try {
+        await this.delete(id);
+        count++;
+      } catch {
+      }
+    }
+    return count;
+  }
+  async retrieve(query, embedding) {
+    const strategy = query.strategy ?? "recent";
+    const limit = query.limit ?? 10;
+    if ((strategy === "semantic" || strategy === "hybrid") && embedding) {
+      const filters2 = this._buildFilter(query);
+      const result2 = await this.collection().query.nearVector(embedding, {
+        limit: 100,
+        filters: filters2,
+        includeVector: true
+      });
+      let objects2 = result2.objects.map((o) => ({
+        ...this._fromProperties(o.properties, o.vectors?.default),
+        _score: o.metadata?.creationTimeUnix ?? 0
+      }));
+      objects2 = objects2.filter((o) => !o.expiresAt || o.expiresAt > /* @__PURE__ */ new Date());
+      if (query.actorId) {
+        objects2 = objects2.filter((o) => o.actorId === query.actorId);
+      }
+      if (strategy === "hybrid") {
+        objects2.sort((a, b) => b._score + b.importance - (a._score + a.importance));
+      }
+      return objects2.slice(0, limit);
+    }
+    const filters = this._buildFilter(query);
+    const result = await this.collection().query.fetchObjects({
+      limit: 1e4,
+      filters
+    });
+    let objects = result.objects.map((o) => ({
+      ...this._fromProperties(o.properties, o.vectors?.default),
+      _createdAt: o.properties.createdAt,
+      _importance: o.properties.importance ?? 0.5
+    }));
+    objects = objects.filter((o) => !o.expiresAt || o.expiresAt > /* @__PURE__ */ new Date());
+    if (query.actorId) {
+      objects = objects.filter((o) => o.actorId === query.actorId);
+    }
+    switch (strategy) {
+      case "recent":
+        objects.sort((a, b) => new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime());
+        break;
+      case "important":
+        objects.sort((a, b) => b._importance - a._importance);
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        objects.sort((a, b) => b._importance - a._importance || new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime());
+        break;
+    }
+    return objects.slice(0, limit);
+  }
+  async count(filter) {
+    const and = [];
+    if (filter?.actorId) {
+      and.push({ operator: "Equal", target: { property: "actorId" }, value: filter.actorId });
+    }
+    if (filter?.memoryType) {
+      and.push({ operator: "Equal", target: { property: "memoryType" }, value: filter.memoryType });
+    }
+    if (filter?.minImportance !== void 0) {
+      and.push({ operator: "GreaterThanEqual", target: { property: "importance" }, value: filter.minImportance });
+    }
+    const finalFilter = and.length === 0 ? void 0 : and.length === 1 ? and[0] : { operator: "And", filters: and };
+    const result = await this.collection().query.fetchObjects({
+      limit: 1e4,
+      filters: finalFilter
+    });
+    return result.objects.length;
+  }
+  async close() {
+  }
+  _buildFilter(query) {
+    const and = [];
+    if (query.actorId) {
+      and.push({ operator: "Equal", target: { property: "actorId" }, value: query.actorId });
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      if (query.memoryTypes.length === 1) {
+        and.push({ operator: "Equal", target: { property: "memoryType" }, value: query.memoryTypes[0] });
+      } else {
+        and.push({
+          operator: "Or",
+          filters: query.memoryTypes.map((t) => ({ operator: "Equal", target: { property: "memoryType" }, value: t }))
+        });
+      }
+    }
+    if (query.tags && query.tags.length > 0) {
+      if (query.tags.length === 1) {
+        and.push({ operator: "ContainsAny", target: { property: "tags" }, values: query.tags });
+      } else {
+        and.push({
+          operator: "Or",
+          filters: query.tags.map((t) => ({ operator: "ContainsAny", target: { property: "tags" }, values: [t] }))
+        });
+      }
+    }
+    if (query.query) {
+      and.push({ operator: "Like", target: { property: "content" }, value: `*${query.query}*` });
+    }
+    return and.length === 0 ? void 0 : and.length === 1 ? and[0] : { operator: "And", filters: and };
+  }
+  _toProperties(memory) {
+    return {
+      _memstackId: memory.id,
+      actorId: memory.actorId,
+      memoryType: memory.memoryType,
+      content: memory.content,
+      importance: memory.importance,
+      emotionalValence: memory.emotionalValence,
+      tags: memory.tags,
+      metadata: JSON.stringify(memory.metadata ?? {}),
+      sourceId: memory.sourceId ?? null,
+      expiresAt: memory.expiresAt?.toISOString() ?? null,
+      createdAt: memory.createdAt.toISOString()
+    };
+  }
+  _fromProperties(props, vectors) {
+    return {
+      id: props._memstackId ?? "",
+      actorId: props.actorId ?? "",
+      memoryType: props.memoryType ?? "interaction",
+      content: props.content ?? "",
+      importance: props.importance ?? 0.5,
+      emotionalValence: props.emotionalValence ?? 0,
+      tags: Array.isArray(props.tags) ? props.tags : [],
+      embedding: vectors,
+      sourceId: props.sourceId ?? void 0,
+      metadata: typeof props.metadata === "string" ? JSON.parse(props.metadata) : props.metadata ?? {},
+      expiresAt: props.expiresAt ? new Date(props.expiresAt) : void 0,
+      createdAt: new Date(props.createdAt ?? (/* @__PURE__ */ new Date()).toISOString())
+    };
+  }
+};
+
+// src/adapters/storage/lancedb.ts
+var LanceDBStorageAdapter = class {
+  connection;
+  table;
+  tableName;
+  _zeroVector;
+  constructor(config) {
+    if (!config.connection) {
+      throw configError("LanceDBStorageAdapter requires a LanceDB connection instance");
+    }
+    this.connection = config.connection;
+    this.tableName = config.tableName ?? "memstack";
+    this._zeroVector = new Array(1536).fill(0);
+  }
+  async initialize() {
+    const tables = await this.connection.tableNames();
+    if (!tables.includes(this.tableName)) {
+      this.table = await this.connection.createTable(this.tableName, []);
+    } else {
+      this.table = await this.connection.openTable(this.tableName);
+    }
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const id = input.id ?? this.generateId();
+    const row = {
+      id,
+      vector: input.embedding ?? this._zeroVector,
+      actor_id: input.actorId,
+      memory_type: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotional_valence: input.emotionalValence ?? 0,
+      tags: JSON.stringify(input.tags ?? []),
+      source_id: input.sourceId ?? "",
+      metadata: JSON.stringify(input.metadata ?? {}),
+      expires_at: input.expiresAt?.toISOString() ?? "",
+      created_at: now.toISOString()
+    };
+    await this.table.add([row]);
+    return {
+      id,
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now
+    };
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const results = await this.table.search(this._zeroVector).limit(1).where(`id = "${id}"`).execute();
+    if (results.length === 0) return null;
+    const row = results[0];
+    if (row.expires_at) {
+      const expiresAt = new Date(row.expires_at);
+      if (expiresAt <= /* @__PURE__ */ new Date()) {
+        await this.table.delete(`id = "${id}"`);
+        return null;
+      }
+    }
+    return this._rowToMemory(row);
+  }
+  async delete(id) {
+    const existing = await this.get(id);
+    if (!existing) throw notFound("Memory", id);
+    await this.table.delete(`id = "${id}"`);
+  }
+  async deleteMany(ids) {
+    const before = await this.table.countRows();
+    const inClause = ids.map((id) => `"${id}"`).join(", ");
+    await this.table.delete(`id IN (${inClause})`);
+    const after = await this.table.countRows();
+    return before - after;
+  }
+  async retrieve(query, embedding) {
+    const conditions = [];
+    if (query.actorId) {
+      conditions.push(`actor_id = "${query.actorId}"`);
+    }
+    const where = conditions.length > 0 ? conditions.join(" AND ") : "";
+    const isSemantic = (query.strategy === "semantic" || query.strategy === "hybrid") && embedding && embedding.length > 0;
+    const searchVec = isSemantic ? embedding : this._zeroVector;
+    const scanLimit = isSemantic ? query.limit ?? 10 : 1e4;
+    const results = await this.table.search(searchVec).limit(scanLimit).where(where).execute();
+    let rows = results;
+    const now = /* @__PURE__ */ new Date();
+    rows = rows.filter((r) => !r.expires_at || new Date(r.expires_at) > now);
+    if (query.actorId) {
+      rows = rows.filter((r) => r.actor_id === query.actorId);
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      rows = rows.filter((r) => query.memoryTypes.includes(r.memory_type));
+    }
+    if (query.tags && query.tags.length > 0) {
+      rows = rows.filter((r) => {
+        const tags = JSON.parse(r.tags);
+        return tags.some((t) => query.tags.includes(t));
+      });
+    }
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      rows = rows.filter((r) => r.content.toLowerCase().includes(q));
+    }
+    const limit = query.limit ?? 10;
+    if (isSemantic && query.strategy === "hybrid") {
+      rows.sort((a, b) => {
+        const scoreA = (a._distance ?? 0) + a.importance;
+        const scoreB = (b._distance ?? 0) + b.importance;
+        return scoreB - scoreA;
+      });
+    } else if (query.strategy === "recent") {
+      rows.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    } else if (query.strategy === "important") {
+      rows.sort((a, b) => b.importance - a.importance);
+    } else if (!isSemantic) {
+      rows.sort((a, b) => b.importance - a.importance || new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    }
+    return rows.slice(0, limit).map((r) => this._rowToMemory(r));
+  }
+  async count(filter) {
+    const conditions = [];
+    if (filter?.actorId) {
+      conditions.push(`actor_id = "${filter.actorId}"`);
+    }
+    const where = conditions.length > 0 ? conditions.join(" AND ") : "";
+    const results = await this.table.search(this._zeroVector).limit(1e4).where(where).execute();
+    const now = /* @__PURE__ */ new Date();
+    let rows = results.filter((r) => !r.expires_at || new Date(r.expires_at) > now);
+    if (filter?.actorId) {
+      rows = rows.filter((r) => r.actor_id === filter.actorId);
+    }
+    if (filter?.memoryType) {
+      rows = rows.filter((r) => r.memory_type === filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      rows = rows.filter((r) => r.importance >= filter.minImportance);
+    }
+    return rows.length;
+  }
+  async close() {
+  }
+  _rowToMemory(row) {
+    return {
+      id: row.id,
+      actorId: row.actor_id,
+      memoryType: row.memory_type,
+      content: row.content,
+      importance: row.importance,
+      emotionalValence: row.emotional_valence,
+      tags: row.tags ? JSON.parse(row.tags) : [],
+      embedding: row.vector && row.vector.length > 0 ? row.vector : void 0,
+      sourceId: row.source_id || void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      expiresAt: row.expires_at ? new Date(row.expires_at) : void 0,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
+// src/adapters/storage/mongodb.ts
+var MongoDBStorageAdapter = class {
+  collection;
+  vectorDimensions;
+  constructor(config) {
+    this.collection = config.collection;
+    this.vectorDimensions = config.vectorDimensions ?? 1536;
+  }
+  async initialize() {
+    try {
+      const col = this.collection;
+      if (col.createSearchIndex) {
+        await col.createSearchIndex({
+          name: "memstack_vector",
+          definition: {
+            mappings: {
+              dynamic: false,
+              fields: {
+                embedding: {
+                  type: "knnVector",
+                  dimensions: this.vectorDimensions,
+                  similarity: "cosine"
+                }
+              }
+            }
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now
+    };
+    await this.collection.insertOne(this.toDoc(memory));
+    return memory;
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const doc = await this.collection.findOne({ _id: id });
+    if (!doc) return null;
+    const memory = this.toMemory(doc);
+    if (memory.expiresAt && memory.expiresAt <= /* @__PURE__ */ new Date()) return null;
+    return memory;
+  }
+  async delete(id) {
+    const result = await this.collection.deleteOne({ _id: id });
+    if (result.deletedCount === 0) throw notFound("Memory", id);
+  }
+  async deleteMany(ids) {
+    const result = await this.collection.deleteMany({ _id: { $in: ids } });
+    return result.deletedCount;
+  }
+  async retrieve(query, embedding) {
+    if (query.strategy === "semantic" && embedding) {
+      return this.retrieveSemantic(query, embedding);
+    }
+    return this.retrieveStandard(query);
+  }
+  async count(filter) {
+    const mongoFilter = {};
+    if (filter?.actorId) mongoFilter.actorId = filter.actorId;
+    if (filter?.memoryType) mongoFilter.memoryType = filter.memoryType;
+    if (filter?.minImportance !== void 0) {
+      mongoFilter.importance = { $gte: filter.minImportance };
+    }
+    return this.collection.countDocuments(mongoFilter);
+  }
+  async close() {
+  }
+  async retrieveStandard(query) {
+    const filter = {};
+    if (query.actorId) filter.actorId = query.actorId;
+    if (query.tags && query.tags.length > 0) {
+      filter.tags = { $in: query.tags };
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      filter.memoryType = { $in: query.memoryTypes };
+    }
+    let sortObj;
+    switch (query.strategy) {
+      case "recent":
+        sortObj = { createdAt: -1 };
+        break;
+      case "important":
+        sortObj = { importance: -1 };
+        break;
+      default:
+        sortObj = { importance: -1, createdAt: -1 };
+        break;
+    }
+    const docs = await this.collection.find(filter).sort(sortObj).limit(1e4).toArray();
+    const now = /* @__PURE__ */ new Date();
+    let results = docs.map((doc) => this.toMemory(doc)).filter((m) => !m.expiresAt || m.expiresAt > now);
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((m) => m.content.toLowerCase().includes(q));
+    }
+    return results.slice(0, query.limit ?? 10);
+  }
+  async retrieveSemantic(query, embedding) {
+    try {
+      const filter = {};
+      if (query.actorId) filter.actorId = query.actorId;
+      const pipeline = [
+        {
+          $vectorSearch: {
+            index: "memstack_vector",
+            path: "embedding",
+            queryVector: embedding,
+            numCandidates: 100,
+            limit: query.limit ?? 10,
+            filter
+          }
+        }
+      ];
+      const docs = await this.collection.aggregate(pipeline).toArray();
+      const now = /* @__PURE__ */ new Date();
+      return docs.map((doc) => this.toMemory(doc)).filter((m) => !m.expiresAt || m.expiresAt > now);
+    } catch {
+      return this.retrieveStandard(query);
+    }
+  }
+  toMemory(doc) {
+    return {
+      id: doc._id,
+      actorId: doc.actorId,
+      memoryType: doc.memoryType,
+      content: doc.content,
+      importance: doc.importance,
+      emotionalValence: doc.emotionalValence,
+      tags: doc.tags,
+      embedding: doc.embedding,
+      sourceId: doc.sourceId,
+      metadata: doc.metadata,
+      expiresAt: doc.expiresAt,
+      createdAt: doc.createdAt
+    };
+  }
+  toDoc(memory) {
+    return {
+      _id: memory.id,
+      actorId: memory.actorId,
+      memoryType: memory.memoryType,
+      content: memory.content,
+      importance: memory.importance,
+      emotionalValence: memory.emotionalValence,
+      tags: memory.tags,
+      embedding: memory.embedding,
+      sourceId: memory.sourceId,
+      metadata: memory.metadata,
+      expiresAt: memory.expiresAt,
+      createdAt: memory.createdAt
+    };
+  }
+};
+
+// src/adapters/storage/sqlite.ts
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const dims = Math.min(a.length, b.length);
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < dims; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const mag = Math.sqrt(magA) * Math.sqrt(magB);
+  return mag === 0 ? 0 : dot / mag;
+}
+var SQLiteStorageAdapter = class {
+  db;
+  table;
+  vectorDimensions;
+  constructor(config) {
+    if (!config.db) {
+      throw configError("SQLiteStorageAdapter requires a better-sqlite3 database instance");
+    }
+    this.db = config.db;
+    this.table = config.tableName ?? "memstack_memories";
+    if (!/^[a-zA-Z0-9_]+$/.test(this.table)) {
+      throw configError(`Invalid table name: "${this.table}". Use only alphanumeric characters and underscores.`);
+    }
+    this.vectorDimensions = config.vectorDimensions ?? 1536;
+  }
+  async initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        id TEXT PRIMARY KEY,
+        actor_id TEXT NOT NULL,
+        memory_type TEXT NOT NULL DEFAULT 'interaction',
+        content TEXT NOT NULL,
+        importance REAL NOT NULL DEFAULT 0.5,
+        emotional_valence REAL NOT NULL DEFAULT 0,
+        tags TEXT NOT NULL DEFAULT '[]',
+        embedding TEXT,
+        source_id TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        expires_at TEXT,
+        created_at TEXT NOT NULL,
+        touched_at TEXT NOT NULL
+      )
+    `);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${this.table}_actor ON ${this.table}(actor_id)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${this.table}_created ON ${this.table}(created_at DESC)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${this.table}_importance ON ${this.table}(importance DESC)`);
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = input.id ?? this.generateId();
+    this.db.prepare(
+      `INSERT INTO ${this.table} (id, actor_id, memory_type, content, importance, emotional_valence, tags, embedding, source_id, metadata, expires_at, created_at, touched_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         content = excluded.content,
+         importance = excluded.importance,
+         emotional_valence = excluded.emotional_valence,
+         tags = excluded.tags,
+         embedding = excluded.embedding,
+         source_id = excluded.source_id,
+         metadata = excluded.metadata,
+         expires_at = excluded.expires_at,
+         touched_at = excluded.touched_at`
+    ).run(
+      id,
+      input.actorId,
+      input.memoryType ?? "interaction",
+      input.content,
+      input.importance ?? 0.5,
+      input.emotionalValence ?? 0,
+      JSON.stringify(input.tags ?? []),
+      input.embedding ? JSON.stringify(input.embedding) : null,
+      input.sourceId ?? null,
+      JSON.stringify(input.metadata ?? {}),
+      input.expiresAt?.toISOString() ?? null,
+      now,
+      now
+    );
+    return {
+      id,
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: new Date(now)
+    };
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const row = this.db.prepare(
+      `SELECT * FROM ${this.table} WHERE id = ? AND (expires_at IS NULL OR expires_at > ?)`
+    ).get(id, (/* @__PURE__ */ new Date()).toISOString());
+    if (!row) return null;
+    return this._rowToMemory(row);
+  }
+  async delete(id) {
+    const row = this.db.prepare(`SELECT id FROM ${this.table} WHERE id = ?`).get(id);
+    if (!row) throw notFound("Memory", id);
+    this.db.prepare(`DELETE FROM ${this.table} WHERE id = ?`).run(id);
+  }
+  async deleteMany(ids) {
+    const placeholders = ids.map(() => "?").join(", ");
+    const result = this.db.prepare(
+      `DELETE FROM ${this.table} WHERE id IN (${placeholders})`
+    ).run(...ids);
+    return result.changes;
+  }
+  async touch(id) {
+    const row = this.db.prepare(`SELECT id FROM ${this.table} WHERE id = ?`).get(id);
+    if (!row) throw notFound("Memory", id);
+    this.db.prepare(`UPDATE ${this.table} SET touched_at = ? WHERE id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  async retrieve(query, embedding) {
+    const conditions = ["(expires_at IS NULL OR expires_at > ?)"];
+    const params = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (query.actorId) {
+      conditions.push("actor_id = ?");
+      params.push(query.actorId);
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      const placeholders = query.memoryTypes.map(() => "?").join(", ");
+      conditions.push(`memory_type IN (${placeholders})`);
+      params.push(...query.memoryTypes);
+    }
+    if (query.createdAfter) {
+      conditions.push("created_at >= ?");
+      params.push(query.createdAfter.toISOString());
+    }
+    if (query.createdBefore) {
+      conditions.push("created_at <= ?");
+      params.push(query.createdBefore.toISOString());
+    }
+    const where = `WHERE ${conditions.join(" AND ")}`;
+    const hasSemantic = (query.strategy === "semantic" || query.strategy === "hybrid") && embedding && embedding.length > 0;
+    let orderBy;
+    switch (query.strategy) {
+      case "recent":
+        orderBy = "touched_at DESC";
+        break;
+      case "important":
+        orderBy = "importance DESC";
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        if (hasSemantic) {
+          orderBy = "touched_at DESC";
+        } else {
+          orderBy = "importance DESC, touched_at DESC";
+        }
+        break;
+    }
+    const limit = query.limit ?? 10;
+    const sql = `SELECT * FROM ${this.table} ${where} ORDER BY ${orderBy}`;
+    const rows = this.db.prepare(sql).all(...params);
+    let results = rows;
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((r) => r.content.toLowerCase().includes(q));
+    }
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((r) => {
+        const tags = JSON.parse(r.tags);
+        return tags.some((t) => query.tags.includes(t));
+      });
+    }
+    if (hasSemantic && embedding) {
+      const scored = results.filter((r) => r.embedding !== null).map((r) => {
+        const emb = JSON.parse(r.embedding);
+        const score = cosineSimilarity(embedding, emb);
+        return { row: r, score };
+      }).sort((a, b) => b.score - a.score);
+      if (query.strategy === "hybrid") {
+        scored.sort((a, b) => b.score + b.row.importance - (a.score + a.row.importance));
+      }
+      const topK = scored.slice(0, limit);
+      for (const { row } of topK) {
+        this.db.prepare(`UPDATE ${this.table} SET touched_at = ? WHERE id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), row.id);
+      }
+      return topK.map(({ row }) => this._rowToMemory(row));
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const limited = results.slice(0, limit);
+    for (const row of limited) {
+      this.db.prepare(`UPDATE ${this.table} SET touched_at = ? WHERE id = ?`).run(now, row.id);
+    }
+    return limited.map((r) => this._rowToMemory(r));
+  }
+  async count(filter) {
+    const conditions = ["(expires_at IS NULL OR expires_at > ?)"];
+    const params = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (filter?.actorId) {
+      conditions.push("actor_id = ?");
+      params.push(filter.actorId);
+    }
+    if (filter?.memoryType) {
+      conditions.push("memory_type = ?");
+      params.push(filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      conditions.push("importance >= ?");
+      params.push(filter.minImportance);
+    }
+    if (filter?.createdAfter) {
+      conditions.push("created_at >= ?");
+      params.push(filter.createdAfter.toISOString());
+    }
+    if (filter?.createdBefore) {
+      conditions.push("created_at <= ?");
+      params.push(filter.createdBefore.toISOString());
+    }
+    const where = conditions.join(" AND ");
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as count FROM ${this.table} WHERE ${where}`
+    ).get(...params);
+    return row?.count ?? 0;
+  }
+  async close() {
+    this.db.close();
+  }
+  _rowToMemory(row) {
+    return {
+      id: row.id,
+      actorId: row.actor_id,
+      memoryType: row.memory_type,
+      content: row.content,
+      importance: row.importance,
+      emotionalValence: row.emotional_valence,
+      tags: JSON.parse(row.tags),
+      embedding: row.embedding ? JSON.parse(row.embedding) : void 0,
+      sourceId: row.source_id ?? void 0,
+      metadata: JSON.parse(row.metadata),
+      expiresAt: row.expires_at ? new Date(row.expires_at) : void 0,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
 // src/adapters/llm/openai.ts
 var OpenAILLMAdapter = class {
   apiKey;
@@ -1634,7 +3835,6 @@ var AnthropicLLMAdapter = class {
   baseURL;
   defaultModel;
   defaultMaxTokens;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   sdk;
   constructor(config) {
     this.apiKey = config.apiKey;
@@ -1650,7 +3850,8 @@ var AnthropicLLMAdapter = class {
         const { default: Anthropic } = await import('@anthropic-ai/sdk');
         this.sdk = new Anthropic({ apiKey: this.apiKey, baseURL: this.baseURL });
       }
-      const response = await this.sdk.messages.create({
+      const sdk = this.sdk;
+      const response = await sdk.messages.create({
         model,
         system: request.system,
         messages: [{ role: "user", content: request.user }],
@@ -1681,6 +3882,7 @@ var OpenAIEmbeddingAdapter = class {
   baseURL;
   model;
   dimensions;
+  maxBatchSize = 2048;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.baseURL = config.baseURL ?? "https://api.openai.com/v1";
@@ -1689,8 +3891,8 @@ var OpenAIEmbeddingAdapter = class {
   }
   async embed(texts) {
     if (texts.length === 0) return [];
-    if (texts.length > 2048) {
-      throw new MemStackError("VALIDATION_ERROR", `Max 2048 texts per batch, got ${texts.length}`);
+    if (texts.length > this.maxBatchSize) {
+      throw new MemStackError("VALIDATION_ERROR", `Max ${this.maxBatchSize} texts per batch, got ${texts.length}`);
     }
     try {
       const response = await fetch(`${this.baseURL}/embeddings`, {
@@ -1737,6 +3939,7 @@ var CohereEmbeddingAdapter = class {
   baseURL;
   model;
   dimensions;
+  maxBatchSize = 96;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.baseURL = config.baseURL ?? "https://api.cohere.ai/v1";
@@ -1745,8 +3948,8 @@ var CohereEmbeddingAdapter = class {
   }
   async embed(texts) {
     if (texts.length === 0) return [];
-    if (texts.length > 96) {
-      throw new MemStackError("VALIDATION_ERROR", `Cohere max 96 texts per batch, got ${texts.length}`);
+    if (texts.length > this.maxBatchSize) {
+      throw new MemStackError("VALIDATION_ERROR", `Cohere max ${this.maxBatchSize} texts per batch, got ${texts.length}`);
     }
     try {
       const response = await fetch(`${this.baseURL}/embed`, {
@@ -1973,16 +4176,24 @@ var GroqLLMAdapter = class {
 
 exports.AnthropicLLMAdapter = AnthropicLLMAdapter;
 exports.CohereEmbeddingAdapter = CohereEmbeddingAdapter;
-exports.DiskStorage = DiskStorage;
+exports.DiskStorageAdapter = DiskStorageAdapter;
 exports.GroqLLMAdapter = GroqLLMAdapter;
-exports.InMemoryStorage = InMemoryStorage;
+exports.HybridStorageAdapter = HybridStorageAdapter;
+exports.InMemoryStorageAdapter = InMemoryStorageAdapter;
+exports.LanceDBStorageAdapter = LanceDBStorageAdapter;
+exports.MarkdownStorageAdapter = MarkdownStorageAdapter;
 exports.MemStack = MemStack;
 exports.MemStackError = MemStackError;
+exports.MongoDBStorageAdapter = MongoDBStorageAdapter;
+exports.Neo4jStorageAdapter = Neo4jStorageAdapter;
 exports.OllamaLLMAdapter = OllamaLLMAdapter;
 exports.OpenAIEmbeddingAdapter = OpenAIEmbeddingAdapter;
 exports.OpenAILLMAdapter = OpenAILLMAdapter;
-exports.PostgresStorage = PostgresStorage;
-exports.RedisStorage = RedisStorage;
+exports.PostgresStorageAdapter = PostgresStorageAdapter;
+exports.QdrantStorageAdapter = QdrantStorageAdapter;
+exports.RedisStorageAdapter = RedisStorageAdapter;
+exports.SQLiteStorageAdapter = SQLiteStorageAdapter;
+exports.WeaviateStorageAdapter = WeaviateStorageAdapter;
 exports.configError = configError;
 exports.notFound = notFound;
 exports.storageError = storageError;