prism-mcp-server 20.2.3 → 20.2.4

package/README.md

@@ -57,6 +57,19 @@ features.
 <details>
 <summary>Release history (optional)</summary>
 
+## What's New in v20.2.4
+
+### Reliable Session Memory That Shows Work, Not Greetings
+Greeting-only assistant replies are skipped before ledger writes. Existing
+greeting rows are filtered at read time across native startup, MCP context, and
+`prism load --json`, while entries containing decisions, TODOs, changed files,
+or non-session events remain visible. Historical rows are not destructively
+deleted. If Synalux has a transient startup failure, Prism displays one bounded
+local last-good snapshot and clearly labels it; permanent authorization or
+validation failures still fail loud, and later writes remain cloud-routed.
+
+---
+
 ## What's New in v20.2.2
 
 ### One Local-First Workflow Across Every Agent

package/dist/cli.js

@@ -10,22 +10,25 @@ import { getCurrentGitState } from './utils/git.js';
 import { sessionBootstrapHandler, sessionLoadContextHandler, sessionSaveLedgerHandler, sessionSaveHandoffHandler, } from './tools/ledgerHandlers.js';
 import { configureClaudeAgentPolicy, configureClaudeNativeStartup, configureCodexAgentPolicy, configureCodexNativeStartup, configureGeminiAgentPolicy, configureGeminiNativeStartup, connectHosts, migrateLegacyClaudeHooks, migrateLegacyClaudeInstructions, migrateLegacyClaudeManagedStartup, migrateLegacyClaudeProjectMcp, normalizeHostName, } from './connect.js';
 import { runBrowserCli } from './browserCli.js';
+import { filterPrismMemoryContext } from './utils/memoryQuality.js';
+import { isRecoverableStartupStorageError } from './utils/startupRecovery.js';
 const program = new Command();
 /** Build the stable `prism load --json` envelope from depth-specific context. */
 export function buildLoadJsonOutput(project, data, level, metadata) {
+    const filteredData = filterPrismMemoryContext(data);
     let history = [];
     let historyLimit = 0;
     if (level === 'standard') {
-        history = Array.isArray(data.recent_sessions) ? data.recent_sessions : [];
+        history = Array.isArray(filteredData.recent_sessions) ? filteredData.recent_sessions : [];
         historyLimit = 5;
     }
     else if (level === 'deep') {
         // Canonical deep context uses session_history. Fall back only when that
         // field is absent so older portal responses remain consumable.
-        history = Array.isArray(data.session_history)
-            ? data.session_history
-            : Array.isArray(data.recent_sessions)
-                ? data.recent_sessions
+        history = Array.isArray(filteredData.session_history)
+            ? filteredData.session_history
+            : Array.isArray(filteredData.recent_sessions)
+                ? filteredData.recent_sessions
                 : [];
         historyLimit = 50;
     }
@@ -33,15 +36,15 @@ export function buildLoadJsonOutput(project, data, level, metadata) {
         agent_name: metadata.agentName || null,
         handoff: [{
                 project,
-                role: metadata.effectiveRole || data.role || 'global',
-                last_summary: data.last_summary || null,
-                pending_todo: data.pending_todo || null,
-                active_decisions: data.active_decisions || null,
-                keywords: data.keywords || null,
-                key_context: data.key_context || null,
-                active_branch: data.active_branch || null,
-                version: data.version ?? null,
-                updated_at: data.updated_at || null,
+                role: metadata.effectiveRole || filteredData.role || 'global',
+                last_summary: filteredData.last_summary || null,
+                pending_todo: filteredData.pending_todo || null,
+                active_decisions: filteredData.active_decisions || null,
+                keywords: filteredData.keywords || null,
+                key_context: filteredData.key_context || null,
+                active_branch: filteredData.active_branch || null,
+                version: filteredData.version ?? null,
+                updated_at: filteredData.updated_at || null,
             }],
         // Keep the established key for callers while sourcing the canonical field
         // for the requested depth.
@@ -61,21 +64,46 @@ program
     .description('Prism — The Mind Palace for AI Agents')
     .version(SERVER_CONFIG.version);
 /** Print the canonical hook-free first-turn display used by the MCP tool. */
+export const isRecoverableBootstrapStorageError = isRecoverableStartupStorageError;
+async function printBootstrapDisplay() {
+    const result = await sessionBootstrapHandler({});
+    const output = result.content?.map((part) => part?.text).filter(Boolean).join('\n') || '';
+    if (!output)
+        throw new Error('session_bootstrap returned no display content');
+    console.log(output);
+    if (result.isError)
+        process.exitCode = 1;
+}
 export async function runBootstrapCommand() {
+    const previousStorage = process.env.PRISM_STORAGE;
     try {
-        const result = await sessionBootstrapHandler({});
-        const output = result.content?.map((part) => part?.text).filter(Boolean).join('\n') || '';
-        if (!output)
-            throw new Error('session_bootstrap returned no display content');
-        console.log(output);
-        if (result.isError)
-            process.exitCode = 1;
+        try {
+            await printBootstrapDisplay();
+        }
+        catch (err) {
+            if (!isRecoverableBootstrapStorageError(err))
+                throw err;
+            // Startup is a read-only display. If paid cloud memory is temporarily
+            // unavailable, retry this one read against the local last-good database
+            // instead of blocking the host's entire first turn. Do not persist the
+            // override: normal saves still use the configured subscription backend.
+            await closeStorage().catch(() => { });
+            process.env.PRISM_STORAGE = 'local';
+            console.error('Prism cloud startup unavailable; using local last-good context for this startup.');
+            await printBootstrapDisplay();
+        }
     }
     catch (err) {
         console.error(`Bootstrap failed: ${err instanceof Error ? err.message : String(err)}`);
         process.exitCode = 1;
     }
     finally {
+        if (previousStorage === undefined) {
+            delete process.env.PRISM_STORAGE;
+        }
+        else {
+            process.env.PRISM_STORAGE = previousStorage;
+        }
         await closeStorage().catch(() => { });
     }
 }

package/dist/storage/synalux.js

@@ -47,12 +47,16 @@ function resolveKnowledgeScope(callerScope) {
 }
 /** Refresh JWT this many ms before expiry to avoid edge-case 401s. */
 const JWT_REFRESH_LEEWAY_MS = 60_000;
+function buildContextLoadKey(project, level, userId, role) {
+    return JSON.stringify({ project, level, userId, role: role ?? "" });
+}
 export class SynaluxStorage extends SupabaseStorage {
     baseUrl;
     refreshToken;
     cachedJwt = null;
     cachedJwtExpiresAt = 0;
     inflightExchange = null;
+    inflightContextLoads = new Map();
     constructor() {
         super();
         const url = process.env.PRISM_SYNALUX_BASE_URL || PRISM_SYNALUX_BASE_URL;
@@ -203,31 +207,46 @@ export class SynaluxStorage extends SupabaseStorage {
     }
     // ─── Context ─────────────────────────────────────────────────
     async loadContext(project, level, userId, role) {
-        const result = await this.portalPost("/api/v1/prism/memory", {
-            action: "load_context",
-            project,
-            level,
-            user_id: userId,
-            role,
-        });
-        // Current portals return the canonical flat `context`. Older deployed
-        // portals returned `{ handoff, recent_sessions }`; normalize that envelope
-        // here so the formatter can still see last_summary, TODOs, version, and
-        // session history during a rolling portal/client upgrade.
-        if (result.context === null)
-            return null;
-        if (result.context && typeof result.context === "object" && !Array.isArray(result.context)) {
-            return result.context;
+        const key = buildContextLoadKey(project, level, userId, role);
+        const existing = this.inflightContextLoads.get(key);
+        if (existing)
+            return existing;
+        const request = (async () => {
+            const result = await this.portalPost("/api/v1/prism/memory", {
+                action: "load_context",
+                project,
+                level,
+                user_id: userId,
+                role,
+            });
+            // Current portals return the canonical flat `context`. Older deployed
+            // portals returned `{ handoff, recent_sessions }`; normalize that envelope
+            // here so the formatter can still see last_summary, TODOs, version, and
+            // session history during a rolling portal/client upgrade.
+            if (result.context === null)
+                return null;
+            if (result.context && typeof result.context === "object" && !Array.isArray(result.context)) {
+                return result.context;
+            }
+            if (result.handoff === null)
+                return null;
+            if (result.handoff && typeof result.handoff === "object" && !Array.isArray(result.handoff)) {
+                return {
+                    ...result.handoff,
+                    recent_sessions: Array.isArray(result.recent_sessions) ? result.recent_sessions : [],
+                };
+            }
+            return result;
+        })();
+        this.inflightContextLoads.set(key, request);
+        try {
+            return await request;
         }
-        if (result.handoff === null)
-            return null;
-        if (result.handoff && typeof result.handoff === "object" && !Array.isArray(result.handoff)) {
-            return {
-                ...result.handoff,
-                recent_sessions: Array.isArray(result.recent_sessions) ? result.recent_sessions : [],
-            };
+        finally {
+            if (this.inflightContextLoads.get(key) === request) {
+                this.inflightContextLoads.delete(key);
+            }
         }
-        return result;
     }
     // ─── Forget memory (GDPR surgical deletion) ──────────────────
     // Phase 3 Tier A: route both soft and hard delete through the

package/dist/tools/ledgerHandlers.js

@@ -31,6 +31,7 @@ import { getCurrentGitState, getGitDrift } from "../utils/git.js";
 import { getSetting, getAllSettings, refreshConfigStorageCache } from "../storage/configStorage.js";
 import { mergeHandoff, dbToHandoffSchema, sanitizeForMerge } from "../utils/crdtMerge.js";
 import { resolveProject } from "../utils/projectResolver.js";
+import { isRecoverableStartupStorageError, LOCAL_STARTUP_FALLBACK_NOTICE, } from "../utils/startupRecovery.js";
 import { PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS } from "../config.js";
 import { captureLocalEnvironment } from "../utils/autoCapture.js";
 import { fireCaptionAsync } from "../utils/imageCaptioner.js";
@@ -264,6 +265,7 @@ function compactWithOmissionCount(value, maxChars) {
  */
 import { computeEffectiveImportance, recordMemoryAccess } from "../utils/cognitiveMemory.js";
 import { formatInferenceMetrics, resetInferenceMetrics, getInferenceSnapshot } from "../utils/inferenceMetrics.js";
+import { filterPrismMemoryContext, isGreetingOnlyMemoryEntry } from "../utils/memoryQuality.js";
 export async function sessionSaveLedgerHandler(args) {
     if (!isSessionSaveLedgerArgs(args)) {
         throw new Error("Invalid arguments for session_save_ledger");
@@ -289,6 +291,16 @@ export async function sessionSaveLedgerHandler(args) {
     const files_changed = args.files_changed ? sanitizeArray(args.files_changed) : undefined;
     const decisions = args.decisions ? sanitizeArray(args.decisions) : undefined;
     const role = args.role;
+    if (isGreetingOnlyMemoryEntry({ summary, todos, files_changed, decisions })) {
+        return {
+            content: [{
+                    type: "text",
+                    text: (_saveLedgerGateWarning ? `⚠️ ${_saveLedgerGateWarning}\n\n` : "") +
+                        "ℹ️ Greeting-only turn skipped; no ledger entry was written.",
+                }],
+            isError: false,
+        };
+    }
     const storage = await getStorage();
     // ─── Project mismatch validation (v13 — hard-rejects on mismatch) ───
     // Replaces the old soft-warning behavior that allowed cross-project
@@ -817,7 +829,7 @@ export async function sessionLoadContextHandler(args, options = {}) {
     const protectedFallbackNames = new Set(protectedFallbackEntries.map((entry) => entry.name));
     const manifestSnapshot = await resolveNativeSkillManifestSnapshot(skillSyncResult);
     const entitledSkillNames = new Set(manifestSnapshot.names);
-    const storage = await getStorage();
+    const storage = options.storageOverride ?? await getStorage();
     const effectiveRole = role || await getSetting("default_role", "") || undefined;
     const loadEntitledRoleSkill = async () => {
         if (!effectiveRole)
@@ -830,11 +842,11 @@ export async function sessionLoadContextHandler(args, options = {}) {
         }
         return await getSetting(`user_skill:${effectiveRole}`, "");
     };
-    const data = await storage.loadContext(project, level, PRISM_USER_ID, effectiveRole); // v3.0: role with dashboard fallback
+    const loadedData = await storage.loadContext(project, level, PRISM_USER_ID, effectiveRole); // v3.0: role with dashboard fallback
     // F4 fix: inject protected skills even for fresh projects.
     // Previously this returned before skill injection, leaving new projects with zero
     // behavioral guardrails for the entire session. Now protected skills always load.
-    if (!data) {
+    if (!loadedData) {
         let freshSkillBlock = "";
         const freshLoadedSkills = new Set();
         if (includeSkillContent) {
@@ -896,6 +908,7 @@ export async function sessionLoadContextHandler(args, options = {}) {
             isError: false,
         };
     }
+    const data = filterPrismMemoryContext(loadedData);
     const version = data?.version;
     const versionNote = version
         ? `\n\n🔑 Session version: ${version}. Pass expected_version: ${version} when saving handoff.`
@@ -1416,11 +1429,13 @@ export async function sessionLoadContextHandler(args, options = {}) {
         isError: false,
     };
 }
-/**
- * Hook-free first-turn entrypoint used by the native prism-startup skill.
- * Configuration, rather than the host model, owns project and depth selection.
- */
-export async function sessionBootstrapHandler(args = {}) {
+async function createLocalStartupStorage() {
+    const { SqliteStorage } = await import("../storage/sqlite.js");
+    const storage = new SqliteStorage();
+    await storage.initialize(true);
+    return storage;
+}
+export async function sessionBootstrapHandler(args = {}, options = {}) {
     if (typeof args !== "object" || args === null || Array.isArray(args)) {
         throw new Error("Invalid arguments for session_bootstrap");
     }
@@ -1487,39 +1502,76 @@ export async function sessionBootstrapHandler(args = {}) {
             : "";
         const omissionLength = omittedProjectsText ? omittedProjectsText.length + 2 : 0;
         const separatorsLength = Math.max(0, renderedProjectCount - 1) * 2;
-        perProjectMaxChars = Math.floor((startupMaxChars - startupHeader.length - systemReadyBlock.length - 4 - omissionLength - separatorsLength) /
+        perProjectMaxChars = Math.floor((startupMaxChars - startupHeader.length - systemReadyBlock.length - LOCAL_STARTUP_FALLBACK_NOTICE.length -
+            6 - omissionLength - separatorsLength) /
             renderedProjectCount);
         if (perProjectMaxChars >= 512 || renderedProjectCount === 1)
             break;
         renderedProjectCount -= 1;
     }
-    const loaded = [];
-    let hadError = false;
-    for (const project of projects.slice(0, renderedProjectCount)) {
-        const result = await sessionLoadContextHandler({
-            project,
-            level: depth,
-            role: defaultRole || undefined,
-            conversation_id: conversationId,
-            prompt: input.prompt,
-        }, { includeSkillContent: false, nativeMaxChars: perProjectMaxChars, skillSyncResult });
-        const text = result.content?.map((part) => part?.text).filter(Boolean).join("\n") ||
-            `No session context found for project "${project}".`;
-        loaded.push(text);
-        hadError ||= result.isError === true;
+    const renderedProjects = projects.slice(0, renderedProjectCount);
+    const loadProjects = async (storageOverride) => {
+        const loaded = [];
+        let hadError = false;
+        for (const project of renderedProjects) {
+            const result = await sessionLoadContextHandler({
+                project,
+                level: depth,
+                role: defaultRole || undefined,
+                conversation_id: conversationId,
+                prompt: input.prompt,
+            }, {
+                includeSkillContent: false,
+                nativeMaxChars: perProjectMaxChars,
+                skillSyncResult,
+                storageOverride,
+            });
+            const text = result.content?.map((part) => part?.text).filter(Boolean).join("\n") ||
+                `No session context found for project "${project}".`;
+            loaded.push(text);
+            hadError ||= result.isError === true;
+        }
+        return { loaded, hadError };
+    };
+    let localStorage = null;
+    let usedLocalFallback = false;
+    let startupContext;
+    try {
+        try {
+            startupContext = await loadProjects();
+        }
+        catch (error) {
+            if (!isRecoverableStartupStorageError(error))
+                throw error;
+            localStorage = await (options.localStorageFactory ?? createLocalStartupStorage)();
+            usedLocalFallback = true;
+            startupContext = await loadProjects(localStorage);
+        }
+    }
+    finally {
+        if (localStorage) {
+            try {
+                await localStorage.close();
+            }
+            catch (error) {
+                debugLog(`[session_bootstrap] Local fallback close failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
     }
+    const fallbackNotice = usedLocalFallback ? `${LOCAL_STARTUP_FALLBACK_NOTICE}\n\n` : "";
     return {
         content: [{
                 type: "text",
-                text: `${startupHeader}\n\n${loaded.join("\n\n")}` +
+                text: `${startupHeader}\n\n${fallbackNotice}${startupContext.loaded.join("\n\n")}` +
                     (omittedProjectsText ? `\n\n${omittedProjectsText}` : "") +
                     `\n\n${systemReadyBlock}`,
             }],
-        isError: hadError,
+        isError: startupContext.hadError,
         structuredContent: {
             conversation_id: conversationId,
-            projects: projects.slice(0, renderedProjectCount),
+            projects: renderedProjects,
             depth,
+            context_source: usedLocalFallback ? "local-last-good" : activeStorageBackend,
         },
     };
 }

package/dist/utils/memoryQuality.js

@@ -0,0 +1,51 @@
+const SOURCE_LABEL_PATTERN = /^\s*\[[^\]]+\]\s*/u;
+const GREETING_ONLY_PATTERN = /^(?:hi|hello|hey|ready)(?:[\s.!?,…—-]|[\u{1F300}-\u{1FAFF}]|\uFE0F)*$/iu;
+const GREETING_OPENING_PATTERN = /^(?:hi(?:\s+there)?|hello|hey)\b/iu;
+const ASSISTANCE_INVITATION_PATTERN = /\b(?:(?:how|what)\s+(?:can|may)\s+i\s+(?:help|assist)|let\s+me\s+know\s+what\s+you\s+need)\b/iu;
+const SUBSTANTIVE_OUTCOME_PATTERN = /\b(?:added|built|changed|completed|configured|created|debugged|deployed|fixed|implemented|investigated|removed|repaired|resolved|tested|updated|verified|wrote)\b/iu;
+const STRUCTURED_WORK_FIELDS = ["decisions", "todos", "files_changed"];
+function hasStructuredWork(entry) {
+    return STRUCTURED_WORK_FIELDS.some((field) => {
+        const value = entry[field];
+        if (value === undefined || value === null)
+            return false;
+        return !Array.isArray(value) || value.length > 0;
+    });
+}
+/** Greeting-only assistant replies are presentation, not durable work. */
+export function isGreetingOnlyMemoryEntry(entry) {
+    if (hasStructuredWork(entry))
+        return false;
+    if (typeof entry.event_type === "string" && entry.event_type !== "session")
+        return false;
+    if (typeof entry.summary !== "string")
+        return false;
+    const summary = entry.summary.replace(SOURCE_LABEL_PATTERN, "").trim();
+    if (!summary)
+        return false;
+    if (GREETING_ONLY_PATTERN.test(summary))
+        return true;
+    return GREETING_OPENING_PATTERN.test(summary)
+        && ASSISTANCE_INVITATION_PATTERN.test(summary)
+        && !SUBSTANTIVE_OUTCOME_PATTERN.test(summary);
+}
+export function filterGreetingOnlyMemoryEntries(entries) {
+    return entries.filter((entry) => !isGreetingOnlyMemoryEntry(entry));
+}
+/**
+ * Defensive local-storage fallback for the portal-owned memory policy.
+ * Returns a copy so storage responses remain immutable for other consumers.
+ */
+export function filterPrismMemoryContext(data) {
+    const filtered = { ...data };
+    if (isGreetingOnlyMemoryEntry({ summary: data.last_summary })) {
+        filtered.last_summary = null;
+    }
+    if (Array.isArray(data.recent_sessions)) {
+        filtered.recent_sessions = filterGreetingOnlyMemoryEntries(data.recent_sessions);
+    }
+    if (Array.isArray(data.session_history)) {
+        filtered.session_history = filterGreetingOnlyMemoryEntries(data.session_history);
+    }
+    return filtered;
+}

package/dist/utils/startupRecovery.js

@@ -0,0 +1,13 @@
+const RECOVERABLE_STARTUP_STORAGE_ERROR = /(?:rate limit|(?:HTTP|status)\s*(?:408|425|429|5\d{2})\b|network error|fetch failed|timed?\s*out|timeout|ECONN(?:RESET|REFUSED)|ENOTFOUND|EAI_AGAIN|socket hang up)/i;
+const RECOVERABLE_ENTITLEMENT_PROBE_ERROR = /\[Prism Storage\]\s+Could not verify the Synalux cloud-memory entitlement\b/i;
+export const LOCAL_STARTUP_FALLBACK_NOTICE = "⚠️ Synalux cloud context is temporarily unavailable; showing local last-good context for this startup only.";
+/**
+ * Startup may degrade to the local last-good snapshot only for transient
+ * storage failures. Validation, formatting, and programmer errors must still
+ * fail loud instead of being hidden by an unrelated fallback.
+ */
+export function isRecoverableStartupStorageError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return RECOVERABLE_STARTUP_STORAGE_ERROR.test(message)
+        || RECOVERABLE_ENTITLEMENT_PROBE_ERROR.test(message);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.3",
+  "version": "20.2.4",
   "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, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",