feat(plugin): proactive memory embedding

Embed memories immediately after ctx_memory write (fire-and-forget)
and sweep for unembedded memories on the periodic dream timer. The
lazy search-time fallback remains as a safety net.

Author: ualtinok

packages/plugin/src/features/magic-context/memory/embedding.ts

@@ -1,3 +1,4 @@
+import type { Database } from "bun:sqlite";
 import type { EmbeddingConfig } from "../../../config/schema/magic-context";
 import { DEFAULT_LOCAL_EMBEDDING_MODEL } from "../../../config/schema/magic-context";
 import { log } from "../../../shared/logger";
@@ -6,6 +7,7 @@ import { LocalEmbeddingProvider } from "./embedding-local";
 import { OpenAICompatibleEmbeddingProvider } from "./embedding-openai";
 import type { EmbeddingProvider } from "./embedding-provider";
 import { computeNormalizedHash } from "./normalize-hash";
+import { saveEmbedding } from "./storage-memory-embeddings";
 
 const DEFAULT_EMBEDDING_CONFIG: EmbeddingConfig = {
     provider: "local",
@@ -15,6 +17,36 @@ const DEFAULT_EMBEDDING_CONFIG: EmbeddingConfig = {
 let embeddingConfig: EmbeddingConfig = DEFAULT_EMBEDDING_CONFIG;
 let provider: EmbeddingProvider | null = null;
 
+type PreparedStatement = ReturnType<Database["prepare"]>;
+
+interface UnembeddedMemoryRow {
+    id: number;
+    content: string;
+}
+
+const loadUnembeddedMemoriesStatements = new WeakMap<Database, PreparedStatement>();
+
+function isUnembeddedMemoryRow(row: unknown): row is UnembeddedMemoryRow {
+    if (row === null || typeof row !== "object") {
+        return false;
+    }
+
+    const candidate = row as Record<string, unknown>;
+    return typeof candidate.id === "number" && typeof candidate.content === "string";
+}
+
+function getLoadUnembeddedMemoriesStatement(db: Database): PreparedStatement {
+    let stmt = loadUnembeddedMemoriesStatements.get(db);
+    if (!stmt) {
+        stmt = db.prepare(
+            "SELECT m.id AS id, m.content AS content FROM memories m LEFT JOIN memory_embeddings me ON m.id = me.memory_id WHERE m.project_path = ? AND m.status = 'active' AND me.memory_id IS NULL LIMIT ?",
+        );
+        loadUnembeddedMemoriesStatements.set(db, stmt);
+    }
+
+    return stmt;
+}
+
 function resolveEmbeddingConfig(config?: EmbeddingConfig): EmbeddingConfig {
     if (!config || config.provider === "local") {
         return {
@@ -140,6 +172,55 @@ export async function embedBatch(texts: string[]): Promise<(Float32Array | null)
     return currentProvider.embedBatch(texts);
 }
 
+export async function embedUnembeddedMemories(
+    db: Database,
+    projectPath: string,
+    config: EmbeddingConfig,
+    batchSize = 10,
+): Promise<number> {
+    const normalizedBatchSize = Math.max(1, Math.floor(batchSize));
+    const resolvedConfig = resolveEmbeddingConfig(config);
+
+    if (resolvedConfig.provider === "off") {
+        return 0;
+    }
+
+    initializeEmbedding(resolvedConfig);
+
+    const memories = getLoadUnembeddedMemoriesStatement(db)
+        .all(projectPath, normalizedBatchSize)
+        .filter(isUnembeddedMemoryRow);
+    if (memories.length === 0) {
+        return 0;
+    }
+
+    try {
+        const embeddings = await embedBatch(memories.map((memory) => memory.content));
+        const modelId = getEmbeddingModelId();
+        if (modelId === "off") {
+            return 0;
+        }
+
+        let embeddedCount = 0;
+        db.transaction(() => {
+            for (const [index, memory] of memories.entries()) {
+                const embedding = embeddings[index];
+                if (!embedding) {
+                    continue;
+                }
+
+                saveEmbedding(db, memory.id, embedding, modelId);
+                embeddedCount += 1;
+            }
+        })();
+
+        return embeddedCount;
+    } catch (error) {
+        log("[magic-context] failed to proactively embed missing memories:", error);
+        return 0;
+    }
+}
+
 export function getEmbeddingModelId(): string {
     return getOrCreateProvider()?.modelId ?? "off";
 }

packages/plugin/src/index.ts

@@ -34,10 +34,13 @@ const plugin: Plugin = async (ctx) => {
 
     // Start independent dream schedule timer at plugin level (not inside hooks)
     // so overnight dreaming works even when the user isn't chatting.
-    if (pluginConfig.dreamer) {
+    if (pluginConfig.enabled) {
         startDreamScheduleTimer({
+            directory: ctx.directory,
             client: ctx.client,
             dreamerConfig: pluginConfig.dreamer,
+            embeddingConfig: pluginConfig.embedding,
+            memoryEnabled: pluginConfig.memory?.enabled === true,
         });
     }
 

packages/plugin/src/plugin/dream-timer.ts

@@ -1,5 +1,7 @@
-import type { DreamerConfig } from "../config/schema/magic-context";
+import type { DreamerConfig, EmbeddingConfig } from "../config/schema/magic-context";
 import { checkScheduleAndEnqueue, processDreamQueue } from "../features/magic-context/dreamer";
+import { embedUnembeddedMemories } from "../features/magic-context/memory/embedding";
+import { resolveProjectIdentity } from "../features/magic-context/memory/project-identity";
 import { openDatabase } from "../features/magic-context/storage";
 import { log } from "../shared/logger";
 import type { PluginContext } from "./types";
@@ -15,17 +17,42 @@ const DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
  * The timer is unref'd so it doesn't prevent the process from exiting.
  */
 export function startDreamScheduleTimer(args: {
+    directory: string;
     client: PluginContext["client"];
-    dreamerConfig: DreamerConfig;
+    dreamerConfig?: DreamerConfig;
+    embeddingConfig: EmbeddingConfig;
+    memoryEnabled: boolean;
 }): (() => void) | undefined {
-    const { client, dreamerConfig } = args;
+    const { client, directory, dreamerConfig, embeddingConfig, memoryEnabled } = args;
+    const dreamingEnabled = Boolean(dreamerConfig?.enabled && dreamerConfig.schedule?.trim());
+    const embeddingSweepEnabled = memoryEnabled && embeddingConfig.provider !== "off";
 
-    if (!dreamerConfig.enabled || !dreamerConfig.schedule?.trim()) {
+    if (!dreamingEnabled && !embeddingSweepEnabled) {
         return;
     }
 
+    const projectPath = embeddingSweepEnabled ? resolveProjectIdentity(directory) : null;
+
     const timer = setInterval(() => {
         try {
+            if (embeddingSweepEnabled && projectPath) {
+                void embedUnembeddedMemories(openDatabase(), projectPath, embeddingConfig)
+                    .then((embeddedCount) => {
+                        if (embeddedCount > 0) {
+                            log(
+                                `[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} for project ${projectPath}`,
+                            );
+                        }
+                    })
+                    .catch((error: unknown) => {
+                        log("[magic-context] periodic memory embedding sweep failed:", error);
+                    });
+            }
+
+            if (!dreamingEnabled || !dreamerConfig?.schedule?.trim()) {
+                return;
+            }
+
             const db = openDatabase();
             checkScheduleAndEnqueue(db, dreamerConfig.schedule);
 
@@ -39,7 +66,7 @@ export function startDreamScheduleTimer(args: {
                 log("[dreamer] timer-triggered queue processing failed:", error);
             });
         } catch (error) {
-            log("[dreamer] timer-triggered schedule check failed:", error);
+            log("[magic-context] timer-triggered maintenance check failed:", error);
         }
     }, DREAM_TIMER_INTERVAL_MS);
 

packages/plugin/src/tools/ctx-memory/tools.ts

@@ -17,7 +17,7 @@ import {
 } from "../../features/magic-context/memory";
 import { embedText, getEmbeddingModelId } from "../../features/magic-context/memory/embedding";
 import { computeNormalizedHash } from "../../features/magic-context/memory/normalize-hash";
-import { log } from "../../shared/logger";
+import { sessionLog } from "../../shared/logger";
 import { CTX_MEMORY_DESCRIPTION, CTX_MEMORY_TOOL_NAME, DEFAULT_SEARCH_LIMIT } from "./constants";
 import {
     CTX_MEMORY_DREAMER_ACTIONS,
@@ -117,16 +117,39 @@ function filterByCategory(memories: Memory[], category?: string): Memory[] {
     return memories.filter((memory) => memory.category === category);
 }
 
-function queueMemoryEmbedding(deps: CtxMemoryToolDeps, memoryId: number, content: string): void {
+function queueMemoryEmbedding(args: {
+    deps: CtxMemoryToolDeps;
+    sessionId: string;
+    memoryId: number;
+    content: string;
+}): void {
+    if (!args.deps.embeddingEnabled) {
+        return;
+    }
+
     void (async () => {
-        const embedding = await embedText(content);
+        const embedding = await embedText(args.content);
         if (!embedding) {
+            sessionLog(
+                args.sessionId,
+                `memory embedding skipped for memory ${args.memoryId}: provider unavailable or embedding generation failed.`,
+            );
+            return;
+        }
+
+        const modelId = getEmbeddingModelId();
+        if (modelId === "off") {
+            sessionLog(
+                args.sessionId,
+                `memory embedding skipped for memory ${args.memoryId}: embedding provider is off.`,
+            );
             return;
         }
 
-        saveEmbedding(deps.db, memoryId, embedding, getEmbeddingModelId());
+        saveEmbedding(args.deps.db, args.memoryId, embedding, modelId);
+        sessionLog(args.sessionId, `proactively embedded memory ${args.memoryId}.`);
     })().catch((error: unknown) => {
-        log("[ctx-memory] failed to save memory embedding:", error);
+        sessionLog(args.sessionId, `memory embedding failed for memory ${args.memoryId}:`, error);
     });
 }
 
@@ -231,7 +254,12 @@ function createCtxMemoryTool(deps: CtxMemoryToolDeps): ToolDefinition {
                         toolContext.agent === DREAMER_AGENT ? "dreamer" : getSourceType(deps),
                 });
 
-                queueMemoryEmbedding(deps, memory.id, content);
+                queueMemoryEmbedding({
+                    deps,
+                    sessionId: toolContext.sessionID,
+                    memoryId: memory.id,
+                    content,
+                });
 
                 return `Saved memory [ID: ${memory.id}] in ${category}.`;
             }
@@ -288,7 +316,12 @@ function createCtxMemoryTool(deps: CtxMemoryToolDeps): ToolDefinition {
                 }
 
                 updateMemoryContent(deps.db, memory.id, content, normalizedHash);
-                queueMemoryEmbedding(deps, memory.id, content);
+                queueMemoryEmbedding({
+                    deps,
+                    sessionId: toolContext.sessionID,
+                    memoryId: memory.id,
+                    content,
+                });
 
                 return `Updated memory [ID: ${memory.id}] in ${memory.category}.`;
             }
@@ -415,7 +448,12 @@ function createCtxMemoryTool(deps: CtxMemoryToolDeps): ToolDefinition {
                     return nextCanonical;
                 })();
 
-                queueMemoryEmbedding(deps, canonicalMemory.id, content);
+                queueMemoryEmbedding({
+                    deps,
+                    sessionId: toolContext.sessionID,
+                    memoryId: canonicalMemory.id,
+                    content,
+                });
 
                 const supersededIds = sourceMemories
                     .map((memory) => memory.id)