prism-mcp-server 16.0.0 → 16.1.0

package/dist/storage/sqlite.js

@@ -1183,6 +1183,33 @@ export class SqliteStorage {
             version: result.rows[0].version,
         };
     }
+    async patchHandoff(project, userId, data) {
+        const ALLOWED_COLUMNS = new Set([
+            'embedding', 'embedding_compressed', 'embedding_format', 'embedding_turbo_radius',
+        ]);
+        const sets = [];
+        const args = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (!ALLOWED_COLUMNS.has(key)) {
+                throw new Error(`[SqliteStorage] patchHandoff: rejected unknown column "${key}".`);
+            }
+            if (key === "embedding") {
+                sets.push(`${key} = vector(?)`);
+                args.push((typeof value === "string" ? value : JSON.stringify(value)));
+            }
+            else {
+                sets.push(`${key} = ?`);
+                args.push((typeof value === "object" && value !== null ? JSON.stringify(value) : value));
+            }
+        }
+        if (sets.length === 0)
+            return;
+        args.push(project, userId);
+        await this.db.execute({
+            sql: `UPDATE session_handoffs SET ${sets.join(", ")} WHERE project = ? AND user_id = ?`,
+            args,
+        });
+    }
     async deleteHandoff(project, userId) {
         await this.db.execute({
             sql: "DELETE FROM session_handoffs WHERE project = ? AND user_id = ?",

package/dist/storage/supabase.js

@@ -161,6 +161,12 @@ export class SupabaseStorage {
             };
         }
     }
+    async patchHandoff(project, userId, data) {
+        await supabasePatch("session_handoffs", data, {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+        });
+    }
     async deleteHandoff(project, userId) {
         await supabaseDelete("session_handoffs", {
             project: `eq.${project}`,
@@ -285,12 +291,36 @@ export class SupabaseStorage {
                     queryParams.project = `eq.${params.project}`;
                 if (params.role)
                     queryParams.role = `eq.${params.role}`;
-                const rows = await supabaseGet("session_ledger", queryParams);
+                const ledgerRows = await supabaseGet("session_ledger", queryParams);
+                // Also fetch handoff entries with embeddings
+                const handoffParams = {
+                    user_id: `eq.${params.userId}`,
+                    embedding_compressed: "not.is.null",
+                    select: "id,project,last_summary,active_decisions,updated_at,embedding_compressed,embedding_turbo_radius",
+                    limit: "500",
+                };
+                if (params.project)
+                    handoffParams.project = `eq.${params.project}`;
+                if (params.role)
+                    handoffParams.role = `eq.${params.role}`;
+                const handoffRows = await supabaseGet("session_handoffs", handoffParams);
+                // Normalize handoff rows to match ledger shape for scoring
+                const normalizedHandoffs = (Array.isArray(handoffRows) ? handoffRows : []).map(h => ({
+                    ...h,
+                    summary: h.last_summary || "",
+                    decisions: h.active_decisions || [],
+                    files_changed: [],
+                    session_date: h.updated_at,
+                    created_at: h.updated_at,
+                }));
+                const rows = [
+                    ...(Array.isArray(ledgerRows) ? ledgerRows : []),
+                    ...normalizedHandoffs,
+                ];
                 const scored = [];
-                // v9.3: Import tiebreaker config for optional residualNorm ranking
                 const { PRISM_TURBOQUANT_TIEBREAKER_EPSILON } = await import("../config.js");
                 const eps = PRISM_TURBOQUANT_TIEBREAKER_EPSILON;
-                for (const row of (Array.isArray(rows) ? rows : [])) {
+                for (const row of rows) {
                     try {
                         const compressedBase64 = row.embedding_compressed;
                         const buf = Buffer.from(compressedBase64, "base64");
@@ -313,7 +343,6 @@ export class SupabaseStorage {
                         // Skip entries with corrupt compressed data
                     }
                 }
-                // Sort by similarity descending, with optional residualNorm tiebreaker
                 scored.sort((a, b) => {
                     const diff = b.similarity - a.similarity;
                     if (eps > 0 && Math.abs(diff) < eps && a._residualNorm != null && b._residualNorm != null) {
@@ -321,8 +350,8 @@ export class SupabaseStorage {
                     }
                     return diff;
                 });
-                debugLog(`[SupabaseStorage] Tier-2 TurboQuant fallback: scored ${rows.length} entries, ` +
-                    `${scored.length} above threshold`);
+                debugLog(`[SupabaseStorage] Tier-2 TurboQuant fallback: scored ${rows.length} entries ` +
+                    `(${ledgerRows.length} ledger + ${handoffRows.length} handoff), ${scored.length} above threshold`);
                 const results = scored.slice(0, params.limit);
                 // Strip internal tiebreaker field before returning
                 for (const r of results)

package/dist/tools/ledgerHandlers.js

@@ -400,6 +400,40 @@ export async function sessionSaveHandoffHandler(args, server) {
         };
         storage.saveHistorySnapshot(snapshotEntry).catch(err => console.error(`[session_save_handoff] History snapshot failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`));
     }
+    // ─── Fire-and-forget embedding generation (enables semantic search on handoffs) ───
+    if (data.status === "created" || data.status === "updated") {
+        const embeddingText = [
+            last_summary || "",
+            key_context || "",
+            ...(open_todos || []),
+        ].filter(Boolean).join("\n");
+        if (embeddingText.trim()) {
+            getLLMProvider().generateEmbedding(embeddingText)
+                .then(async (embedding) => {
+                const patchData = {
+                    embedding: JSON.stringify(embedding),
+                };
+                try {
+                    const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
+                    const compressor = getDefaultCompressor();
+                    const compressed = compressor.compress(embedding);
+                    const buf = serialize(compressed);
+                    patchData.embedding_compressed = buf.toString("base64");
+                    patchData.embedding_format = `turbo${compressor.bits}`;
+                    patchData.embedding_turbo_radius = compressed.radius;
+                    debugLog(`[session_save_handoff] TurboQuant compressed: ${buf.length} bytes`);
+                }
+                catch (turboErr) {
+                    console.error(`[session_save_handoff] TurboQuant compression failed (non-fatal): ${turboErr.message}`);
+                }
+                await storage.patchHandoff(project, PRISM_USER_ID, patchData);
+                debugLog(`[session_save_handoff] Embedding saved for project "${project}"`);
+            })
+                .catch((err) => {
+                console.error(`[session_save_handoff] Embedding generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    }
     // ─── Trigger resource subscription notification ───
     if (server && (data.status === "created" || data.status === "updated")) {
         try {
@@ -523,6 +557,7 @@ export async function sessionSaveHandoffHandler(args, server) {
             (last_summary ? `Last summary: ${last_summary}\n` : "") +
             (open_todos?.length ? `Open TODOs: ${open_todos.length} items\n` : "") +
             (active_branch ? `Active branch: ${active_branch}\n` : "") +
+            `📊 Embedding generation queued for semantic search.\n` +
             `\n🔑 Remember: pass expected_version: ${newVersion} on your next save ` +
             `to maintain concurrency control.`;
     return {

package/dist/utils/llm/adapters/openai.js

@@ -112,7 +112,8 @@ export class OpenAIAdapter {
             throw new Error("Cannot generate embedding for empty text.");
         }
         const trimmedText = text.trim();
-        const cacheKey = `${trimmedText.substring(0, 500)}|L${trimmedText.length}`;
+        const model = getSettingSync("openai_embedding_model", "text-embedding-3-small");
+        const cacheKey = `${model}|${trimmedText.substring(0, 500)}|L${trimmedText.length}`;
         const entry = OpenAIAdapter._embeddingCache.get(cacheKey);
         if (entry && Date.now() - entry.ts < OpenAIAdapter.EMBED_CACHE_TTL_MS) {
             debugLog(`[OpenAIAdapter] Embedding cache HIT`);
@@ -127,7 +128,7 @@ export class OpenAIAdapter {
             debugLog(`[OpenAIAdapter] Embedding in-flight dedup HIT`);
             return inflight;
         }
-        const promise = this._generateEmbeddingImpl(trimmedText, cacheKey);
+        const promise = this._generateEmbeddingImpl(trimmedText, cacheKey, model);
         OpenAIAdapter._inflight.set(cacheKey, promise);
         try {
             return await promise;
@@ -136,8 +137,7 @@ export class OpenAIAdapter {
             OpenAIAdapter._inflight.delete(cacheKey);
         }
     }
-    async _generateEmbeddingImpl(inputTextRaw, cacheKey) {
-        const model = getSettingSync("openai_embedding_model", "text-embedding-3-small");
+    async _generateEmbeddingImpl(inputTextRaw, cacheKey, model) {
         // ── Truncation Guard ───────────────────────────────────────────────────
         // text-embedding-3-small accepts up to 8191 tokens.
         // We apply the same preventive truncation as GeminiAdapter so behavior

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "16.0.0",
+  "version": "16.1.0",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 54 Agent Skills, Zero-Search HDC/HRR retrieval, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder:7b / 14b open-weights LLM fleet.",
   "module": "index.ts",