@marsnme/mcp-gateway 0.1.8 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marsnme/mcp-gateway",
-  "version": "0.1.8",
+  "version": "0.2.1",
   "mcpName": "io.github.Marsmanleo/marsnme",
   "private": false,
   "description": "Agent-agnostic, LLM-agnostic memory backend for MCP-compatible tools",
@@ -26,7 +26,8 @@
     "session-memory",
     "cross-session",
     "llm",
-    "symbiosis"
+    "symbiosis",
+    "perplexity"
   ],
   "bin": {
     "marsnme": "server.mjs"
@@ -48,4 +49,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}

package/server.mjs

@@ -2,6 +2,7 @@
 import http from 'node:http';
 import crypto from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 
@@ -171,6 +172,28 @@ if (!Number.isInteger(PORT) || PORT < 1 || PORT > 65535) {
   throw new Error(`Invalid PORT: ${PORT_RAW || String(PORT)}. Must be an integer between 1 and 65535.`);
 }
 const SUPABASE_BASE_URL = process.env.SUPABASE_BASE_URL || 'http://127.0.0.1:8100';
+const SUPABASE_AUTH_MODE_VALUES = new Set(['service', 'anon', 'hybrid']);
+const SUPABASE_AUTH_MODE_RAW = String(process.env.MCP_SUPABASE_AUTH_MODE || 'service')
+  .trim()
+  .toLowerCase();
+if (SUPABASE_AUTH_MODE_RAW && !SUPABASE_AUTH_MODE_VALUES.has(SUPABASE_AUTH_MODE_RAW)) {
+  console.warn(
+    `[config] invalid MCP_SUPABASE_AUTH_MODE=${SUPABASE_AUTH_MODE_RAW}; fallback to service`
+  );
+}
+const SUPABASE_AUTH_MODE = SUPABASE_AUTH_MODE_VALUES.has(SUPABASE_AUTH_MODE_RAW)
+  ? SUPABASE_AUTH_MODE_RAW
+  : 'service';
+const SUPABASE_ANON_KEY = String(process.env.SUPABASE_ANON_KEY || '').trim();
+const ANON_ALLOWED_TOOL_NAMES = new Set([
+  'list_memories',
+  'search_memories',
+  'reload_source_registry',
+  'recall',
+  'health_check',
+  'explain_memory'
+]);
+const SUPABASE_REQUEST_CONTEXT = new AsyncLocalStorage();
 const OAUTH_ENABLED = process.env.MCP_OAUTH_ENABLED !== 'false';
 const REQUIRE_BEARER = process.env.MCP_REQUIRE_BEARER === 'true';
 const BYPASS_BEARER_FOR_PRIVATE = process.env.MCP_BYPASS_BEARER_FOR_PRIVATE !== 'false';
@@ -284,29 +307,29 @@ function buildTools() {
   return [
     {
       name: 'insert_memory',
-      description: `Insert a short-term ${PROFILE.displayName} memory into ${DB_PROFILE}.memories (ephemeral context)`,
+      description: `Store a short-term ${PROFILE.displayName} memory into ${DB_PROFILE}.memories (ephemeral context that auto-expires). Use this to capture observations, decisions, session notes, or any context worth remembering temporarily. Memories last 7 days by default unless expires_at is set. For permanent knowledge, use memory_ingest instead.`,
       inputSchema: {
         type: 'object',
         properties: {
-          body: { type: 'string', description: 'Memory content text' },
+          body: { type: 'string', description: 'The memory content to store. Be specific and include relevant context — this text is used for semantic search later.' },
           source: buildMemorySourceSchema(),
-          session_id: { type: 'string', description: 'Session trace id' },
+          session_id: { type: 'string', description: 'Unique identifier for the current session/conversation. Used to group related memories together.' },
           tags: {
             type: 'array',
             items: { type: 'string' },
-            description: 'Optional tags list'
+            description: 'Categorization labels for filtering (e.g. ["decision", "architecture", "bugfix"])'
           },
           expires_at: {
             type: 'string',
-            description: 'Optional ISO timestamp override'
+            description: 'Custom expiration time in ISO 8601 format (e.g. "2026-06-17T00:00:00Z"). Defaults to 7 days from now if omitted.'
           },
           agent_body: {
             type: 'string',
-            description: 'Optional body label (default inferred from source)'
+            description: 'Which persona/agent body this memory belongs to (e.g. "coco", "toto"). Defaults to the profile of this server.'
           },
           environment: {
             type: 'string',
-            description: 'Optional environment label (default from MCP_ENVIRONMENT)'
+            description: 'Deployment environment label (e.g. "production", "staging"). Defaults to MCP_ENVIRONMENT if set.'
           }
         },
         required: ['body', 'source', 'session_id'],
@@ -315,36 +338,36 @@ function buildTools() {
     },
     {
       name: 'list_memories',
-      description: `List recent memories from ${DB_PROFILE}.memories`,
+      description: `List recent short-term memories from ${DB_PROFILE}.memories in reverse chronological order — like a daily log or activity feed. Use this to review what was recently captured, check for duplicate memories before inserting, or browse recent activity. This is a time-ordered listing tool, not a search tool. For semantic search by meaning, use search_memories instead. For long-term knowledge retrieval, use recall. Returns memory body, source, creation time, and expiration status.`,
       inputSchema: {
         type: 'object',
         properties: {
-          limit: { type: 'number', minimum: 1, maximum: 100, default: 20 },
+          limit: { type: 'number', minimum: 1, maximum: 100, default: 20, description: 'Maximum number of memories to return (default 20)' },
           source: buildMemorySourceSchema(),
-          unexpired_only: { type: 'boolean', default: true }
+          unexpired_only: { type: 'boolean', default: true, description: 'When true (default), only return memories that have not yet expired. Set false to include expired entries.' }
         },
         additionalProperties: false
       }
     },
     {
       name: 'search_memories',
-      description: `Semantic search memories from ${DB_PROFILE}.memories using Jina embeddings`,
+      description: `Semantic search across short-term memories in ${DB_PROFILE}.memories using Jina embeddings. Finds memories by meaning, not just keywords — ask a natural language question and get the most relevant matches. Use this to recall past decisions, find related context, or check if something was already discussed recently.`,
       inputSchema: {
         type: 'object',
         properties: {
-          query: { type: 'string', description: 'Semantic search query text' },
-          limit: { type: 'number', minimum: 1, maximum: 100, default: 20 },
+          query: { type: 'string', description: 'Natural language search query. Describe what you are looking for — semantic matching finds relevant results even without exact keywords.' },
+          limit: { type: 'number', minimum: 1, maximum: 100, default: 20, description: 'Maximum number of results to return' },
           source: buildMemorySourceSchema(),
-          unexpired_only: { type: 'boolean', default: true },
-          min_similarity: { type: 'number', minimum: -1, maximum: 1 },
-          scope: { type: 'string', enum: ['this_body', 'all_bodies'], default: 'this_body' },
+          unexpired_only: { type: 'boolean', default: true, description: 'When true (default), exclude expired memories from results' },
+          min_similarity: { type: 'number', minimum: -1, maximum: 1, description: 'Minimum cosine similarity threshold for results (range -1 to 1). Higher values return fewer but more relevant matches.' },
+          scope: { type: 'string', enum: ['this_body', 'all_bodies'], default: 'this_body', description: 'Search scope: "this_body" searches only the current profile, "all_bodies" searches across all personas.' },
           agent_body: {
             type: 'string',
-            description: 'Optional body scope key; defaults to source/body/env inference'
+            description: 'Filter results to a specific persona/body (e.g. "coco", "toto")'
           },
           environment: {
             type: 'string',
-            description: 'Optional environment filter'
+            description: 'Filter results to a specific environment (e.g. "production", "staging")'
           }
         },
         required: ['query'],
@@ -354,7 +377,7 @@ function buildTools() {
     {
       name: 'reload_source_registry',
       description:
-        `Reload enabled sources cache from ${DB_PROFILE}.${SOURCE_REGISTRY_TABLE} (effective when MCP_SOURCE_MODE=registry)`,
+        `Reload the source registry cache from ${DB_PROFILE}.${SOURCE_REGISTRY_TABLE}. Use this after adding or removing entries to refresh which sources are enabled for insert/search filtering. Only effective when running in registry mode (MCP_SOURCE_MODE=registry).`,
       inputSchema: {
         type: 'object',
         properties: {},
@@ -363,31 +386,31 @@ function buildTools() {
     },
     {
       name: 'recall',
-      description: `Semantic recall from ${DB_PROFILE}.marsvault_chunks using Jina embeddings`,
+      description: `Semantic recall from long-term memory (${DB_PROFILE}.marsvault_chunks) using Jina embeddings. Searches across promoted insights, digests, and archived knowledge using vector similarity. Use this to retrieve established patterns, past decisions, documented workflows, or any knowledge that was previously promoted to long-term storage. This is the primary tool for accessing institutional memory.`,
       inputSchema: {
         type: 'object',
         properties: {
-          query: { type: 'string', description: 'Semantic recall query text' },
-          limit: { type: 'number', minimum: 1, maximum: 50, default: 5 },
-          body: { type: 'string', enum: PROFILE.recallBodyEnum, default: DB_PROFILE },
-          include_global: { type: 'boolean', default: true },
-          include_shared: { type: 'boolean', default: true },
-          include_private: { type: 'boolean', default: true },
-          type: { type: 'string', description: 'Optional chunk type filter' },
-          min_similarity: { type: 'number', minimum: -1, maximum: 1 },
-          scope: { type: 'string', enum: ['this_body', 'all_bodies'], default: 'this_body' },
+          query: { type: 'string', description: 'Natural language query describing what knowledge you need. The system finds semantically similar chunks — describe the concept, not just keywords.' },
+          limit: { type: 'number', minimum: 1, maximum: 50, default: 5, description: 'Maximum number of chunks to return (default 5)' },
+          body: { type: 'string', enum: PROFILE.recallBodyEnum, default: DB_PROFILE, description: 'Which persona profile to search in (e.g. "coco", "toto", "system")' },
+          include_global: { type: 'boolean', default: true, description: 'Include globally visible chunks in results' },
+          include_shared: { type: 'boolean', default: true, description: 'Include shared-visibility chunks in results' },
+          include_private: { type: 'boolean', default: true, description: 'Include private chunks in results' },
+          type: { type: 'string', description: 'Filter by chunk type (e.g. "insight", "digest", "observation")' },
+          min_similarity: { type: 'number', minimum: -1, maximum: 1, description: 'Minimum cosine similarity threshold. Raise for higher precision, lower for broader recall.' },
+          scope: { type: 'string', enum: ['this_body', 'all_bodies'], default: 'this_body', description: 'Search scope: "this_body" for current profile only, "all_bodies" for cross-persona search' },
           agent_body: {
             type: 'string',
-            description: 'Optional body scope key; defaults to MCP_AGENT_BODY when present'
+            description: 'Filter to a specific persona/body scope'
           },
           environment: {
             type: 'string',
-            description: 'Optional environment filter'
+            description: 'Filter to a specific environment label'
           },
           debug_explain: {
             type: 'boolean',
             default: false,
-            description: 'Include query/hit token overlap debug details'
+            description: 'When true, include token overlap details in each result for debugging relevance'
           }
         },
         required: ['query'],
@@ -396,7 +419,7 @@ function buildTools() {
     },
     {
       name: 'health_check',
-      description: `Run ${PROFILE.displayName} memory health diagnostics (count_chunks, expiry_alert, coverage_map, detect_conflicts)`,
+      description: `Run comprehensive ${PROFILE.displayName} memory system diagnostics. Returns chunk counts by type and visibility, identifies expiring short-term memories that need promotion, detects timeline coverage gaps, and finds conflicting or redundant long-term chunks. Use this regularly to maintain memory hygiene and before batch promotion.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -491,11 +514,11 @@ function buildTools() {
     {
       name: 'session_boot',
       description:
-        'One-call session boot rhythm: always run identity/workflow/status recall + expiry-focused health snapshot + heartbeat sign-in',
+        `Initialize a new ${PROFILE.displayName} session by loading identity, workflow context, and recent status from long-term memory. Also runs an expiry-focused health snapshot and records a heartbeat sign-in. Call this once at the start of every new conversation to restore continuity and awareness of pending work.`,
       inputSchema: {
         type: 'object',
         properties: {
-          source: { type: 'string', enum: PROFILE.sourceWhitelist },
+          source: { type: 'string', enum: PROFILE.sourceWhitelist, description: 'Source tool identifier (e.g. "warp", "cursor", "perplexity") for provenance tracking' },
           body_name: {
             type: 'string',
             description: 'Optional body/persona name (例如：大家姐、三哥、五妹、Toto)'
@@ -528,7 +551,8 @@ function buildTools() {
             type: 'number',
             minimum: 1,
             maximum: 10,
-            default: 5
+            default: 5,
+            description: 'Maximum recall results per category (identity/workflow/status, default 5)'
           },
           alert_window_hours: {
             type: 'number',
@@ -556,7 +580,7 @@ function buildTools() {
     {
       name: 'session_close',
       description:
-        'Store session close summary with 7-day retention for CoCo/Toto rhythm closure',
+        `Save a ${PROFILE.displayName} session close summary before ending a conversation. The summary is stored as a short-term memory with 7-day retention, providing context for the next session boot. Include what was accomplished, what is still pending, and any important context for continuity.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -581,24 +605,24 @@ function buildTools() {
     },
     {
       name: 'dream_ingest',
-      description: `Chunk and ingest Hermes digest text into ${DB_PROFILE}.marsvault_chunks as long-term insight data`,
+      description: `Ingest a Hermes digest (periodic summary report) into ${DB_PROFILE}.marsvault_chunks long-term memory. The content is automatically chunked into semantically meaningful segments and stored with vector embeddings for future recall. Use this for scheduled reports, daily digests, or any structured summary content that should be permanently available.`,
       inputSchema: {
         type: 'object',
         properties: {
-          content: { type: 'string', description: 'Digest full text content' },
-          source_file: { type: 'string', description: 'Logical source path for digest' },
-          section: { type: 'string', description: 'Section label prefix' },
+          content: { type: 'string', description: 'The full text content of the digest to ingest. Will be automatically split into semantically coherent chunks.' },
+          source_file: { type: 'string', description: 'Logical file path or identifier for the source of this digest (e.g. "hermes/daily/2026-06-10")' },
+          section: { type: 'string', description: 'Optional section label prefix to tag all resulting chunks' },
           tags: {
             type: 'array',
             items: { type: 'string' },
-            description: 'Optional tags list'
+            description: 'Tags for categorization (e.g. ["digest", "daily", "report"])'
           },
-          type: { type: 'string', description: 'Chunk type', default: 'digest' },
-          date: { type: 'string', description: 'Optional YYYY-MM-DD date override' },
-          body: { type: 'string', enum: PROFILE.recallBodyEnum, default: DB_PROFILE },
-          visibility: { type: 'string', enum: ['private', 'shared', 'global'], default: 'private' },
-          origin: { type: 'string', description: 'Origin marker', default: PROFILE.digestDefaultOrigin },
-          max_chunk_chars: { type: 'number', minimum: 300, maximum: 3000, default: 1200 }
+          type: { type: 'string', description: 'Chunk type label', default: 'digest' },
+          date: { type: 'string', description: 'Date for this digest in YYYY-MM-DD format. Defaults to today if omitted.' },
+          body: { type: 'string', enum: PROFILE.recallBodyEnum, default: DB_PROFILE, description: 'Target persona profile for storage' },
+          visibility: { type: 'string', enum: ['private', 'shared', 'global'], default: 'private', description: 'Access level: "private" = owner only, "shared" = cross-profile, "global" = system-wide' },
+          origin: { type: 'string', description: 'Origin marker identifying where this content came from', default: PROFILE.digestDefaultOrigin },
+          max_chunk_chars: { type: 'number', minimum: 300, maximum: 3000, default: 1200, description: 'Maximum character length per chunk (default 1200). Larger values = fewer, longer chunks.' }
         },
         required: ['content'],
         additionalProperties: false
@@ -606,48 +630,48 @@ function buildTools() {
     },
     {
       name: PROFILE.memoryIngestToolName,
-      description: `Chunk and ingest ${PROFILE.displayName} long-term insight content into ${DB_PROFILE}.marsvault_chunks (not short-memory)`,
+      description: `Promote content into permanent long-term memory (${DB_PROFILE}.marsvault_chunks). Automatically chunks the input text, generates vector embeddings, and stores each segment for semantic recall. Use this to preserve important insights, decisions, patterns, or knowledge that should survive beyond the current session. This is the primary path from ephemeral to permanent memory.`,
       inputSchema: {
         type: 'object',
         properties: {
-          content: { type: 'string', description: 'Insight full text content' },
-          source_file: { type: 'string', description: 'Logical source path for insight content' },
-          section: { type: 'string', description: 'Section label prefix' },
+          content: { type: 'string', description: 'The insight content to promote to long-term memory. Be specific and self-contained — future recall depends on the quality of this text.' },
+          source_file: { type: 'string', description: 'Logical file path or identifier for the source (e.g. "sessions/2026-06-10-session-notes")' },
+          section: { type: 'string', description: 'Optional section label prefix to organize chunks within the source' },
           tags: {
             type: 'array',
             items: { type: 'string' },
-            description: 'Optional tags list'
+            description: 'Categorization tags (e.g. ["decision", "architecture"])'
           },
-          type: { type: 'string', description: 'Chunk type', default: 'insight' },
-          date: { type: 'string', description: 'Optional YYYY-MM-DD date override' },
-          visibility: { type: 'string', enum: ['private', 'shared', 'global'], default: 'private' },
+          type: { type: 'string', description: 'Content type label (e.g. "insight", "observation", "decision")', default: 'insight' },
+          date: { type: 'string', description: 'Date for this content in YYYY-MM-DD format. Defaults to today if omitted.' },
+          visibility: { type: 'string', enum: ['private', 'shared', 'global'], default: 'private', description: 'Access level: "private" = this profile only, "shared" = cross-profile readable, "global" = system-wide' },
           origin: buildMemoryIngestOriginSchema(),
           source_memory_id: {
             type: 'string',
-            description: 'Optional short-memory id to link promoted long-memory chunks'
+            description: 'Link this promotion to a specific short-term memory ID (for traceability)'
           },
           source_session_id: {
             type: 'string',
-            description: 'Optional source session id for provenance'
+            description: 'Session ID where this insight originated (for provenance tracking)'
           },
           source_tool: {
             type: 'string',
             enum: PROFILE.sourceWhitelist,
-            description: 'Optional source tool for provenance'
+            description: 'The tool/platform where this insight was originally captured'
           },
           source_user_note: {
             type: 'string',
-            description: 'Optional user note describing why this memory was promoted'
+            description: 'Brief note explaining why this memory was selected for promotion'
           },
           agent_body: {
             type: 'string',
-            description: 'Optional body label for memory boundary'
+            description: 'The persona/body this memory belongs to (e.g. "coco", "toto")'
           },
           environment: {
             type: 'string',
-            description: 'Optional environment label'
+            description: 'Environment label (e.g. "production", "staging")'
           },
-          max_chunk_chars: { type: 'number', minimum: 300, maximum: 3000, default: 1200 }
+          max_chunk_chars: { type: 'number', minimum: 300, maximum: 3000, default: 1200, description: 'Maximum characters per chunk (default 1200). Adjust for finer or coarser granularity.' }
         },
         required: ['content'],
         additionalProperties: false
@@ -655,19 +679,19 @@ function buildTools() {
     },
     {
       name: 'demote_memory',
-      description: `Mark a long-memory chunk as deprecated/superseded in ${DB_PROFILE}.marsvault_chunks`,
+      description: `Deprecate a long-term memory chunk in ${DB_PROFILE}.marsvault_chunks, marking it as outdated or superseded. The chunk is not deleted — it is flagged so it no longer appears in recall results. Use this when information becomes incorrect, irrelevant, or is replaced by newer knowledge. Optionally link to the replacement chunk for traceability.`,
       inputSchema: {
         type: 'object',
         properties: {
-          id: { type: 'string', description: 'Long-memory chunk id (UUID)' },
-          deprecated_reason: { type: 'string', description: 'Reason for deprecation' },
+          id: { type: 'string', description: 'UUID of the long-term memory chunk to deprecate' },
+          deprecated_reason: { type: 'string', description: 'Why this memory is being deprecated (e.g. "superseded by newer architecture decision", "information confirmed incorrect")' },
           superseded_by: {
             type: 'string',
-            description: 'Optional replacement chunk id (UUID) when this memory is superseded'
+            description: 'UUID of the replacement chunk, if this memory is being superseded by updated content'
           },
           deprecated_at: {
             type: 'string',
-            description: 'Optional ISO timestamp override; defaults to now'
+            description: 'Custom deprecation timestamp in ISO 8601 format. Defaults to now if omitted.'
           }
         },
         required: ['id', 'deprecated_reason'],
@@ -676,7 +700,7 @@ function buildTools() {
     },
     {
       name: 'soft_forget',
-      description: `Expire short-memory rows early in ${DB_PROFILE}.memories (manual cleanup without hard delete)`,
+      description: `Expire short-term memories in ${DB_PROFILE}.memories early without permanently deleting them. Marked memories become invisible to search and list operations but remain in the database for audit purposes. Use this to clean up irrelevant or incorrect short-term memories before their natural expiration.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -685,15 +709,15 @@ function buildTools() {
             items: { type: 'string' },
             minItems: 1,
             maxItems: 50,
-            description: 'Short-memory IDs (UUID) to expire immediately'
+            description: 'Array of short-term memory UUIDs to expire. Up to 50 at a time.'
           },
           reason: {
             type: 'string',
-            description: 'Optional note for why these memories are being soft-forgotten'
+            description: 'Brief explanation of why these memories are being forgotten (for audit trail)'
           },
           forgotten_at: {
             type: 'string',
-            description: 'Optional ISO timestamp override; defaults to now'
+            description: 'Custom expiration timestamp in ISO 8601 format. Defaults to now if omitted.'
           }
         },
         required: ['ids'],
@@ -702,20 +726,61 @@ function buildTools() {
     },
     {
       name: 'explain_memory',
-      description: `Explain provenance of a long-memory chunk in ${DB_PROFILE}.marsvault_chunks (source memory/session/tool/timeline)`,
+      description: `Trace the full provenance of a long-term memory chunk in ${DB_PROFILE}.marsvault_chunks — where it came from, how it was created, and what source material it was derived from. Returns the original source memory, session, tool, and timeline information. Use this to understand why a piece of knowledge exists or to verify its reliability.`,
       inputSchema: {
         type: 'object',
         properties: {
-          id: { type: 'string', description: 'Long-memory chunk id (UUID)' }
+          id: { type: 'string', description: 'UUID of the long-term memory chunk to explain' }
         },
         required: ['id'],
         additionalProperties: false
       }
+    },
+    {
+      name: 'batch_promote',
+      description: `Automatically promote expiring short-term memories from ${DB_PROFILE}.memories to permanent long-term storage (${DB_PROFILE}.marsvault_chunks). Scans for memories that will expire within the alert window, then chunks and ingests each one with vector embeddings. Use this to prevent valuable context from being lost when short-term memories expire. Supports dry-run mode to preview candidates before committing.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          alert_window_hours: {
+            type: 'number',
+            minimum: 1,
+            maximum: 720,
+            default: 48,
+            description: 'Look-ahead window in hours. Memories expiring within this window are candidates for promotion (default 48).'
+          },
+          max_promote: {
+            type: 'number',
+            minimum: 1,
+            maximum: 50,
+            default: 10,
+            description: 'Maximum number of memories to promote in a single batch (default 10).'
+          },
+          dry_run: {
+            type: 'boolean',
+            default: false,
+            description: 'When true, list candidate memories without actually promoting them. Use to preview before committing.'
+          },
+          memory_ids: {
+            type: 'array',
+            items: { type: 'string' },
+            maxItems: 50,
+            description: 'Explicit list of short-term memory UUIDs to promote. When provided, auto-detection is skipped and only these IDs are processed.'
+          },
+          origin: {
+            type: 'string',
+            description: 'Origin marker tagged on all promoted chunks for traceability',
+            default: 'batch-promote'
+          }
+        },
+        additionalProperties: false
+      }
     }
   ];
 }
 
 const TOOLS = buildTools();
+const TOOL_BY_NAME = new Map(TOOLS.map((tool) => [tool.name, tool]));
 
 const OAUTH_CLIENTS = new Map();
 const OAUTH_CODES = new Map();
@@ -876,7 +941,15 @@ function getServiceKey() {
   );
 }
 
-const SERVICE_KEY = getServiceKey();
+const SERVICE_KEY = SUPABASE_AUTH_MODE === 'anon' ? '' : getServiceKey();
+if (
+  (SUPABASE_AUTH_MODE === 'anon' || SUPABASE_AUTH_MODE === 'hybrid') &&
+  !SUPABASE_ANON_KEY
+) {
+  throw new Error(
+    'SUPABASE_ANON_KEY is required when MCP_SUPABASE_AUTH_MODE is anon or hybrid'
+  );
+}
 loadPersistedOauthClients();
 
 if (STATIC_CLIENT_ID && STATIC_CLIENT_SECRET && OAUTH_ENABLED) {
@@ -935,10 +1008,67 @@ async function readRequestBody(req) {
   }
 }
 
+function resolveSupabaseRequestAuthMode() {
+  const storeMode = String(SUPABASE_REQUEST_CONTEXT.getStore()?.db_auth_mode || '')
+    .trim()
+    .toLowerCase();
+  if (SUPABASE_AUTH_MODE_VALUES.has(storeMode)) {
+    return storeMode;
+  }
+  if (SUPABASE_AUTH_MODE === 'anon') {
+    return 'anon';
+  }
+  return 'service';
+}
+
+function isToolAllowedInAnonMode(toolName) {
+  return ANON_ALLOWED_TOOL_NAMES.has(String(toolName || '').trim());
+}
+
+function assertToolCapabilityForAuthMode(toolName) {
+  if (SUPABASE_AUTH_MODE !== 'anon') return;
+  if (isToolAllowedInAnonMode(toolName)) return;
+  throw new Error(
+    `capability_not_available_in_anon_mode: ${toolName} is disabled; use MCP_SUPABASE_AUTH_MODE=service or hybrid`
+  );
+}
+
+function resolveDbAuthModeForTool(toolName) {
+  if (SUPABASE_AUTH_MODE === 'anon') return 'anon';
+  if (SUPABASE_AUTH_MODE === 'service') return 'service';
+  return isToolAllowedInAnonMode(toolName) ? 'anon' : 'service';
+}
+function listAvailableToolNamesForAuthMode(authMode) {
+  if (authMode === 'anon') {
+    return TOOLS
+      .map((tool) => String(tool?.name || '').trim())
+      .filter((name) => name && isToolAllowedInAnonMode(name));
+  }
+  return TOOLS.map((tool) => String(tool?.name || '').trim()).filter(Boolean);
+}
+function listAvailableToolsForAuthMode(authMode) {
+  const names = listAvailableToolNamesForAuthMode(authMode);
+  return names
+    .map((name) => TOOL_BY_NAME.get(name))
+    .filter((tool) => Boolean(tool));
+}
+function buildSupabaseCapabilityPayload() {
+  return {
+    mode: SUPABASE_AUTH_MODE,
+    anon_allowed_tools: listAvailableToolNamesForAuthMode('anon'),
+    effective_tools: listAvailableToolNamesForAuthMode(SUPABASE_AUTH_MODE)
+  };
+}
+
 async function supabaseRequest(path, options = {}) {
+  const requestAuthMode = resolveSupabaseRequestAuthMode();
+  const requestApiKey = requestAuthMode === 'anon' ? SUPABASE_ANON_KEY : SERVICE_KEY;
+  if (!requestApiKey) {
+    throw new Error(`Supabase API key missing for auth mode: ${requestAuthMode}`);
+  }
   const headers = {
-    apikey: SERVICE_KEY,
-    Authorization: `Bearer ${SERVICE_KEY}`,
+    apikey: requestApiKey,
+    Authorization: `Bearer ${requestApiKey}`,
     'content-type': 'application/json'
   };
   if (options.profile) {
@@ -1455,7 +1585,10 @@ async function writeToolUsageTelemetry(payload = {}) {
     new Date().toISOString();
   const agentBody =
     normalizeOptionalAgentBody(payload.agent_body) || DB_PROFILE;
-  try {
+  if (SUPABASE_AUTH_MODE === 'anon') {
+    return;
+  }
+  const writeTelemetry = async () => {
     await supabaseRequest(
       `/rest/v1/memory_tool_usage?select=${TOOL_USAGE_INSERT_SELECT_COLUMNS}`,
       {
@@ -1473,6 +1606,13 @@ async function writeToolUsageTelemetry(payload = {}) {
         ]
       }
     );
+  };
+  try {
+    if (SUPABASE_AUTH_MODE === 'hybrid') {
+      await SUPABASE_REQUEST_CONTEXT.run({ db_auth_mode: 'service' }, writeTelemetry);
+    } else {
+      await writeTelemetry();
+    }
   } catch (error) {
     console.warn(
       `[telemetry] failed to persist memory_tool_usage: ${String(error?.message || error)}`
@@ -2717,6 +2857,156 @@ async function runHealthExpiryCheck(args = {}) {
   return payload;
 }
 
+async function runBatchPromote(args = {}) {
+  const alertWindowHours = clampInteger(args.alert_window_hours, 1, 720, 48);
+  const maxPromote = clampInteger(args.max_promote, 1, 50, 10);
+  const dryRun = Boolean(args.dry_run);
+  const origin = String(args.origin || 'batch-promote').trim() || 'batch-promote';
+  const explicitIds = Array.isArray(args.memory_ids)
+    ? args.memory_ids
+        .map((id) => normalizeOptionalUuid(id, 'memory_ids'))
+        .filter(Boolean)
+    : [];
+
+  const candidates = [];
+
+  if (explicitIds.length > 0) {
+    for (const memoryId of explicitIds.slice(0, maxPromote)) {
+      const memory = await fetchMemoryById(memoryId);
+      if (!memory) {
+        candidates.push({ id: memoryId, status: 'not_found', skipped: true });
+        continue;
+      }
+      if (memory.promoted || memory.promoted_at) {
+        candidates.push({
+          id: memoryId,
+          status: 'already_promoted',
+          skipped: true,
+          excerpt: String(memory.body || '').slice(0, 140)
+        });
+        continue;
+      }
+      candidates.push({
+        id: memoryId,
+        status: 'eligible',
+        skipped: false,
+        excerpt: String(memory.body || '').slice(0, 140),
+        tags: normalizeTags(memory.tags),
+        expires_at: memory.expires_at || null,
+        memory
+      });
+    }
+  } else {
+    const healthResult = await runHealthExpiryCheck({
+      alert_window_hours: alertWindowHours
+    });
+    const soonExpiring = healthResult?.expiry_alert?.soon_expiring || [];
+    const recommended = soonExpiring
+      .filter((item) => item.recommend_promote === 'Y')
+      .slice(0, maxPromote);
+
+    for (const item of recommended) {
+      const memory = await fetchMemoryById(item.id);
+      if (!memory) {
+        candidates.push({ id: item.id, status: 'not_found', skipped: true });
+        continue;
+      }
+      candidates.push({
+        id: item.id,
+        status: 'eligible',
+        skipped: false,
+        excerpt: item.excerpt || String(memory.body || '').slice(0, 140),
+        tags: item.tags || normalizeTags(memory.tags),
+        expires_at: item.expires_at || memory.expires_at || null,
+        recommendation_reason: item.recommendation_reason || null,
+        memory
+      });
+    }
+  }
+
+  const eligible = candidates.filter((c) => !c.skipped);
+
+  if (dryRun) {
+    return {
+      ok: true,
+      dry_run: true,
+      profile: DB_PROFILE,
+      origin,
+      alert_window_hours: alertWindowHours,
+      max_promote: maxPromote,
+      total_candidates: candidates.length,
+      eligible_count: eligible.length,
+      skipped_count: candidates.length - eligible.length,
+      candidates: candidates.map(({ memory, ...rest }) => rest)
+    };
+  }
+
+  const promoted = [];
+  const errors = [];
+
+  for (const candidate of eligible) {
+    try {
+      const memory = candidate.memory;
+      const content = String(memory.body || '').trim();
+      if (!content) {
+        errors.push({ id: candidate.id, error: 'empty memory body' });
+        continue;
+      }
+
+      const ingestResult = await ingestMarsvaultChunks(
+        {
+          content,
+          tags: normalizeTags(memory.tags),
+          source_memory_id: memory.id,
+          source_session_id: memory.session_id || null,
+          source_tool: memory.source || null,
+          origin
+        },
+        {
+          defaultType: 'insight',
+          defaultSourceFile: PROFILE.memoryIngestDefaultSourceFile,
+          defaultSectionPrefix: 'batch-promote',
+          defaultOrigin: origin,
+          body: DB_PROFILE,
+          fixedTags: [...PROFILE.memoryIngestFixedTags, 'batch-promote']
+        }
+      );
+
+      const promotedMemory = await markMemoryAsPromoted(memory.id);
+
+      promoted.push({
+        id: memory.id,
+        chunk_count: ingestResult.chunk_count || 0,
+        promoted_at: promotedMemory?.promoted_at || null,
+        excerpt: String(content).slice(0, 140)
+      });
+    } catch (error) {
+      errors.push({
+        id: candidate.id,
+        error: normalizeOptionalText(error?.message || String(error), 280)
+      });
+    }
+  }
+
+  return {
+    ok: true,
+    dry_run: false,
+    profile: DB_PROFILE,
+    origin,
+    alert_window_hours: alertWindowHours,
+    max_promote: maxPromote,
+    total_candidates: candidates.length,
+    promoted_count: promoted.length,
+    error_count: errors.length,
+    skipped_count: candidates.length - eligible.length,
+    promoted,
+    errors: errors.length > 0 ? errors : undefined,
+    skipped: candidates
+      .filter((c) => c.skipped)
+      .map(({ memory, ...rest }) => rest)
+  };
+}
+
 async function runHealthCheck(args = {}) {
   const alertWindowHours = clampInteger(args.alert_window_hours, 1, 720, 48);
   const gapDays = clampInteger(args.gap_days, 7, 365, 30);
@@ -3620,6 +3910,9 @@ async function callTool(name, args = {}) {
       };
     }
 
+    if (toolName === 'batch_promote') {
+      return await runBatchPromote(args);
+    }
     if (toolName === 'health_check') {
       return await runHealthCheck(args);
     }
@@ -4237,6 +4530,8 @@ const server = http.createServer(async (req, res) => {
       embedding_provider: 'jina',
       embedding_model: JINA_EMBEDDING_MODEL,
       embedding_enabled: Boolean(JINA_API_KEY),
+      supabase_auth_mode: SUPABASE_AUTH_MODE,
+      supabase_capabilities: buildSupabaseCapabilityPayload(),
       source_mode: SOURCE_MODE,
       memory_sources: MEMORY_SOURCE_LIST.slice(),
       extra_sources: EXTRA_SOURCE_LIST.slice(),
@@ -4318,14 +4613,24 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (method === 'tools/list') {
-      json(res, 200, mcpResult(id, { tools: TOOLS }));
+      json(
+        res,
+        200,
+        mcpResult(id, { tools: listAvailableToolsForAuthMode(SUPABASE_AUTH_MODE) })
+      );
       return;
     }
 
     if (method === 'tools/call') {
-      const toolName = rpc?.params?.name;
+      const requestedToolName = rpc?.params?.name;
+      const toolName = resolveToolName(requestedToolName);
+      assertToolCapabilityForAuthMode(toolName);
+      const dbAuthMode = resolveDbAuthModeForTool(toolName);
       const args = rpc?.params?.arguments ?? {};
-      const result = await callTool(toolName, args);
+      const result = await SUPABASE_REQUEST_CONTEXT.run(
+        { db_auth_mode: dbAuthMode },
+        async () => await callTool(toolName, args)
+      );
       json(
         res,
         200,