prism-mcp-server 2.5.1 → 3.0.0

package/dist/storage/supabase.js

@@ -17,30 +17,25 @@ import { debugLog } from "../utils/logger.js";
 export class SupabaseStorage {
     // ─── Lifecycle ─────────────────────────────────────────────
     async initialize() {
-        // Supabase is always ready — connection is stateless (REST API).
-        // The SUPABASE_URL and SUPABASE_KEY are validated at import time
-        // by supabaseApi.ts's guard clause.
         debugLog("[SupabaseStorage] Initialized (REST API, stateless)");
     }
     async close() {
-        // No-op for Supabase — connections are stateless.
         debugLog("[SupabaseStorage] Closed (no-op for REST)");
     }
     // ─── Ledger Operations ─────────────────────────────────────
     async saveLedger(entry) {
-        // Direct mapping from sessionSaveLedgerHandler line 95
         const record = {
             project: entry.project,
             conversation_id: entry.conversation_id,
             summary: entry.summary,
             user_id: entry.user_id,
+            role: entry.role || "global", // v3.0: include role
             todos: entry.todos || [],
             files_changed: entry.files_changed || [],
             decisions: entry.decisions || [],
             keywords: entry.keywords || [],
             ...(entry.is_rollup !== undefined && { is_rollup: entry.is_rollup }),
             ...(entry.rollup_count !== undefined && { rollup_count: entry.rollup_count }),
-            // Compaction handler also sets title, agent_name for rollup entries
             ...(entry.is_rollup && {
                 title: `Session Rollup (${entry.rollup_count || 0} entries)`,
                 agent_name: "prism-compactor",
@@ -49,63 +44,36 @@ export class SupabaseStorage {
         return supabasePost("session_ledger", record);
     }
     async patchLedger(id, data) {
-        // Direct mapping from sessionSaveLedgerHandler line 115 (embedding patch)
-        // and compactionHandler line 292 (archive patch)
         await supabasePatch("session_ledger", data, { id: `eq.${id}` });
     }
     async getLedgerEntries(params) {
-        // Direct mapping from:
-        //   - compactionHandler line 143 (count entries for project)
-        //   - compactionHandler line 211 (fetch oldest entries)
-        //   - backfillEmbeddingsHandler line 700 (find missing embeddings)
-        //   - knowledgeForgetHandler line 479 (dry run count)
         const result = await supabaseGet("session_ledger", params);
         return Array.isArray(result) ? result : [];
     }
     async deleteLedger(params) {
-        // Direct mapping from knowledgeForgetHandler line 482
         const result = await supabaseDelete("session_ledger", params);
         return Array.isArray(result) ? result : [];
     }
     // ─── Phase 2: GDPR-Compliant Memory Deletion ──────────────
-    //
-    // These methods are SURGICAL — they operate on a single entry by ID.
-    // They MUST verify user_id ownership to prevent cross-user deletion.
-    //
-    // softDeleteLedger: Sets deleted_at + deleted_reason. Entry stays in
-    //   DB for audit trail. Supabase RPCs and TypeScript queries filter
-    //   it out via "WHERE deleted_at IS NULL". Reversible.
-    //
-    // hardDeleteLedger: Physical DELETE. Irreversible. For GDPR Article 17
-    //   "right to erasure" when the audit trail must also be removed.
     async softDeleteLedger(id, userId, reason) {
-        // PATCH (not DELETE): sets tombstone fields while preserving the row.
-        // The deleted_at timestamp is set server-side for consistency.
-        // deleted_reason captures the GDPR justification (e.g., "User requested",
-        // "Data retention policy", "GDPR Article 17 request").
         await supabasePatch("session_ledger", {
             deleted_at: new Date().toISOString(),
             deleted_reason: reason || null,
         }, {
             id: `eq.${id}`,
-            user_id: `eq.${userId}`, // Ownership guard — prevents cross-user deletion
+            user_id: `eq.${userId}`,
         });
         debugLog(`[SupabaseStorage] Soft-deleted ledger entry ${id} (reason: ${reason || "none"})`);
     }
     async hardDeleteLedger(id, userId) {
-        // Physical DELETE — row is permanently removed from the database.
-        // This is irreversible. The FTS5 index (if any) is cleaned up by
-        // Supabase's built-in trigger handling.
         await supabaseDelete("session_ledger", {
             id: `eq.${id}`,
-            user_id: `eq.${userId}`, // Ownership guard
+            user_id: `eq.${userId}`,
         });
         debugLog(`[SupabaseStorage] Hard-deleted ledger entry ${id}`);
     }
     // ─── Handoff Operations ────────────────────────────────────
     async saveHandoff(handoff, expectedVersion) {
-        // Direct mapping from sessionSaveHandoffHandler line 214
-        // Calls the save_handoff_with_version RPC for OCC
         const result = await supabaseRpc("save_handoff_with_version", {
             p_project: handoff.project,
             p_expected_version: expectedVersion ?? null,
@@ -116,6 +84,7 @@ export class SupabaseStorage {
             p_key_context: handoff.key_context ?? null,
             p_active_branch: handoff.active_branch ?? null,
             p_user_id: handoff.user_id,
+            p_role: handoff.role || "global", // v3.0: pass role to RPC
         });
         const data = Array.isArray(result) ? result[0] : result;
         if (data?.status === "conflict") {
@@ -130,25 +99,24 @@ export class SupabaseStorage {
         };
     }
     async deleteHandoff(project, userId) {
-        // Direct mapping from knowledgeForgetHandler line 486
         await supabaseDelete("session_handoffs", {
             project: `eq.${project}`,
             user_id: `eq.${userId}`,
         });
     }
-    async loadContext(project, level, userId) {
-        // Direct mapping from sessionLoadContextHandler line 330
+    async loadContext(project, level, userId, role // v3.0: optional role filter
+    ) {
         const result = await supabaseRpc("get_session_context", {
             p_project: project,
             p_level: level,
             p_user_id: userId,
+            p_role: role || "global", // v3.0: pass role to RPC
         });
         const data = Array.isArray(result) ? result[0] : result;
         return data ?? null;
     }
     // ─── Search Operations ─────────────────────────────────────
     async searchKnowledge(params) {
-        // Direct mapping from knowledgeSearchHandler line 388
         const result = await supabaseRpc("search_knowledge", {
             p_project: params.project || null,
             p_keywords: params.keywords,
@@ -164,7 +132,6 @@ export class SupabaseStorage {
         return data;
     }
     async searchMemory(params) {
-        // Direct mapping from sessionSearchMemoryHandler line 583
         const result = await supabaseRpc("semantic_search_ledger", {
             p_query_embedding: params.queryEmbedding,
             p_project: params.project || null,
@@ -176,7 +143,6 @@ export class SupabaseStorage {
     }
     // ─── Compaction ────────────────────────────────────────────
     async getCompactionCandidates(threshold, keepRecent, userId) {
-        // Direct mapping from compactionHandler line 165
         const result = await supabaseRpc("get_compaction_candidates", {
             p_threshold: threshold,
             p_keep_recent: keepRecent,
@@ -210,100 +176,112 @@ export class SupabaseStorage {
             order: "project.asc",
         });
         const rows = Array.isArray(data) ? data : [];
-        // Deduplicate on the client side since Supabase doesn't support DISTINCT via REST
         return [...new Set(rows.map((r) => r.project))];
     }
     // ─── v2.2.0 Health Check (fsck) ─────────────────────────────
-    /**
-     * Gather raw health statistics via Supabase REST API.
-     *
-     * Supabase REST (PostgREST) doesn't support complex JOINs,
-     * so we fetch raw data and let healthCheck.ts do the analysis
-     * in pure JS — same approach as SQLite for consistency.
-     */
     async getHealthStats(userId) {
-        // ── Check 1: Entries missing embeddings ────────────────────
-        // Fetch active entries where embedding column is null.
-        // PostgREST filter: archived_at=is.null AND embedding=is.null
         const missingData = await supabaseGet("session_ledger", {
-            select: "id", // only need count
-            user_id: `eq.${userId}`, // scope to this user
-            archived_at: "is.null", // only active entries
-            embedding: "is.null", // missing embedding
+            select: "id",
+            user_id: `eq.${userId}`,
+            archived_at: "is.null",
+            embedding: "is.null",
         });
-        // Count the returned rows (PostgREST returns array)
         const missingEmbeddings = Array.isArray(missingData) ? missingData.length : 0;
-        // ── Check 2: All active summaries for JS duplicate detection ─
-        // Pull id + project + summary so healthCheck.ts can run
-        // Jaccard similarity comparison in-memory.
         const summData = await supabaseGet("session_ledger", {
-            select: "id,project,summary", // minimal columns needed
-            user_id: `eq.${userId}`, // scope to this user
-            archived_at: "is.null", // only active entries
+            select: "id,project,summary",
+            user_id: `eq.${userId}`,
+            archived_at: "is.null",
         });
-        // Map to typed array for the health check engine
         const activeLedgerSummaries = (Array.isArray(summData) ? summData : []).map((r) => ({
-            id: r.id, // unique entry ID
-            project: r.project, // project name
-            summary: r.summary, // text for dupe comparison
+            id: r.id,
+            project: r.project,
+            summary: r.summary,
         }));
-        // ── Check 3: Find orphaned handoffs ──────────────────────────
-        // Fetch all handoff projects, then all ledger projects.
-        // Difference = orphaned handoffs (handoff but no ledger entries).
         const handoffData = await supabaseGet("session_handoffs", {
-            select: "project", // only need project names
-            user_id: `eq.${userId}`, // scope to this user
+            select: "project",
+            user_id: `eq.${userId}`,
         });
-        const handoffProjects = new Set(// set for O(1) lookup
-        (Array.isArray(handoffData) ? handoffData : [])
+        const handoffProjects = new Set((Array.isArray(handoffData) ? handoffData : [])
             .map((r) => r.project));
         const ledgerData = await supabaseGet("session_ledger", {
-            select: "project", // only need project names
-            user_id: `eq.${userId}`, // scope to this user
-            archived_at: "is.null", // only active entries
+            select: "project",
+            user_id: `eq.${userId}`,
+            archived_at: "is.null",
         });
-        const ledgerProjects = new Set(// projects that have entries
-        (Array.isArray(ledgerData) ? ledgerData : [])
+        const ledgerProjects = new Set((Array.isArray(ledgerData) ? ledgerData : [])
             .map((r) => r.project));
-        // Orphaned = in handoffs but NOT in ledger
         const orphanedHandoffs = [...handoffProjects]
-            .filter(p => !ledgerProjects.has(p)) // keep only orphans
-            .map(project => ({ project })); // wrap in object
-        // ── Check 4: Count stale rollups ─────────────────────────────
-        // PostgREST can't do self-joins. Fetch rollups and archived
-        // entries separately, then compute in JS.
+            .filter(p => !ledgerProjects.has(p))
+            .map(project => ({ project }));
         const rollupData = await supabaseGet("session_ledger", {
-            select: "id,project", // rollup ID and project
-            user_id: `eq.${userId}`, // scope to this user
-            is_rollup: "eq.true", // only rollup entries
-            archived_at: "is.null", // still active
+            select: "id,project",
+            user_id: `eq.${userId}`,
+            is_rollup: "eq.true",
+            archived_at: "is.null",
         });
         const archivedData = await supabaseGet("session_ledger", {
-            select: "project", // just need project names
-            user_id: `eq.${userId}`, // scope to this user
-            "archived_at": "not.is.null", // only archived entries
+            select: "project",
+            user_id: `eq.${userId}`,
+            "archived_at": "not.is.null",
         });
-        // Build a set of projects that have archived entries
         const archivedProjects = new Set((Array.isArray(archivedData) ? archivedData : [])
             .map((r) => r.project));
-        // Stale = rollup exists but project has no archived originals
         const rollups = Array.isArray(rollupData) ? rollupData : [];
-        const staleRollups = rollups.filter((r) => !archivedProjects.has(r.project) // no originals
-        ).length;
-        // ── Totals ───────────────────────────────────────────────────
-        // Reuse data already fetched above to avoid extra API calls
+        const staleRollups = rollups.filter((r) => !archivedProjects.has(r.project)).length;
         const totalActiveEntries = activeLedgerSummaries.length;
         const totalHandoffs = handoffProjects.size;
         const totalRollups = rollups.length;
-        // ── Return raw health stats for the JS engine ────────────────
         return {
-            missingEmbeddings, // entries needing embedding repair
-            activeLedgerSummaries, // raw summaries for JS dupe detection
-            orphanedHandoffs, // projects with handoff but no ledger
-            staleRollups, // rollups with no archived originals
-            totalActiveEntries, // grand total of active entries
-            totalHandoffs, // grand total of handoff records
-            totalRollups, // grand total of rollup entries
+            missingEmbeddings,
+            activeLedgerSummaries,
+            orphanedHandoffs,
+            staleRollups,
+            totalActiveEntries,
+            totalHandoffs,
+            totalRollups,
+        };
+    }
+    // ─── v3.0: Agent Registry (Hivemind) ───────────────────────
+    // Supabase users need to run the 017_agent_hivemind.sql migration
+    async registerAgent(entry) {
+        const record = {
+            project: entry.project,
+            user_id: entry.user_id,
+            role: entry.role,
+            agent_name: entry.agent_name ?? null,
+            status: entry.status || "active",
+            current_task: entry.current_task ?? null,
         };
+        const result = await supabasePost("agent_registry", record);
+        const data = Array.isArray(result) ? result[0] : result;
+        return { ...entry, id: data?.id, status: entry.status || "active" };
+    }
+    async heartbeatAgent(project, userId, role, currentTask) {
+        const patchData = {
+            last_heartbeat: new Date().toISOString(),
+        };
+        if (currentTask !== undefined) {
+            patchData.current_task = currentTask;
+        }
+        await supabasePatch("agent_registry", patchData, {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+            role: `eq.${role}`,
+        });
+    }
+    async listTeam(project, userId, _staleMinutes = 30) {
+        const data = await supabaseGet("agent_registry", {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+            order: "last_heartbeat.desc",
+        });
+        return (Array.isArray(data) ? data : []);
+    }
+    async deregisterAgent(project, userId, role) {
+        await supabaseDelete("agent_registry", {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+            role: `eq.${role}`,
+        });
     }
 }

package/dist/tools/agentRegistryDefinitions.js

@@ -0,0 +1,104 @@
+/**
+ * Agent Registry Tool Definitions (v3.0 — Agent Hivemind)
+ *
+ * Three new MCP tools for multi-agent coordination:
+ *   - agent_register: Register an agent with project + role
+ *   - agent_heartbeat: Update heartbeat + current task
+ *   - agent_list_team: List active agents on a project
+ *
+ * These tools are ONLY registered when PRISM_ENABLE_HIVEMIND=true
+ * (see server.ts). This prevents increasing the tool count for
+ * users who don't need multi-agent features.
+ */
+// ─── Role Icons (for dashboard + responses) ──────────────────
+export const ROLE_ICONS = {
+    dev: "🛠️",
+    qa: "🔍",
+    pm: "📋",
+    lead: "🏗️",
+    security: "🔒",
+    ux: "🎨",
+    cmo: "📢",
+    global: "🌐",
+};
+/** Get icon for a role, with fallback for custom roles (Pro-Tip 4) */
+export function getRoleIcon(role) {
+    return ROLE_ICONS[role.toLowerCase()] || "🤖";
+}
+// ─── Tool Definitions ────────────────────────────────────────
+export const AGENT_REGISTER_TOOL = {
+    name: "agent_register",
+    description: "Register this agent with the Hivemind team for a project. " +
+        "Announces your role and current task to other agents. " +
+        "If already registered, updates the existing entry. " +
+        "Other agents will see you when they call agent_list_team or session_load_context.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project identifier (e.g., 'prism-mcp').",
+            },
+            role: {
+                type: "string",
+                description: "Your agent role. Common roles: 'dev', 'qa', 'pm', 'lead', 'security', 'ux'. " +
+                    "Custom roles are also supported (e.g., 'translator', 'docs').",
+            },
+            agent_name: {
+                type: "string",
+                description: "Optional human-readable name for this agent (e.g., 'Backend Dev #1').",
+            },
+            current_task: {
+                type: "string",
+                description: "Optional description of what you're currently working on.",
+            },
+        },
+        required: ["project", "role"],
+    },
+};
+export const AGENT_HEARTBEAT_TOOL = {
+    name: "agent_heartbeat",
+    description: "Update your heartbeat and optionally your current task. " +
+        "Call this periodically to stay visible to the team. " +
+        "Agents that haven't sent a heartbeat in 30 minutes are auto-pruned.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project identifier.",
+            },
+            role: {
+                type: "string",
+                description: "Your agent role.",
+            },
+            current_task: {
+                type: "string",
+                description: "Optional updated description of your current task.",
+            },
+        },
+        required: ["project", "role"],
+    },
+};
+export const AGENT_LIST_TEAM_TOOL = {
+    name: "agent_list_team",
+    description: "List all active agents on a project. Shows role, status, current task, " +
+        "and last heartbeat time. Automatically prunes agents that haven't " +
+        "reported in 30+ minutes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project identifier.",
+            },
+        },
+        required: ["project"],
+    },
+};
+/** All Hivemind agent registry tools — conditionally registered */
+export const AGENT_REGISTRY_TOOLS = [
+    AGENT_REGISTER_TOOL,
+    AGENT_HEARTBEAT_TOOL,
+    AGENT_LIST_TEAM_TOOL,
+];

package/dist/tools/agentRegistryHandlers.js

@@ -0,0 +1,114 @@
+/**
+ * Agent Registry Handlers (v3.0 — Agent Hivemind)
+ *
+ * Handler implementations for the 3 agent registry MCP tools.
+ * These are only called when PRISM_ENABLE_HIVEMIND=true.
+ */
+import { getStorage } from "../storage/index.js";
+import { PRISM_USER_ID } from "../config.js";
+import { getRoleIcon } from "./agentRegistryDefinitions.js";
+// ─── Type Guards ─────────────────────────────────────────────
+function isAgentRegisterArgs(args) {
+    return typeof args.project === "string" && typeof args.role === "string";
+}
+function isAgentHeartbeatArgs(args) {
+    return typeof args.project === "string" && typeof args.role === "string";
+}
+function isAgentListTeamArgs(args) {
+    return typeof args.project === "string";
+}
+// ─── Handlers ────────────────────────────────────────────────
+export async function agentRegisterHandler(args) {
+    if (!isAgentRegisterArgs(args)) {
+        return {
+            content: [{ type: "text", text: "Missing required: project, role" }],
+            isError: true,
+        };
+    }
+    const storage = await getStorage();
+    const result = await storage.registerAgent({
+        project: args.project,
+        user_id: PRISM_USER_ID,
+        role: args.role,
+        agent_name: args.agent_name || null,
+        status: "active",
+        current_task: args.current_task || null,
+    });
+    const icon = getRoleIcon(args.role);
+    return {
+        content: [{
+                type: "text",
+                text: `${icon} **Agent Registered**\n\n` +
+                    `- **Project:** ${args.project}\n` +
+                    `- **Role:** ${args.role}\n` +
+                    (args.agent_name ? `- **Name:** ${args.agent_name}\n` : "") +
+                    (args.current_task ? `- **Task:** ${args.current_task}\n` : "") +
+                    `\nOther agents will see you when they call \`agent_list_team\` or \`session_load_context\`.`,
+            }],
+    };
+}
+export async function agentHeartbeatHandler(args) {
+    if (!isAgentHeartbeatArgs(args)) {
+        return {
+            content: [{ type: "text", text: "Missing required: project, role" }],
+            isError: true,
+        };
+    }
+    const storage = await getStorage();
+    await storage.heartbeatAgent(args.project, PRISM_USER_ID, args.role, args.current_task);
+    return {
+        content: [{
+                type: "text",
+                text: `💓 Heartbeat updated for **${args.role}** on \`${args.project}\`.` +
+                    (args.current_task ? ` Task: ${args.current_task}` : ""),
+            }],
+    };
+}
+export async function agentListTeamHandler(args) {
+    if (!isAgentListTeamArgs(args)) {
+        return {
+            content: [{ type: "text", text: "Missing required: project" }],
+            isError: true,
+        };
+    }
+    const storage = await getStorage();
+    const team = await storage.listTeam(args.project, PRISM_USER_ID);
+    if (team.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No active agents on \`${args.project}\`. Use \`agent_register\` to join the team.`,
+                }],
+        };
+    }
+    const lines = team.map(agent => {
+        const icon = getRoleIcon(agent.role);
+        const ago = agent.last_heartbeat
+            ? getTimeAgo(agent.last_heartbeat)
+            : "unknown";
+        return (`${icon} **${agent.role}**` +
+            (agent.agent_name ? ` (${agent.agent_name})` : "") +
+            ` — ${agent.status}` +
+            (agent.current_task ? ` | Task: ${agent.current_task}` : "") +
+            ` | Last seen: ${ago}`);
+    });
+    return {
+        content: [{
+                type: "text",
+                text: `## 🐝 Active Hivemind Team — \`${args.project}\`\n\n` +
+                    lines.join("\n") +
+                    `\n\n_${team.length} agent(s) active. Stale agents (>30min) auto-pruned._`,
+            }],
+    };
+}
+// ─── Helpers ─────────────────────────────────────────────────
+function getTimeAgo(isoString) {
+    const diff = Date.now() - new Date(isoString).getTime();
+    const mins = Math.floor(diff / 60000);
+    if (mins < 1)
+        return "just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    return `${hours}h ago`;
+}

package/dist/tools/index.js

@@ -33,3 +33,8 @@ export { sessionSaveLedgerHandler, sessionSaveHandoffHandler, sessionLoadContext
 // more complex than the other session memory handlers (chunked Gemini
 // API calls, recursive summarization, etc.).
 export { compactLedgerHandler } from "./compactionHandler.js";
+// ── Agent Registry Tools (v3.0 — Hivemind, Optional) ──
+// These tools are only registered when PRISM_ENABLE_HIVEMIND=true.
+// server.ts handles the conditional registration.
+export { AGENT_REGISTRY_TOOLS, getRoleIcon } from "./agentRegistryDefinitions.js";
+export { agentRegisterHandler, agentHeartbeatHandler, agentListTeamHandler } from "./agentRegistryHandlers.js";

package/dist/tools/sessionMemoryDefinitions.js

@@ -35,6 +35,10 @@ export const SESSION_SAVE_LEDGER_TOOL = {
                 items: { type: "string" },
                 description: "Optional list of key decisions made during this session.",
             },
+            role: {
+                type: "string",
+                description: "v3.0: Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Defaults to 'global'.",
+            },
         },
         required: ["project", "conversation_id", "summary"],
     },
@@ -84,6 +88,10 @@ export const SESSION_SAVE_HANDOFF_TOOL = {
                 type: "string",
                 description: "Free-form critical context the next session needs to know.",
             },
+            role: {
+                type: "string",
+                description: "v3.0: Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Defaults to 'global'.",
+            },
         },
         required: ["project"],
     },
@@ -109,6 +117,10 @@ export const SESSION_LOAD_CONTEXT_TOOL = {
                 enum: ["quick", "standard", "deep"],
                 description: "How much context to load: 'quick' (just TODOs), 'standard' (recommended — includes recent summaries), or 'deep' (full history). Default: standard.",
             },
+            role: {
+                type: "string",
+                description: "v3.0: Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Defaults to 'global'. When set, also injects active_team roster.",
+            },
         },
         required: ["project"],
     },

package/dist/tools/sessionMemoryHandlers.js

@@ -46,7 +46,7 @@ export async function sessionSaveLedgerHandler(args) {
     if (!isSessionSaveLedgerArgs(args)) {
         throw new Error("Invalid arguments for session_save_ledger");
     }
-    const { project, conversation_id, summary, todos, files_changed, decisions } = args;
+    const { project, conversation_id, summary, todos, files_changed, decisions, role } = args;
     const storage = await getStorage();
     debugLog(`[session_save_ledger] Saving ledger entry for project="${project}"`);
     // Auto-extract keywords from summary + decisions for knowledge accumulation
@@ -63,6 +63,7 @@ export async function sessionSaveLedgerHandler(args) {
         files_changed: files_changed || [],
         decisions: decisions || [],
         keywords,
+        role: role || "global", // v3.0: Hivemind role scoping
     });
     // ─── Fire-and-forget embedding generation ───
     if (GOOGLE_API_KEY && result) {
@@ -104,7 +105,8 @@ export async function sessionSaveHandoffHandler(args, server) {
     if (!isSessionSaveHandoffArgs(args)) {
         throw new Error("Invalid arguments for session_save_handoff");
     }
-    const { project, expected_version, open_todos, active_branch, last_summary, key_context, } = args;
+    const { project, expected_version, open_todos, active_branch, last_summary, key_context, role, // v3.0: Hivemind role
+     } = args;
     const storage = await getStorage();
     debugLog(`[session_save_handoff] Saving handoff for project="${project}" ` +
         `(expected_version=${expected_version ?? "none"})`);
@@ -133,6 +135,7 @@ export async function sessionSaveHandoffHandler(args, server) {
         key_context: key_context ?? null,
         active_branch: active_branch ?? null,
         metadata,
+        role: role || "global", // v3.0: Hivemind role scoping
     }, expected_version ?? null);
     // ─── Handle version conflict ───
     if (data.status === "conflict") {
@@ -317,7 +320,7 @@ export async function sessionLoadContextHandler(args) {
     if (!isSessionLoadContextArgs(args)) {
         throw new Error("Invalid arguments for session_load_context");
     }
-    const { project, level = "standard" } = args;
+    const { project, level = "standard", role } = args;
     const validLevels = ["quick", "standard", "deep"];
     if (!validLevels.includes(level)) {
         return {
@@ -330,7 +333,7 @@ export async function sessionLoadContextHandler(args) {
     }
     debugLog(`[session_load_context] Loading ${level} context for project="${project}"`);
     const storage = await getStorage();
-    const data = await storage.loadContext(project, level, PRISM_USER_ID);
+    const data = await storage.loadContext(project, level, PRISM_USER_ID, role); // v3.0: pass role
     if (!data) {
         return {
             content: [{

package/dist/utils/googleAi.js

@@ -38,7 +38,7 @@ export async function createMcpClient() {
         command: "node",
         args: ["index.js"], // Server entry point
     });
-    const client = new Client({ name: "gemini-mcp-client", version: "1.0.0" }, { capabilities: { tools: {} } });
+    const client = new Client({ name: "gemini-mcp-client", version: "1.0.0" });
     await client.connect(transport);
     return { client, transport };
 }