@betterdb/memory 0.1.2 → 0.4.0

package/src/client/memory-store.ts

@@ -0,0 +1,406 @@
+import {
+  MemoryStore,
+  similarityFromDistance,
+  type ConsolidateOptions,
+  type ConsolidateResult,
+  type EmbedFn,
+  type MemoryItem,
+  type MemoryScope,
+  type MemoryStats,
+  type MemoryStoreClient,
+} from "@betterdb/agent-memory";
+import {
+  EpisodicMemorySchema,
+  type EpisodicMemory,
+} from "../memory/schema.js";
+import { getValkeyClient } from "./valkey.js";
+import { config } from "../config.js";
+
+const SECONDS_PER_DAY = 86400;
+
+// Store name fixes the index (`betterdb:mem:idx`) and key prefix
+// (`betterdb:mem:{id}`) that @betterdb/agent-memory derives internally.
+const STORE_NAME = "betterdb";
+
+// --- EpisodicMemory <-> MemoryItem mapping ---
+//
+// agent-memory's MemoryItem is flat (content + importance + tags + scope),
+// while the plugin's EpisodicMemory carries a structured `summary` plus
+// `branch` and an original `timestamp`. We embed `summary.oneLineSummary`
+// (so recall quality matches the current implementation, which embeds the
+// same string) and stash everything MemoryItem can't hold natively in the
+// free-form `source` field. The remaining fields map directly:
+//   project        -> namespace
+//   importanceScore -> importance
+//   accessCount     -> accessCount   (tracked natively, bumped on recall)
+//   lastAccessed    -> lastAccessedAt (tracked natively)
+
+interface SourcePayload {
+  summary: EpisodicMemory["summary"];
+  branch: string;
+  timestamp: string;
+}
+
+/** A recalled memory carrying its relevance and composite score for gating. */
+export interface ScoredMemory {
+  memory: EpisodicMemory;
+  /** Cosine similarity to the query, 0..1 (higher = more relevant). */
+  relevance: number;
+  /** Composite recall score (similarity + recency + importance). */
+  score: number;
+}
+
+export function episodicToSource(memory: EpisodicMemory): string {
+  const payload: SourcePayload = {
+    summary: memory.summary,
+    branch: memory.branch,
+    timestamp: memory.timestamp,
+  };
+  return JSON.stringify(payload);
+}
+
+/**
+ * Content-type tags for a memory, derived from which summary sections it fills.
+ * Stored natively (not in the opaque `source` blob) so recall can filter on
+ * them — e.g. surface only decisions, or only unresolved open threads.
+ */
+export function memoryTags(memory: EpisodicMemory): string[] {
+  const tags: string[] = [];
+  if (memory.summary.decisions.length > 0) tags.push("decision");
+  if (memory.summary.patterns.length > 0) tags.push("pattern");
+  if (memory.summary.problemsSolved.length > 0) tags.push("problem");
+  if (memory.summary.openThreads.length > 0) tags.push("open-thread");
+  return tags;
+}
+
+/**
+ * The text embedded for a memory. Previously only `oneLineSummary` was
+ * embedded, so recall could never see the structured detail (decisions,
+ * patterns, problems, open threads) — the single biggest recall-quality limit.
+ * We fold those into the vector here. `filesChanged` is deliberately omitted:
+ * bare file paths are generic and dominate the similarity band with noise.
+ */
+export function buildEmbedText(memory: EpisodicMemory): string {
+  const s = memory.summary;
+  const parts: string[] = [s.oneLineSummary];
+  if (s.decisions.length > 0) parts.push(`Decisions: ${s.decisions.join("; ")}`);
+  if (s.patterns.length > 0) parts.push(`Patterns: ${s.patterns.join("; ")}`);
+  if (s.problemsSolved.length > 0) {
+    const solved = s.problemsSolved
+      .map((p) => `${p.problem} → ${p.resolution}`)
+      .join("; ");
+    parts.push(`Problems solved: ${solved}`);
+  }
+  if (s.openThreads.length > 0) {
+    parts.push(`Open threads: ${s.openThreads.join("; ")}`);
+  }
+  return parts.join("\n");
+}
+
+export function itemToEpisodic(item: MemoryItem): EpisodicMemory | null {
+  let summary: EpisodicMemory["summary"];
+  let branch: string;
+  let timestamp: string;
+
+  const payload = parseSourcePayload(item.source);
+  if (payload) {
+    summary = payload.summary;
+    branch = payload.branch;
+    timestamp = payload.timestamp;
+  } else {
+    // A flat item with no SourcePayload — e.g. a memory produced by
+    // MemoryStore.consolidate(), whose `source` is its own marker, not our
+    // JSON. Synthesize a minimal episodic memory from the content so merged
+    // summaries stay first-class for recall, listing, and injection.
+    summary = {
+      decisions: [],
+      patterns: [],
+      problemsSolved: [],
+      openThreads: [],
+      filesChanged: [],
+      oneLineSummary: item.content,
+    };
+    branch = "consolidated";
+    timestamp = new Date(item.createdAt).toISOString();
+  }
+
+  const parsed = EpisodicMemorySchema.safeParse({
+    memoryId: item.id,
+    project: item.namespace ?? "unknown",
+    branch,
+    timestamp,
+    summary,
+    importanceScore: item.importance,
+    accessCount: item.accessCount,
+    lastAccessed: new Date(item.lastAccessedAt).toISOString(),
+  });
+
+  return parsed.success ? parsed.data : null;
+}
+
+function parseSourcePayload(source: string | undefined): SourcePayload | null {
+  if (!source) return null;
+  try {
+    const parsed = JSON.parse(source) as Partial<SourcePayload>;
+    if (parsed && typeof parsed === "object" && parsed.summary) {
+      return parsed as SourcePayload;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// --- Adapter ---
+//
+// Drop-in replacement for the episodic-vector subset of ValkeyClient, backed
+// by @betterdb/agent-memory's MemoryStore. Knowledge entries and work queues
+// stay on the existing ValkeyClient — they have no MemoryStore analog.
+export class PluginMemoryStore {
+  private readonly store: MemoryStore;
+
+  constructor(client: MemoryStoreClient, embed?: EmbedFn) {
+    this.store = new MemoryStore({
+      client,
+      name: STORE_NAME,
+      embedFn: embed,
+      // Composite-score decay/blend from plugin config. This is the single
+      // time-decay in the system (recency, applied at query time) — there is
+      // no separate importance-aging pass. configRefresh:false keeps these
+      // values fixed rather than letting a Valkey config key override them.
+      halfLifeSeconds: config.recall.halfLifeDays * SECONDS_PER_DAY,
+      weights: {
+        similarity: config.recall.weightSimilarity,
+        recency: config.recall.weightRecency,
+        importance: config.recall.weightImportance,
+      },
+      // The plugin owns its own analytics/discovery story; keep the store quiet
+      // and offline so it pulls in no posthog/otel network behavior.
+      discovery: false,
+      configRefresh: false,
+      analytics: { disabled: true },
+    });
+  }
+
+  /** Create the `betterdb:mem:idx` vector index if absent (idempotent). */
+  ensureIndex(): Promise<void> {
+    return this.store.ensureIndex();
+  }
+
+  /**
+   * Store an episodic memory and return its generated id. The vector is derived
+   * from {@link buildEmbedText} (summary + structured detail) inside
+   * MemoryStore — callers no longer precompute an embedding. The full episodic
+   * memory is preserved in `source` for reconstruction; the embed text only
+   * shapes the vector.
+   */
+  storeMemory(memory: EpisodicMemory): Promise<string> {
+    return this.store.remember(buildEmbedText(memory), {
+      importance: memory.importanceScore,
+      namespace: memory.project,
+      // Branch as the native thread scope; content-type tags for filtered
+      // recall. Both are queryable, unlike the free-form `source` payload.
+      threadId: memory.branch,
+      tags: memoryTags(memory),
+      source: episodicToSource(memory),
+    });
+  }
+
+  /**
+   * KNN recall ranked by MemoryStore's composite score. Unlike the raw store,
+   * this returns each memory *with* its relevance so callers can gate on it —
+   * `relevance` is cosine similarity (0..1, higher = closer) derived from the
+   * hit's raw distance; `score` is the composite (similarity + recency +
+   * importance). Omit `project` to search across all namespaces; pass `branch`
+   * to scope to a git branch (native thread) and `tags` to filter by
+   * content type.
+   */
+  async recall(
+    query: string,
+    opts: {
+      project?: string;
+      branch?: string;
+      tags?: string[];
+      k: number;
+      threshold?: number;
+      reinforce?: boolean;
+    },
+  ): Promise<ScoredMemory[]> {
+    const hits = await this.store.recall(query, {
+      ...(opts.project !== undefined ? { namespace: opts.project } : {}),
+      ...(opts.branch !== undefined ? { threadId: opts.branch } : {}),
+      ...(opts.tags !== undefined && opts.tags.length > 0
+        ? { tags: opts.tags }
+        : {}),
+      k: opts.k,
+      ...(opts.threshold !== undefined ? { threshold: opts.threshold } : {}),
+      reinforce: opts.reinforce ?? true,
+    });
+    const out: ScoredMemory[] = [];
+    for (const hit of hits) {
+      const memory = itemToEpisodic(hit.item);
+      if (memory) {
+        out.push({
+          memory,
+          score: hit.score,
+          relevance: similarityFromDistance(hit.similarity),
+        });
+      }
+    }
+    return out;
+  }
+
+  /** KNN recall from a precomputed embedding (see {@link recall}). */
+  async searchMemories(
+    embedding: number[],
+    project: string,
+    topK: number,
+  ): Promise<EpisodicMemory[]> {
+    const hits = await this.store.recallByVector(embedding, {
+      namespace: project,
+      k: topK,
+    });
+    return hits
+      .map((hit) => itemToEpisodic(hit.item))
+      .filter((m): m is EpisodicMemory => m !== null);
+  }
+
+  /**
+   * List stored memories, optionally scoped to `project` and filtered by a
+   * minimum importance. Paginates through MemoryStore.list so callers that
+   * scan all memories (open-thread aggregation, distillation) get the full set.
+   * Pass `max` to stop early once that many matches are collected, so callers
+   * that only need a bounded slice don't materialize the whole store.
+   */
+  async listMemories(
+    project?: string,
+    minImportance?: number,
+    max?: number,
+  ): Promise<EpisodicMemory[]> {
+    const out: EpisodicMemory[] = [];
+    const limit = 100;
+    let offset = 0;
+
+    for (;;) {
+      const { items, total } = await this.store.list({
+        namespace: project,
+        limit,
+        offset,
+      });
+      if (items.length === 0) break;
+
+      for (const item of items) {
+        const memory = itemToEpisodic(item);
+        if (!memory) continue;
+        if (minImportance !== undefined && memory.importanceScore < minImportance) {
+          continue;
+        }
+        out.push(memory);
+        if (max !== undefined && out.length >= max) return out;
+      }
+
+      offset += items.length;
+      if (offset >= total) break;
+    }
+
+    return out;
+  }
+
+  /**
+   * List memories matching a scope (project namespace, branch thread, and/or
+   * content-type tags) using the SAME native index filter as
+   * {@link forgetByScope} — so a `listByScope` preview is exactly the set a
+   * `forgetByScope` with the same scope would delete. Unlike {@link listMemories}
+   * (which filters summary-derived tags in memory), this queries native tags,
+   * so memories stored before native tagging are matched identically by both.
+   */
+  async listByScope(scope: {
+    project?: string;
+    branch?: string;
+    tags?: string[];
+  }): Promise<EpisodicMemory[]> {
+    const out: EpisodicMemory[] = [];
+    const limit = 100;
+    let offset = 0;
+
+    for (;;) {
+      const { items, total } = await this.store.list({
+        ...(scope.project !== undefined ? { namespace: scope.project } : {}),
+        ...(scope.branch !== undefined ? { threadId: scope.branch } : {}),
+        ...(scope.tags !== undefined && scope.tags.length > 0
+          ? { tags: scope.tags }
+          : {}),
+        limit,
+        offset,
+      });
+      if (items.length === 0) break;
+
+      for (const item of items) {
+        const memory = itemToEpisodic(item);
+        if (memory) out.push(memory);
+      }
+
+      offset += items.length;
+      if (offset >= total) break;
+    }
+
+    return out;
+  }
+
+  /**
+   * Merge a selection of memories into one summary memory (and delete the
+   * sources). Selection criteria — scope, age, or max importance — are passed
+   * through to MemoryStore.consolidate.
+   */
+  consolidate(options: ConsolidateOptions): Promise<ConsolidateResult> {
+    return this.store.consolidate(options);
+  }
+
+  async getMemory(memoryId: string): Promise<EpisodicMemory | null> {
+    const item = await this.store.get(memoryId);
+    return item ? itemToEpisodic(item) : null;
+  }
+
+  async deleteMemory(memoryId: string): Promise<void> {
+    await this.store.forget(memoryId);
+  }
+
+  /**
+   * Bulk-delete every memory matching a scope (project namespace, branch
+   * thread, and/or tags). Returns the number deleted. At least one scope field
+   * should be set — an empty scope would match the whole store.
+   */
+  forgetByScope(scope: {
+    project?: string;
+    branch?: string;
+    tags?: string[];
+  }): Promise<number> {
+    const s: MemoryScope & { tags?: string[] } = {};
+    if (scope.project !== undefined) s.namespace = scope.project;
+    if (scope.branch !== undefined) s.threadId = scope.branch;
+    if (scope.tags !== undefined && scope.tags.length > 0) s.tags = scope.tags;
+    return this.store.forgetByScope(s);
+  }
+
+  /** Live store stats: item count, evictions, and active composite config. */
+  stats(): Promise<MemoryStats> {
+    return this.store.stats();
+  }
+
+  close(): Promise<void> {
+    return this.store.close();
+  }
+}
+
+/**
+ * Shared accessor for the episodic-vector store. Reuses the singleton
+ * ValkeyClient's connection (its `.call()` satisfies MemoryStoreClient) so the
+ * whole plugin runs on one iovalkey socket. Pass `embed` when the caller will
+ * remember/recall/ensureIndex; read-only callers (list/get/delete) may omit it.
+ */
+export async function getPluginMemoryStore(
+  embed?: EmbedFn,
+): Promise<PluginMemoryStore> {
+  const valkey = await getValkeyClient();
+  return new PluginMemoryStore(valkey.redis, embed);
+}

package/src/client/model.ts

@@ -74,6 +74,7 @@ export { AnthropicSummarizeClient } from "./providers/anthropic.js";
 export { VoyageEmbedClient } from "./providers/voyage.js";
 export { GroqEmbedClient, GroqSummarizeClient } from "./providers/groq.js";
 export { TogetherEmbedClient, TogetherSummarizeClient } from "./providers/together.js";
+export { LocalEmbedClient } from "./providers/local.js";
 export { buildSummarizePrompt } from "./providers/_prompt.js";
 
 // --- Provider Detection ---
@@ -146,15 +147,10 @@ async function resolveEmbedProvider(
     return new TogetherEmbedClient(p.togetherKey);
   }
 
-  throw new Error(
-    `No embedding provider available. Options:\n` +
-      `  1. Install Ollama and run: ollama pull mxbai-embed-large\n` +
-      `  2. Set VOYAGE_API_KEY for Voyage AI (voyage-3, dim=1024)\n` +
-      `  3. Set OPENAI_API_KEY for OpenAI (text-embedding-3-small, dim=1536)\n` +
-      `  4. Set GROQ_API_KEY for Groq (nomic-embed-text-v1_5, dim=768)\n` +
-      `  5. Set TOGETHER_API_KEY for Together AI (m2-bert-80M-8k-retrieval, dim=768)\n\n` +
-      `Note: ANTHROPIC_API_KEY does not provide embeddings — pair it with another embed provider.`,
-  );
+  // On-device fallback: zero-config, no API key, no service. Ensures a fresh
+  // install produces embeddings even with nothing else installed.
+  const { LocalEmbedClient } = await import("./providers/local.js");
+  return new LocalEmbedClient();
 }
 
 async function resolveSummarizeProvider(
@@ -217,6 +213,10 @@ function createExplicitEmbedProvider(
   p: typeof config.providers,
 ): ModelClient {
   switch (name) {
+    case "local": {
+      const { LocalEmbedClient } = require("./providers/local.js");
+      return new LocalEmbedClient();
+    }
     case "ollama": {
       const { OllamaModelClient } = require("./providers/ollama.js");
       return new OllamaModelClient(PRESET_CLEAN, config.ollama.url);
@@ -242,7 +242,7 @@ function createExplicitEmbedProvider(
       return new TogetherEmbedClient(p.togetherKey);
     }
     default:
-      throw new Error(`Unknown embed provider: ${name}. Valid: ollama, openai, voyage, groq, together`);
+      throw new Error(`Unknown embed provider: ${name}. Valid: local, ollama, openai, voyage, groq, together`);
   }
 }
 

package/src/client/providers/local.ts

@@ -0,0 +1,58 @@
+import type { SessionSummary } from "../../memory/schema.js";
+import type { ModelClient, ModelPreset } from "../model.js";
+
+// On-device embeddings via @xenova/transformers — no API key, no running
+// service. Weights (all-MiniLM-L6-v2, Apache-2.0, 384-dim) download once on
+// first use and are cached under the transformers cache dir thereafter.
+
+const MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+const EMBED_DIM = 384;
+
+type FeatureExtractor = (
+  text: string,
+  options: { pooling: "mean"; normalize: boolean },
+) => Promise<{ data: Float32Array }>;
+
+interface TransformersModule {
+  pipeline(
+    task: "feature-extraction",
+    model: string,
+  ): Promise<FeatureExtractor>;
+}
+
+// Lazy singleton: the model loads once and is reused across embed calls, and
+// @xenova/transformers is only imported when local embeddings are actually used.
+let extractorPromise: Promise<FeatureExtractor> | null = null;
+
+function getExtractor(): Promise<FeatureExtractor> {
+  if (!extractorPromise) {
+    extractorPromise = import("@xenova/transformers").then((mod) =>
+      (mod as unknown as TransformersModule).pipeline(
+        "feature-extraction",
+        MODEL_ID,
+      ),
+    );
+  }
+  return extractorPromise;
+}
+
+export class LocalEmbedClient implements ModelClient {
+  readonly embedDim = EMBED_DIM;
+  readonly preset: ModelPreset = {
+    embedModel: MODEL_ID,
+    summarizeModel: "n/a",
+    embedDim: EMBED_DIM,
+  };
+
+  async embed(text: string): Promise<number[]> {
+    const extract = await getExtractor();
+    const output = await extract(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+
+  async summarize(_transcript: string): Promise<SessionSummary> {
+    throw new Error(
+      "Local embeddings provider does not summarize — configure a summarize provider (Ollama, Anthropic, OpenAI, Groq, or Together)",
+    );
+  }
+}

package/src/client/valkey.ts

@@ -31,6 +31,15 @@ export class ValkeyClient {
     this.client = client;
   }
 
+  /**
+   * The underlying iovalkey connection. Exposed so the episodic-vector path
+   * (PluginMemoryStore) can share this single connection instead of opening a
+   * second one — its `.call()` satisfies MemoryStoreClient.
+   */
+  get redis(): Redis {
+    return this.client;
+  }
+
   // --- Index Management ---
 
   async assertEmbedDim(expectedDim: number, providerLabel?: string): Promise<void> {

package/src/config.ts

@@ -1,17 +1,21 @@
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 
+const CONFIG_PATH = join(
+  process.env["HOME"] ?? process.env["USERPROFILE"] ?? "",
+  ".betterdb",
+  "memory.json",
+);
+
 /**
  * Load saved config from ~/.betterdb/memory.json as fallback for env vars.
  * This allows compiled binaries (hooks, MCP server) to work without
  * requiring env vars to be set — config is saved during `install`.
  */
 const _fileConfig: Record<string, string> = (() => {
-  const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const p = join(home, ".betterdb", "memory.json");
-  if (!existsSync(p)) return {};
+  if (!existsSync(CONFIG_PATH)) return {};
   try {
-    const data: unknown = JSON.parse(readFileSync(p, "utf-8"));
+    const data: unknown = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
     if (typeof data !== "object" || data === null) return {};
     const result: Record<string, string> = {};
     for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
@@ -42,16 +46,39 @@ export const config = {
   },
   memory: {
     maxContextMemories: Number(env("BETTERDB_MAX_CONTEXT_MEMORIES") ?? 5),
-    decayRate: Number(env("BETTERDB_DECAY_RATE") ?? 0.95),
     compressThreshold: Number(env("BETTERDB_COMPRESS_THRESHOLD") ?? 0.3),
     distillMinSessions: Number(env("BETTERDB_DISTILL_MIN_SESSIONS") ?? 5),
     contextFile: env("BETTERDB_CONTEXT_FILE") ?? ".betterdb_context.md",
     agingIntervalHours: Number(env("BETTERDB_AGING_INTERVAL_HOURS") ?? 6),
   },
+  recall: {
+    // Relative gate — model-agnostic (embed models compress cosine similarity
+    // into different bands, so absolute thresholds don't transfer). `floor`
+    // drops genuine noise and loosens the store's own distance gate; `margin`
+    // keeps hits within that similarity of the top match; `separation` is the
+    // top-vs-next gap above which a result is "high" confidence.
+    floor: Number(env("BETTERDB_RECALL_FLOOR") ?? 0.5),
+    margin: Number(env("BETTERDB_RECALL_MARGIN") ?? 0.05),
+    separation: Number(env("BETTERDB_RECALL_SEPARATION") ?? 0.04),
+    // Over-fetch pool sizes: rung-1 (project) and rung-2/3 (wider / cross).
+    poolK: Number(env("BETTERDB_RECALL_POOL_K") ?? 10),
+    poolKWide: Number(env("BETTERDB_RECALL_POOL_K_WIDE") ?? 20),
+    // Allow the ladder / search_context to fall back to cross-project scope.
+    allowCrossProject: env("BETTERDB_ALLOW_CROSS_PROJECT") !== "false",
+    // Composite recall scoring, owned by @betterdb/agent-memory: a weighted
+    // blend of semantic similarity, recency (half-life decay), and importance.
+    // Recency is the ONE time-decay in the system — it replaces the old, unused
+    // per-day `decayRate`. `halfLifeDays` is the age at which a memory's recency
+    // term halves; weights (defaults match the store's) blend the three terms.
+    halfLifeDays: Number(env("BETTERDB_RECALL_HALF_LIFE_DAYS") ?? 7),
+    weightSimilarity: Number(env("BETTERDB_RECALL_WEIGHT_SIMILARITY") ?? 0.6),
+    weightRecency: Number(env("BETTERDB_RECALL_WEIGHT_RECENCY") ?? 0.25),
+    weightImportance: Number(env("BETTERDB_RECALL_WEIGHT_IMPORTANCE") ?? 0.15),
+  },
   allowRemoteFallback: env("BETTERDB_ALLOW_REMOTE_FALLBACK") !== "false",
   providers: {
     embedProvider: env("BETTERDB_EMBED_PROVIDER") as
-      | "ollama" | "openai" | "voyage" | "groq" | "together"
+      | "local" | "ollama" | "openai" | "voyage" | "groq" | "together"
       | undefined,
     summarizeProvider: env("BETTERDB_SUMMARIZE_PROVIDER") as
       | "ollama" | "openai" | "anthropic" | "groq" | "together"
@@ -65,3 +92,8 @@ export const config = {
 } as const;
 
 export type Config = typeof config;
+
+/** Returns true if ~/.betterdb/memory.json exists (i.e. setup has been run). */
+export function isConfigured(): boolean {
+  return existsSync(CONFIG_PATH);
+}

package/src/hooks/post-tool.ts

@@ -1,6 +1,7 @@
 import { readRawPayload, runHook } from "./_utils.js";
 import { appendFile } from "node:fs/promises";
 import type { SessionEvent } from "../memory/schema.js";
+import { isConfigured } from "../config.js";
 
 /**
  * PostToolUse hook: Records tool call results to a temp JSONL file.
@@ -13,6 +14,7 @@ import type { SessionEvent } from "../memory/schema.js";
  * The JSONL file is read by session-end.ts to build the session transcript.
  */
 runHook(async () => {
+  if (!isConfigured()) return;
   const payload = await readRawPayload();
   const sessionId = payload["session_id"] as string;
   const toolName = (payload["tool_name"] as string) ?? "unknown";

package/src/hooks/pre-tool.ts

@@ -1,6 +1,7 @@
 import { readRawPayload, runHook } from "./_utils.js";
-import { getValkeyClient } from "../client/valkey.js";
-import { config } from "../config.js";
+import { getPluginMemoryStore } from "../client/memory-store.js";
+import { getCwdProject } from "../memory/capture.js";
+import { config, isConfigured } from "../config.js";
 
 /**
  * PreToolUse hook: Checks for file history and appends notes to context.
@@ -11,6 +12,7 @@ import { config } from "../config.js";
  * - Exit 0 to allow, exit 2 to block
  */
 runHook(async () => {
+  if (!isConfigured()) return;
   const payload = await readRawPayload();
   const toolInput = payload["tool_input"] as Record<string, unknown> | undefined;
 
@@ -22,21 +24,20 @@ runHook(async () => {
 
   if (!filePath) return;
 
-  let valkeyClient;
+  let store;
   try {
-    valkeyClient = await getValkeyClient();
+    store = await getPluginMemoryStore();
   } catch {
     return; // Valkey unavailable — skip silently
   }
 
-  // Scan for memories that reference this file
-  const memoryIds = await valkeyClient.listMemoryIds();
+  // Scan the current project's recent memories for ones that reference this
+  // file. Scope to the project and cap at 50 so this stays cheap on every tool
+  // call instead of materializing the whole store.
+  const memories = await store.listMemories(getCwdProject(), undefined, 50);
   const relevantNotes: string[] = [];
 
-  for (const id of memoryIds.slice(0, 50)) {
-    const memory = await valkeyClient.getMemory(id);
-    if (!memory) continue;
-
+  for (const memory of memories) {
     if (memory.summary.filesChanged.some((f) => f.includes(filePath) || filePath.includes(f))) {
       relevantNotes.push(
         `- ${memory.summary.oneLineSummary} (${memory.timestamp.split("T")[0]})`,
@@ -55,5 +56,5 @@ runHook(async () => {
     await Bun.write(config.memory.contextFile, existing + note);
   }
 
-  await valkeyClient.quit();
+  await store.close();
 });