prism-mcp-server 5.1.0 → 5.2.0

package/dist/dashboard/server.js

@@ -17,6 +17,9 @@
  * ═══════════════════════════════════════════════════════════════════
  */
 import * as http from "http";
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
 import { exec } from "child_process";
 import { getStorage } from "../storage/index.js";
 import { PRISM_USER_ID, SERVER_CONFIG } from "../config.js";
@@ -75,10 +78,14 @@ async function killPortHolder(port) {
     });
 }
 export async function startDashboardServer() {
-    // Fire-and-forget port cleanup — don't block server start.
-    // Previously awaiting this added 300ms+ delay from lsof + setTimeout,
-    // starving the MCP stdio transport during the init handshake.
-    killPortHolder(PORT).catch(() => { });
+    // Await port cleanup before binding. This adds ~300ms from lsof + setTimeout,
+    // but is safe because startDashboardServer() is already deferred to
+    // setTimeout(0) in server.ts — the MCP stdio handshake is long finished.
+    // The old fire-and-forget approach caused a deadly race condition:
+    //   1. listen() fired BEFORE killPortHolder cleared the port → EADDRINUSE
+    //   2. killPortHolder then killed the OTHER instance's entire process
+    //   3. Result: no instance ever held port 3000
+    await killPortHolder(PORT).catch(() => { });
     // Lazy storage accessor — returns null if storage isn't ready yet.
     // API routes gracefully degrade with 503 instead of blocking startup.
     let _storage = null;
@@ -770,6 +777,93 @@ return false;}
                     return res.end(JSON.stringify({ error: "Export failed" }));
                 }
             }
+            // ─── API: Universal History Import (v5.2) ───
+            if (url.pathname === "/api/import" && req.method === "POST") {
+                try {
+                    const body = await new Promise(resolve => {
+                        let data = "";
+                        req.on("data", c => data += c);
+                        req.on("end", () => resolve(data));
+                    });
+                    const { path: filePath, format, project, dryRun } = JSON.parse(body || "{}");
+                    if (!filePath) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        return res.end(JSON.stringify({ error: "path is required" }));
+                    }
+                    // Verify file exists before starting import
+                    if (!fs.existsSync(filePath)) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        return res.end(JSON.stringify({ error: `File not found: ${filePath}` }));
+                    }
+                    const { universalImporter } = await import("../utils/universalImporter.js");
+                    const result = await universalImporter({
+                        path: filePath,
+                        format: format || undefined,
+                        project: project || undefined,
+                        dryRun: !!dryRun,
+                        verbose: false,
+                    });
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    return res.end(JSON.stringify({
+                        ok: true,
+                        ...result,
+                        message: `Imported ${result.conversationCount} conversations (${result.successCount} turns)${result.skipCount > 0 ? `, ${result.skipCount} skipped (dup)` : ""}${result.failCount > 0 ? `, ${result.failCount} failed` : ""}${dryRun ? " [DRY RUN]" : ""}`,
+                    }));
+                }
+                catch (err) {
+                    console.error("[Dashboard] Import error:", err);
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    return res.end(JSON.stringify({ error: err.message || "Import failed" }));
+                }
+            }
+            // ─── API: Universal History Import via File Upload (v5.2) ───
+            if (url.pathname === "/api/import-upload" && req.method === "POST") {
+                try {
+                    const body = await new Promise(resolve => {
+                        let data = "";
+                        req.on("data", c => data += c);
+                        req.on("end", () => resolve(data));
+                    });
+                    const { filename, content, format, project, dryRun } = JSON.parse(body || "{}");
+                    if (!content || !filename) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        return res.end(JSON.stringify({ error: "filename and content are required" }));
+                    }
+                    // Write uploaded content to a temp file
+                    const tmpDir = path.join(os.tmpdir(), "prism-import");
+                    fs.mkdirSync(tmpDir, { recursive: true });
+                    const tmpFile = path.join(tmpDir, `upload-${Date.now()}-${filename}`);
+                    fs.writeFileSync(tmpFile, content, "utf-8");
+                    try {
+                        const { universalImporter } = await import("../utils/universalImporter.js");
+                        const result = await universalImporter({
+                            path: tmpFile,
+                            format: format || undefined,
+                            project: project || undefined,
+                            dryRun: !!dryRun,
+                            verbose: false,
+                        });
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        return res.end(JSON.stringify({
+                            ok: true,
+                            ...result,
+                            message: `Imported ${result.conversationCount} conversations (${result.successCount} turns)${result.skipCount > 0 ? `, ${result.skipCount} skipped (dup)` : ""}${result.failCount > 0 ? `, ${result.failCount} failed` : ""}${dryRun ? " [DRY RUN]" : ""} from ${filename}`,
+                        }));
+                    }
+                    finally {
+                        // Clean up temp file
+                        try {
+                            fs.unlinkSync(tmpFile);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                catch (err) {
+                    console.error("[Dashboard] Import upload error:", err);
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    return res.end(JSON.stringify({ error: err.message || "Import failed" }));
+                }
+            }
             // ─── 404 ───
             res.writeHead(404, { "Content-Type": "text/plain" });
             res.end("Not found");
@@ -780,19 +874,61 @@ return false;}
             res.end(JSON.stringify({ error: "Internal Server Error" }));
         }
     });
-    // Gracefully handle port conflicts (non-fatal — MCP server keeps running)
-    httpServer.on("error", (err) => {
-        if (err.code === "EADDRINUSE") {
-            console.error(`[Dashboard] Port ${PORT} is in use — Mind Palace disabled. ` +
-                `Set PRISM_DASHBOARD_PORT to use a different port.`);
+    // ─── Resilient port binding with retry ───
+    // Wraps listen() in a Promise to detect EADDRINUSE failures and retry
+    // with a delay (gives OS time to release the port after killPortHolder).
+    // Falls back to PORT+1, PORT+2 if the preferred port is permanently taken.
+    const MAX_RETRIES = 3;
+    const RETRY_DELAY_MS = 500;
+    const tryListen = (port) => new Promise((resolve, reject) => {
+        const onError = (err) => {
+            httpServer.removeListener("error", onError);
+            reject(err);
+        };
+        httpServer.on("error", onError);
+        httpServer.listen(port, () => {
+            httpServer.removeListener("error", onError);
+            // Re-register a permanent error handler for runtime errors
+            httpServer.on("error", (err) => {
+                console.error(`[Dashboard] HTTP server error: ${err.message}`);
+            });
+            resolve(port);
+        });
+    });
+    let boundPort = PORT;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+            boundPort = await tryListen(PORT + attempt);
+            break; // Success
         }
-        else {
-            console.error(`[Dashboard] HTTP server error: ${err.message}`);
+        catch (err) {
+            if (err.code === "EADDRINUSE") {
+                console.error(`[Dashboard] Port ${PORT + attempt} is in use (attempt ${attempt + 1}/${MAX_RETRIES}).`);
+                if (attempt < MAX_RETRIES - 1) {
+                    // Wait for OS to release the port, then try next port
+                    await new Promise(r => setTimeout(r, RETRY_DELAY_MS));
+                }
+                else {
+                    console.error(`[Dashboard] All ports ${PORT}–${PORT + MAX_RETRIES - 1} in use — Mind Palace disabled. ` +
+                        `Set PRISM_DASHBOARD_PORT to use a different port.`);
+                    return; // Give up — MCP server keeps running
+                }
+            }
+            else {
+                console.error(`[Dashboard] HTTP server error: ${err.message}`);
+                return; // Non-retryable error
+            }
         }
-    });
-    httpServer.listen(PORT, () => {
-        console.error(`[Prism] 🧠 Mind Palace Dashboard → http://localhost:${PORT}`);
-    });
+    }
+    // Write the active port to a file for discoverability
+    try {
+        const portFile = path.join(os.homedir(), ".prism-mcp", "dashboard.port");
+        fs.writeFileSync(portFile, String(boundPort), "utf8");
+    }
+    catch {
+        // Non-fatal — just means the user has to know the port
+    }
+    console.error(`[Prism] 🧠 Mind Palace Dashboard → http://localhost:${boundPort}`);
     // ─── v3.1: TTL Sweep — runs at startup + every 12 hours ───────────
     async function runTtlSweep() {
         try {

package/dist/dashboard/ui.js

@@ -601,6 +601,53 @@ export function renderDashboardHTML(version) {
           <div style="font-size:0.7rem;color:var(--text-muted);margin-top:0.4rem">0 = disabled. Min 7 days. Rollups are never expired.</div>
         </div>
 
+        <!-- Universal History Import (v5.2) -->
+        <div class="card" id="importCard" style="display:none">
+          <div class="card-title"><span class="dot" style="background:var(--accent-cyan)"></span> Import History 📥</div>
+          <div style="margin-bottom:0.75rem">
+            <label style="font-size:0.78rem;color:var(--text-muted);display:block;margin-bottom:0.3rem">Source File</label>
+            <div style="display:flex;gap:0.4rem;align-items:center">
+              <input type="text" id="importPath" class="ttl-input" style="flex:1;text-align:left;font-size:0.82rem;padding:0.45rem 0.65rem" placeholder="/path/to/conversations.jsonl">
+              <input type="file" id="importFileInput" accept=".jsonl,.json,.ndjson" style="display:none">
+              <button class="lc-btn compact" onclick="document.getElementById('importFileInput').click()" style="flex:none;padding:0.45rem 0.75rem;font-size:0.82rem;white-space:nowrap" title="Choose a file from your computer">
+                📂 Browse
+              </button>
+              <button class="lc-btn" onclick="clearImportFile()" id="importClearBtn" style="flex:none;padding:0.45rem 0.55rem;font-size:0.82rem;display:none;background:rgba(244,63,94,0.15);border-color:rgba(244,63,94,0.3);color:var(--accent-rose)" title="Clear selection">
+                ✕
+              </button>
+            </div>
+            <div id="importFileInfo" style="display:none;margin-top:0.35rem;font-size:0.72rem;color:var(--accent-cyan)"></div>
+          </div>
+          <div style="display:flex;gap:0.5rem;margin-bottom:0.75rem;flex-wrap:wrap">
+            <div style="flex:1;min-width:120px">
+              <label style="font-size:0.78rem;color:var(--text-muted);display:block;margin-bottom:0.3rem">Format</label>
+              <select id="importFormat" class="ttl-input" style="width:100%;text-align:left;font-size:0.82rem;padding:0.35rem 0.5rem;cursor:pointer">
+                <option value="">Auto-detect</option>
+                <option value="claude">Claude Code (.jsonl)</option>
+                <option value="gemini">Gemini (.json)</option>
+                <option value="openai">OpenAI (.json)</option>
+              </select>
+            </div>
+            <div style="flex:1;min-width:120px">
+              <label style="font-size:0.78rem;color:var(--text-muted);display:block;margin-bottom:0.3rem">Target Project</label>
+              <input type="text" id="importProject" class="ttl-input" style="width:100%;text-align:left;font-size:0.82rem;padding:0.45rem 0.65rem" placeholder="(auto from file)">
+            </div>
+          </div>
+          <div style="display:flex;gap:0.5rem;align-items:center">
+            <button class="lc-btn compact" id="importBtn" onclick="runImport(false)" style="flex:1">
+              📥 Import
+            </button>
+            <button class="lc-btn export" id="importDryBtn" onclick="runImport(true)" style="flex:1" title="Validate without writing to storage">
+              🧪 Dry Run
+            </button>
+          </div>
+          <div id="importResult" style="display:none;margin-top:0.75rem;padding:0.65rem 0.85rem;border-radius:var(--radius-sm);font-size:0.82rem;line-height:1.5"></div>
+          <div style="font-size:0.68rem;color:var(--text-muted);margin-top:0.5rem">
+            Click <strong>Browse</strong> to pick a file, or type a server-side path.<br>
+            Supports Claude Code (.jsonl), Gemini (.json), and OpenAI (.json).
+          </div>
+        </div>
+
         <div class="card" id="briefingCard" style="display:none">
           <div class="card-title"><span class="dot" style="background:var(--accent-amber)"></span> Morning Briefing 🌅</div>
           <div class="briefing-text" id="briefingText"></div>
@@ -1280,9 +1327,10 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
         document.getElementById('content').className = 'grid grid-main fade-in';
         document.getElementById('content').style.display = 'grid';
 
-        // v3.1: Analytics + Lifecycle Controls
+        // v3.1: Analytics + Lifecycle Controls + Import
         document.getElementById('analyticsCard').style.display = 'block';
         document.getElementById('lifecycleCard').style.display = 'block';
+        document.getElementById('importCard').style.display = 'block';
         loadAnalytics(project);
         loadRetention(project);
 
@@ -1403,6 +1451,122 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
       }
     }
 
+    // ─── v5.2: Universal History Import ───────────────────────────────
+
+    // Track the picked file for upload mode
+    var _importPickedFile = null;
+
+    document.getElementById('importFileInput').addEventListener('change', function(e) {
+      var file = e.target.files[0];
+      if (!file) return;
+      _importPickedFile = file;
+      var pathInput = document.getElementById('importPath');
+      pathInput.value = file.name;
+      document.getElementById('importClearBtn').style.display = 'inline-flex';
+      var infoEl = document.getElementById('importFileInfo');
+      var sizeKB = (file.size / 1024).toFixed(1);
+      var sizeMB = (file.size / (1024 * 1024)).toFixed(1);
+      infoEl.textContent = '📄 ' + file.name + ' (' + (file.size > 1048576 ? sizeMB + ' MB' : sizeKB + ' KB') + ')';
+      infoEl.style.display = 'block';
+
+      // Auto-detect format from extension
+      var fmt = document.getElementById('importFormat');
+      if (file.name.endsWith('.jsonl') || file.name.endsWith('.ndjson')) {
+        fmt.value = 'claude';
+      } else if (file.name.toLowerCase().includes('gemini')) {
+        fmt.value = 'gemini';
+      } else if (file.name.toLowerCase().includes('openai') || file.name.toLowerCase().includes('chatgpt')) {
+        fmt.value = 'openai';
+      } else {
+        fmt.value = '';
+      }
+    });
+
+    function clearImportFile() {
+      _importPickedFile = null;
+      document.getElementById('importPath').value = '';
+      document.getElementById('importFileInput').value = '';
+      document.getElementById('importClearBtn').style.display = 'none';
+      document.getElementById('importFileInfo').style.display = 'none';
+      document.getElementById('importResult').style.display = 'none';
+      document.getElementById('importFormat').value = '';
+    }
+
+    async function runImport(dryRun) {
+      var filePath = document.getElementById('importPath').value.trim();
+      if (!filePath && !_importPickedFile) { showToast('❌ Pick a file or enter a path', true); return; }
+
+      var format = document.getElementById('importFormat').value || undefined;
+      var project = document.getElementById('importProject').value.trim() || undefined;
+      var importBtn = document.getElementById('importBtn');
+      var dryBtn = document.getElementById('importDryBtn');
+      var resultEl = document.getElementById('importResult');
+
+      importBtn.disabled = true;
+      dryBtn.disabled = true;
+      var activeBtn = dryRun ? dryBtn : importBtn;
+      var origText = activeBtn.innerHTML;
+      activeBtn.innerHTML = dryRun ? '🔄 Validating...' : '🔄 Importing...';
+
+      resultEl.style.display = 'block';
+      resultEl.style.background = 'rgba(139,92,246,0.1)';
+      resultEl.style.border = '1px solid rgba(139,92,246,0.25)';
+      resultEl.style.color = 'var(--accent-purple)';
+      resultEl.innerHTML = '<span class="spinner" style="width:16px;height:16px;border-width:2px;margin-right:0.4rem;vertical-align:middle"></span> ' +
+        (dryRun ? 'Validating file...' : 'Importing turns...');
+
+      try {
+        var endpoint, body, headers;
+
+        if (_importPickedFile) {
+          // Upload mode: read file and send as base64
+          var content = await _importPickedFile.text();
+          endpoint = '/api/import-upload';
+          headers = {'Content-Type':'application/json'};
+          body = JSON.stringify({
+            filename: _importPickedFile.name,
+            content: content,
+            format: format,
+            project: project,
+            dryRun: dryRun
+          });
+        } else {
+          // Path mode: just send the server-side path
+          endpoint = '/api/import';
+          headers = {'Content-Type':'application/json'};
+          body = JSON.stringify({ path: filePath, format: format, project: project, dryRun: dryRun });
+        }
+
+        var res = await fetch(endpoint, { method: 'POST', headers: headers, body: body });
+        var d = await res.json();
+        if (res.ok && d.ok) {
+          resultEl.style.background = 'rgba(16,185,129,0.1)';
+          resultEl.style.border = '1px solid rgba(16,185,129,0.25)';
+          resultEl.style.color = 'var(--accent-green)';
+          resultEl.innerHTML = '✅ ' + escapeHtml(d.message) +
+            '<div style="margin-top:0.4rem;font-size:0.75rem;color:var(--text-muted)">' +
+            'Conversations: ' + (d.conversationCount || 0) + ' · Turns: ' + (d.successCount || 0) +
+            (d.skipCount ? ' · Skipped: ' + d.skipCount : '') +
+            (d.failCount ? ' · Failed: ' + d.failCount : '') + '</div>';
+          if (!dryRun) { showToast('✓ Import complete'); loadProject(); }
+        } else {
+          resultEl.style.background = 'rgba(244,63,94,0.1)';
+          resultEl.style.border = '1px solid rgba(244,63,94,0.25)';
+          resultEl.style.color = 'var(--accent-rose)';
+          resultEl.innerHTML = '❌ ' + escapeHtml(d.error || 'Import failed');
+        }
+      } catch(e) {
+        resultEl.style.background = 'rgba(244,63,94,0.1)';
+        resultEl.style.border = '1px solid rgba(244,63,94,0.25)';
+        resultEl.style.color = 'var(--accent-rose)';
+        resultEl.innerHTML = '❌ ' + escapeHtml(e.message);
+      } finally {
+        importBtn.disabled = false;
+        dryBtn.disabled = false;
+        activeBtn.innerHTML = origText;
+      }
+    }
+
     function showToast(msg, isErr) {
       var el = document.getElementById('fixedToast');
       if (!el) return;

package/dist/storage/sqlite.js

@@ -379,6 +379,20 @@ export class SqliteStorage {
             if (!e.message?.includes("duplicate column name"))
                 throw e;
         }
+        // ─── v5.2 Migration: Cognitive Memory — Last Accessed Tracking ───
+        //
+        // REVIEWER NOTE: last_accessed_at enables dynamic importance decay
+        // computed at retrieval time: effective = base * 0.95^days_since_access.
+        // No background workers needed — decay is a pure function of time.
+        // This column is updated fire-and-forget on each search hit.
+        try {
+            await this.db.execute(`ALTER TABLE session_ledger ADD COLUMN last_accessed_at TEXT DEFAULT NULL`);
+            debugLog("[SqliteStorage] v5.2 migration: added last_accessed_at column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
     }
     // ─── PostgREST Filter Parser ───────────────────────────────
     //
@@ -544,9 +558,25 @@ export class SqliteStorage {
         return [{ id, project: entry.project, created_at: now }];
     }
     async patchLedger(id, data) {
+        // ── Column Allowlist (Defense-in-Depth) ────────────────────────
+        // Column names are interpolated directly into SQL (not parameterizable).
+        // This allowlist prevents accidental or malicious injection via the key.
+        // Currently, patchLedger is only called from internal handler code,
+        // but this guard protects against future misuse if the method is
+        // exposed to less-controlled callers.
+        const ALLOWED_COLUMNS = new Set([
+            'embedding', 'embedding_compressed', 'embedding_format', 'embedding_turbo_radius',
+            'archived_at', 'deleted_at', 'deleted_reason', 'is_rollup', 'rollup_count',
+            'importance', 'last_accessed_at', 'keywords', 'todos', 'files_changed', 'decisions',
+            'summary', 'confidence_score', 'event_type', 'role',
+        ]);
         const sets = [];
         const args = [];
         for (const [key, value] of Object.entries(data)) {
+            if (!ALLOWED_COLUMNS.has(key)) {
+                debugLog(`[SqliteStorage] patchLedger: rejected unknown column "${key}" — skipping`);
+                continue;
+            }
             if (key === "embedding") {
                 // Use libSQL's native vector() function for F32_BLOB columns.
                 // The value is a JSON-stringified number[] from the handler.

package/dist/storage/supabaseMigrations.js

@@ -182,7 +182,25 @@ export const MIGRATIONS = [
       $$;
     `,
     },
-    // Future migrations go here (version 31+)
+    {
+        // ─── v5.2: Cognitive Memory — Last Accessed Tracking ──────────
+        //
+        // REVIEWER NOTE: This column enables the Ebbinghaus Importance Decay
+        // feature (effective = base * 0.95^days_since_accessed) computed at
+        // retrieval time in sessionMemoryHandlers.ts. No background workers
+        // needed — decay is a pure function of time.
+        //
+        // The column is updated fire-and-forget via patchLedger() on every
+        // search hit. NULLs are expected (entries never retrieved yet) and
+        // the decay formula falls back to created_at when last_accessed_at
+        // is NULL.
+        version: 31,
+        name: "cognitive_memory_last_accessed",
+        sql: `
+      ALTER TABLE session_ledger ADD COLUMN IF NOT EXISTS last_accessed_at TIMESTAMPTZ DEFAULT NULL;
+    `,
+    },
+    // Future migrations go here (version 32+)
 ];
 /**
  * Current schema version — derived from the MIGRATIONS array.

package/dist/tools/compactionHandler.js

@@ -23,13 +23,23 @@ async function summarizeEntries(entries) {
     const entriesText = entries.map((e, i) => `[${i + 1}] ${e.session_date || "unknown date"}: ${e.summary || "no summary"}\n` +
         (e.decisions?.length ? `  Decisions: ${e.decisions.join("; ")}\n` : "") +
         (e.files_changed?.length ? `  Files: ${e.files_changed.join(", ")}\n` : "")).join("\n");
-    const prompt = (`You are compressing a session history log. Summarize these ${entries.length} ` +
-        `work sessions into a single concise paragraph (max 500 words).\n\n` +
-        `PRESERVE: key decisions, important file changes, error resolutions, ` +
-        `architecture changes, and any recurring patterns.\n` +
-        `OMIT: routine operations, intermediate debugging steps, and redundant details.\n\n` +
-        `Sessions to summarize:\n${entriesText}\n\n` +
-        `Provide ONLY the summary paragraph, no headers or formatting.`).substring(0, 30000);
+    const prompt = (`You are compressing a session history log for an AI agent's persistent memory.\n\n` +
+        `Analyze these ${entries.length} work sessions and produce THREE sections:\n\n` +
+        `1. SUMMARY (max 300 words): A concise paragraph preserving key decisions, ` +
+        `important file changes, error resolutions, and architecture changes. ` +
+        `Omit routine operations and intermediate debugging steps.\n\n` +
+        `2. PRINCIPLES (1-3 bullet points): Reusable lessons extracted from these sessions. ` +
+        `These should be actionable engineering insights the agent can apply to future work. ` +
+        `Format: "- [principle]"\n\n` +
+        `3. PATTERNS (1-3 bullet points): Recurring behaviors, tools, or workflows observed. ` +
+        `Format: "- [pattern]"\n\n` +
+        `Sessions to analyze:\n${entriesText}\n\n` +
+        `Output format (follow exactly):\n` +
+        `[summary paragraph]\n\n` +
+        `Principles:\n` +
+        `- ...\n\n` +
+        `Patterns:\n` +
+        `- ...`).substring(0, 30000);
     return llm.generateText(prompt);
 }
 // ─── Main Handler ─────────────────────────────────────────────

package/dist/tools/sessionMemoryDefinitions.js

@@ -303,6 +303,13 @@ export const SESSION_SEARCH_MEMORY_TOOL = {
                 description: "If true, returns a separate MEMORY TRACE content block with search strategy, " +
                     "latency breakdown (embedding vs storage), and scoring metadata. Default: false.",
             },
+            // v5.2: Context-Weighted Retrieval — biases search toward active work context
+            context_boost: {
+                type: "boolean",
+                description: "If true, appends current project and working context to the search query " +
+                    "before embedding generation, naturally biasing results toward contextually relevant memories. " +
+                    "Useful when searching within a specific project context. Default: false.",
+            },
         },
         required: ["query"],
     },

package/dist/tools/sessionMemoryHandlers.js

@@ -829,9 +829,12 @@ export async function sessionSearchMemoryHandler(args) {
     const { query, project, limit = 5, similarity_threshold = 0.7, 
     // Phase 1: enable_trace defaults to false for full backward compatibility.
     // When true, a MemoryTrace JSON block is appended as content[1].
-    enable_trace = false, } = args;
+    enable_trace = false, 
+    // v5.2: Context-Weighted Retrieval — biases search toward active work context
+    context_boost = false, } = args;
     debugLog(`[session_search_memory] Semantic search: query="${query}", ` +
-        `project=${project || "all"}, limit=${limit}, threshold=${similarity_threshold}`);
+        `project=${project || "all"}, limit=${limit}, threshold=${similarity_threshold}` +
+        `${context_boost ? ", context_boost=ON" : ""}`);
     // Phase 1: Start total latency timer BEFORE any work (embedding + storage)
     const totalStart = performance.now();
     // Step 1: Generate embedding for the search query
@@ -850,8 +853,43 @@ export async function sessionSearchMemoryHandler(args) {
     // Phase 1: Start embedding latency timer — isolates Gemini API call time.
     // This is the most variable component: 50ms on a good day, 2000ms under load.
     const embeddingStart = performance.now();
+    // ── v5.2: Context-Weighted Retrieval ───────────────────────────
+    // When context_boost is enabled, prepend active project context to the
+    // search query before embedding generation. This naturally biases the
+    // embedding vector toward memories from the same project/branch/context.
+    // Elegant: no scoring heuristics needed — semantics do the work.
+    let effectiveQuery = query;
+    if (context_boost && project) {
+        try {
+            const storage = await getStorage();
+            const ctx = await storage.loadContext(project, "quick", PRISM_USER_ID);
+            const contextParts = [];
+            if (ctx && typeof ctx === "object") {
+                const ctxObj = ctx;
+                if (ctxObj.active_branch)
+                    contextParts.push(`branch: ${ctxObj.active_branch}`);
+                if (ctxObj.key_context)
+                    contextParts.push(`context: ${String(ctxObj.key_context).substring(0, 200)}`);
+                const keywords = ctxObj.keywords;
+                if (keywords?.length)
+                    contextParts.push(`keywords: ${keywords.slice(0, 5).join(", ")}`);
+            }
+            if (contextParts.length > 0) {
+                effectiveQuery = `[${contextParts.join("; ")}] ${query}`;
+                debugLog(`[session_search_memory] Context boost applied: "${effectiveQuery.substring(0, 100)}..."`);
+            }
+        }
+        catch {
+            // Context load failed — proceed with unmodified query (graceful degradation)
+            debugLog("[session_search_memory] Context boost failed (non-fatal) — using original query");
+        }
+    }
+    else if (context_boost && !project) {
+        // User enabled context_boost but didn't specify a project — can't boost without context
+        debugLog("[session_search_memory] context_boost ignored — requires a project parameter to load context");
+    }
     try {
-        queryEmbedding = await getLLMProvider().generateEmbedding(query);
+        queryEmbedding = await getLLMProvider().generateEmbedding(effectiveQuery);
     }
     catch (err) {
         return {
@@ -912,14 +950,40 @@ export async function sessionSearchMemoryHandler(args) {
             }
             return { content: contentBlocks, isError: false };
         }
-        // Format results with similarity scores
+        // ── v5.2: Dynamic Importance Decay (Ebbinghaus Curve) ──────
+        // Compute effective_importance at retrieval time:
+        //   effective = base_importance * 0.95^days_since_accessed
+        // This avoids background workers — decay is a pure function of time.
+        // Also fire-and-forget update last_accessed_at on all returned results.
+        const now = new Date();
+        const resultIds = results.map((r) => r.id).filter(Boolean);
+        // Fire-and-forget: update last_accessed_at for all returned results
+        if (resultIds.length > 0) {
+            const nowISO = now.toISOString();
+            for (const id of resultIds) {
+                storage.patchLedger(id, { last_accessed_at: nowISO }).catch(() => { });
+            }
+        }
+        // Format results with similarity scores + effective importance
         const formatted = results.map((r, i) => {
             const score = typeof r.similarity === "number"
                 ? `${(r.similarity * 100).toFixed(1)}%`
                 : "N/A";
+            // Dynamic importance decay: effective = base * 0.95^days
+            const baseImportance = r.importance ?? 0;
+            let effectiveImportance = baseImportance;
+            if (baseImportance > 0) {
+                const lastAccess = r.last_accessed_at || r.created_at || now.toISOString();
+                const daysSince = Math.max(0, (now.getTime() - new Date(lastAccess).getTime()) / 86400000);
+                effectiveImportance = Math.round(baseImportance * Math.pow(0.95, daysSince) * 100) / 100;
+            }
+            const importanceStr = baseImportance > 0
+                ? `  Importance: ${effectiveImportance}${effectiveImportance !== baseImportance ? ` (base: ${baseImportance}, decayed)` : ""}\n`
+                : "";
             return `[${i + 1}] ${score} similar — ${r.session_date || "unknown date"}\n` +
                 `  Project: ${r.project}\n` +
                 `  Summary: ${r.summary}\n` +
+                importanceStr +
                 (r.decisions?.length ? `  Decisions: ${r.decisions.join("; ")}\n` : "") +
                 (r.files_changed?.length ? `  Files: ${r.files_changed.join(", ")}\n` : "");
         }).join("\n");