prism-mcp-server 5.2.0 → 5.5.0

package/dist/server.js

@@ -58,7 +58,9 @@ ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequ
 // Claude Desktop that the attached resource has changed.
 // Without this, the paperclipped context becomes stale.
 SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { SERVER_CONFIG, SESSION_MEMORY_ENABLED, PRISM_USER_ID, PRISM_ENABLE_HIVEMIND } from "./config.js";
+import { SERVER_CONFIG, SESSION_MEMORY_ENABLED, PRISM_USER_ID, PRISM_ENABLE_HIVEMIND, WATCHDOG_INTERVAL_MS, WATCHDOG_STALE_MIN, WATCHDOG_FROZEN_MIN, WATCHDOG_OFFLINE_MIN, WATCHDOG_LOOP_THRESHOLD, PRISM_SCHEDULER_ENABLED, PRISM_SCHEDULER_INTERVAL_MS, PRISM_SCHOLAR_ENABLED, } from "./config.js";
+import { startWatchdog, drainAlerts } from "./hivemindWatchdog.js";
+import { startScheduler, startScholarScheduler } from "./backgroundScheduler.js";
 import { getSyncBus } from "./sync/factory.js";
 import { startDashboardServer } from "./dashboard/server.js";
 import { acquireLock, registerShutdownHandlers } from "./lifecycle.js";
@@ -201,6 +203,13 @@ const activeSubscriptions = new Set();
 // the promise, so they never block the MCP stdio pipe during startup.
 let storageReady = null;
 let storageIsReady = false;
+// ─── v5.2.1: Deferred Auto-Push Tracking ─────────────────────
+// Tracks whether any client has already called session_load_context.
+// Used by the deferred auto-push to skip redundant context injection.
+// This ensures Claude CLI (which calls the tool via its hook within
+// seconds) is never affected, while Antigravity gets a fallback push
+// when the model fails to comply with auto-load instructions.
+let contextLoadedByClient = false;
 /**
  * Notifies subscribed clients that a resource has changed.
  *
@@ -630,6 +639,7 @@ export function createServer() {
                     case "session_load_context":
                         if (!SESSION_MEMORY_ENABLED)
                             throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
+                        contextLoadedByClient = true; // v5.2.1: suppress deferred auto-push
                         result = await sessionLoadContextHandler(args);
                         break;
                     case "knowledge_search":
@@ -755,6 +765,34 @@ export function createServer() {
                         };
                 }
                 rootSpan.setStatus({ code: SpanStatusCode.OK });
+                // ═══ v5.3: Hivemind Watchdog Alert Injection (Telepathy) ═══
+                // CRITICAL: Append alerts DIRECTLY to tool response content
+                // so the LLM actually reads them. sendLoggingMessage goes to
+                // debug logs which the LLM never sees.
+                if (PRISM_ENABLE_HIVEMIND && result && !result.isError) {
+                    const project = args?.project;
+                    if (typeof project === "string") {
+                        const alerts = drainAlerts(project);
+                        if (alerts.length > 0) {
+                            const alertBlock = alerts.map(a => `[🐝 SYSTEM ALERT] ⚠️ Teammate "${a.role}"` +
+                                (a.agentName ? ` (${a.agentName})` : "") +
+                                ` is ${a.status.toUpperCase()}: ${a.message}`).join("\n");
+                            // Inject into LLM context (primary mechanism)
+                            result.content.push({
+                                type: "text",
+                                text: `\n\n${alertBlock}`,
+                            });
+                            // Also log to operator/debug channel (secondary)
+                            try {
+                                server.sendLoggingMessage({
+                                    level: "warning",
+                                    data: alertBlock,
+                                });
+                            }
+                            catch { /* sendLoggingMessage is best-effort */ }
+                        }
+                    }
+                }
                 return result;
             }
             catch (error) {
@@ -866,6 +904,7 @@ export async function startServer() {
     const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    console.error(`[Prism] MCP Server successfully started and listening on stdio...`);
     // Register graceful shutdown handlers (SIGTERM, SIGINT, SIGHUP, stdin close).
     // The stdin close handler is critical — when MCP clients disconnect, they
     // often just close the pipe without sending a signal, leaving zombie processes.
@@ -887,18 +926,94 @@ export async function startServer() {
         ]).catch(err => {
             console.error(`[Prism] Storage pre-warm failed (non-fatal): ${err}`);
         });
-        // ─── v4.1: Auto-Load is handled via dynamic tool descriptions ──
+        // ─── v4.1: Auto-Load via dynamic tool descriptions ──────────
         // The session_load_context tool description is dynamically modified
         // in createServer() → buildSessionMemoryTools() to include the
-        // auto-load projects list. This is the ONLY universally reliable
-        // mechanism — tool descriptions are surfaced by ALL MCP clients.
+        // auto-load projects list. Tool descriptions are surfaced by ALL
+        // MCP clients — this is the primary mechanism.
         //
-        // Previous approaches that FAILED:
-        //   - sendLoggingMessage: goes to debug logs, not AI conversation
-        //   - instructions field: not supported by Claude Code or Claude CLI
+        // ─── v5.2.1: Deferred Auto-Push (fallback for non-compliant models) ──
+        // After storage warms up, wait AUTOLOAD_PUSH_DELAY_MS. If the client
+        // (model) hasn't called session_load_context by then, push context via
+        // sendLoggingMessage as a last resort. This is a FALLBACK — it's not
+        // guaranteed to be surfaced by all clients, but it's better than nothing.
         //
-        // No runtime code needed here — the instruction is baked into the
-        // tool schema returned by ListTools.
+        // Why 10 seconds? Claude CLI always calls the tool within 2-3 seconds
+        // via its SessionStart hook. Antigravity models that comply also call it
+        // within 5 seconds. 10s gives ample time for well-behaved clients.
+        const AUTOLOAD_PUSH_DELAY_MS = 10_000;
+        // Read autoload projects from dashboard config (same source as createServer)
+        const pushAutoloadList = getSettingSync("autoload_projects", "")
+            .split(",").map(p => p.trim()).filter(Boolean);
+        if (pushAutoloadList.length > 0) {
+            // Wait for storage, then schedule the deferred push
+            storageReady?.then(async () => {
+                // Wait for the delay period to give the model a chance to call the tool
+                await new Promise(r => setTimeout(r, AUTOLOAD_PUSH_DELAY_MS));
+                // If the client already called session_load_context, skip the push
+                if (contextLoadedByClient) {
+                    console.error(`[Prism] Auto-push skipped — client already loaded context`);
+                    return;
+                }
+                console.error(`[Prism] Auto-push triggered — model did not call session_load_context within ${AUTOLOAD_PUSH_DELAY_MS / 1000}s`);
+                // Load and push context for each autoload project
+                try {
+                    const storage = await getStorage();
+                    const defaultLevel = getSettingSync("default_context_depth", "standard");
+                    for (const project of pushAutoloadList) {
+                        try {
+                            const data = await storage.loadContext(project, defaultLevel, PRISM_USER_ID);
+                            if (!data) {
+                                server.sendLoggingMessage({
+                                    level: "info",
+                                    data: `[Prism Auto-Push] No context found for project "${project}". Starting fresh.`,
+                                });
+                                continue;
+                            }
+                            // Format context identically to sessionLoadContextHandler
+                            const d = data;
+                            let ctx = `📋 [AUTO-PUSH] Session context for "${project}" (${defaultLevel}):\n\n`;
+                            if (d.last_summary)
+                                ctx += `📝 Last Summary: ${d.last_summary}\n`;
+                            if (d.active_branch)
+                                ctx += `🌿 Active Branch: ${d.active_branch}\n`;
+                            if (d.key_context)
+                                ctx += `💡 Key Context: ${d.key_context}\n`;
+                            if (d.pending_todo?.length) {
+                                ctx += `\n✅ Open TODOs:\n` + d.pending_todo.map((t) => `  - ${t}`).join("\n") + `\n`;
+                            }
+                            if (d.keywords?.length) {
+                                ctx += `\n🔑 Keywords: ${d.keywords.join(", ")}\n`;
+                            }
+                            if (d.recent_sessions?.length) {
+                                ctx += `\n⏳ Recent Sessions:\n` + d.recent_sessions.map((s) => `  [${s.session_date?.split("T")[0]}] ${s.summary}`).join("\n") + `\n`;
+                            }
+                            // Agent identity
+                            const agentName = getSettingSync("agent_name", "");
+                            const defaultRole = getSettingSync("default_role", "");
+                            if (agentName || defaultRole) {
+                                ctx += `\n👤 Agent: ${defaultRole || "global"} — ${agentName || "Agent"}`;
+                            }
+                            const version = d.version;
+                            if (version) {
+                                ctx += `\n🔑 Session version: ${version}. Pass expected_version: ${version} when saving handoff.`;
+                            }
+                            server.sendLoggingMessage({
+                                level: "info",
+                                data: ctx,
+                            });
+                            console.error(`[Prism] Auto-pushed context for "${project}" (${defaultLevel})`);
+                        }
+                        catch (err) {
+                            console.error(`[Prism] Auto-push failed for "${project}" (non-fatal): ${err}`);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(`[Prism] Auto-push storage error (non-fatal): ${err}`);
+                }
+            }).catch(() => { });
+        }
     }
     // ─── v2.0 Step 6: Initialize SyncBus (Telepathy) ───
     // Fire-and-forget — SyncBus is non-critical for startup.
@@ -938,6 +1053,46 @@ export async function startServer() {
             console.error(`[Dashboard] Mind Palace startup failed (non-fatal): ${err}`);
         });
     }, 0);
+    // ─── v5.3: Hivemind Watchdog ──────────────────────────────
+    // Start the server-side health monitor after storage is warm.
+    // Runs every WATCHDOG_INTERVAL_MS (default 60s) to detect
+    // frozen agents, infinite loops, and task overruns.
+    if (PRISM_ENABLE_HIVEMIND && SESSION_MEMORY_ENABLED) {
+        storageReady?.then(() => {
+            startWatchdog({
+                intervalMs: WATCHDOG_INTERVAL_MS,
+                staleThresholdMin: WATCHDOG_STALE_MIN,
+                frozenThresholdMin: WATCHDOG_FROZEN_MIN,
+                offlineThresholdMin: WATCHDOG_OFFLINE_MIN,
+                loopThreshold: WATCHDOG_LOOP_THRESHOLD,
+            });
+        }).catch(err => {
+            console.error(`[Watchdog] Startup failed (non-fatal): ${err}`);
+        });
+    }
+    // ─── v5.4: Background Purge Scheduler ────────────────────
+    // Automated storage maintenance: TTL sweep, importance decay,
+    // compaction, and deep purge. Runs every PRISM_SCHEDULER_INTERVAL_MS
+    // (default: 12 hours). Independent from the Watchdog (60s cadence).
+    if (PRISM_SCHEDULER_ENABLED && SESSION_MEMORY_ENABLED) {
+        storageReady?.then(() => {
+            startScheduler({
+                intervalMs: PRISM_SCHEDULER_INTERVAL_MS,
+            });
+        }).catch(err => {
+            console.error(`[Scheduler] Startup failed (non-fatal): ${err}`);
+        });
+    }
+    // ─── v5.4: Autonomous Web Scholar Scheduler ──────────────
+    // Background LLM research pipeline. Independent from the
+    // maintenance scheduler — has its own interval and enable flag.
+    if (PRISM_SCHOLAR_ENABLED && SESSION_MEMORY_ENABLED) {
+        storageReady?.then(() => {
+            startScholarScheduler();
+        }).catch(err => {
+            console.error(`[WebScholar] Startup failed (non-fatal): ${err}`);
+        });
+    }
     // Keep the process alive — without this, Node.js would exit
     // because there are no active event loop handles after the
     // synchronous setup completes.
@@ -945,8 +1100,15 @@ export async function startServer() {
         // Heartbeat to keep the process running
     }, 10000);
 }
-// Only auto-start when this module is executed directly (not imported by Smithery scanner)
-const isDirectExecution = process.argv[1]?.endsWith('server.js') || process.argv[1]?.endsWith('server.ts');
+// Only auto-start when this module is executed directly (not imported by Smithery scanner).
+// IMPORTANT: npm install -g creates a symlink like /usr/local/bin/prism-mcp-server
+// whose path does NOT end with 'server.js'. Node.js sets process.argv[1] to the
+// symlink path, not the resolved target. Without the bin-name check, startServer()
+// never fires and the process silently exits with zero stdout (see issue #21).
+const entryScript = process.argv[1] ?? '';
+const isDirectExecution = entryScript.endsWith('server.js') ||
+    entryScript.endsWith('server.ts') ||
+    entryScript.endsWith('prism-mcp-server');
 if (isDirectExecution) {
     startServer().catch((error) => {
         console.error('Fatal error running server:', error);