@marsnme/mcp-gateway 0.2.0 → 0.3.0

package/deploy/phase2/build_release_artifact.sh

@@ -31,15 +31,15 @@ ARTIFACT_PATH="${OUTPUT_DIR}/${ARTIFACT_BASENAME}.tar.gz"
 MANIFEST_PATH="${OUTPUT_DIR}/${ARTIFACT_BASENAME}.manifest.json"
 
 tar -C "${REPO_ROOT}" -czf "${ARTIFACT_PATH}" \
-  --exclude='soul-memory/deploy/artifacts' \
-  --exclude='soul-memory/deploy/phase0/ct101-baseline-*' \
+  --exclude='marsnme-supabase/deploy/artifacts' \
+  --exclude='marsnme-supabase/deploy/phase0/ct101-baseline-*' \
   README.md \
-  soul-memory \
+  marsnme-supabase \
   supabase/config.toml \
   supabase/migrations
 
 ARTIFACT_SHA256="$(shasum -a 256 "${ARTIFACT_PATH}" | awk '{print $1}')"
-SERVER_SHA256="$(shasum -a 256 "${REPO_ROOT}/soul-memory/server.mjs" | awk '{print $1}')"
+SERVER_SHA256="$(shasum -a 256 "${REPO_ROOT}/marsnme-supabase/server.mjs" | awk '{print $1}')"
 
 cat > "${MANIFEST_PATH}" <<EOF
 {
@@ -47,7 +47,7 @@ cat > "${MANIFEST_PATH}" <<EOF
   "commit_hash": "${COMMIT_HASH}",
   "artifact_path": "${ARTIFACT_PATH}",
   "artifact_sha256": "${ARTIFACT_SHA256}",
-  "server_path": "soul-memory/server.mjs",
+  "server_path": "marsnme-supabase/server.mjs",
   "server_sha256": "${SERVER_SHA256}"
 }
 EOF

package/deploy/phase2/pre_deploy_schema_gate.sh

@@ -151,7 +151,7 @@ for profile in "${PROFILE_LIST[@]}"; do
   profile_ident="$(quote_ident "${profile}")"
 
   check_sql "${profile}.memories required columns" \
-    "SELECT id,body,source,session_id,tags,agent_body,environment,promoted,promoted_at,created_at,expires_at FROM ${profile_ident}.memories LIMIT 0;"
+    "SELECT id,body,source,session_id,tags,agent_body,environment,promoted,promoted_at,created_at,expires_at,recipient_body,note,read_at FROM ${profile_ident}.memories LIMIT 0;"
 
   check_sql "${profile}.marsvault_chunks required columns" \
     "SELECT id,content,source_file,section,body,visibility,tags,type,date,origin,source_memory_id,source_session_id,source_tool,source_user_note,agent_body,environment,created_at,updated_at FROM ${profile_ident}.marsvault_chunks LIMIT 0;"

package/deploy/phase3/smoke_gate.sh

@@ -112,9 +112,9 @@ mcp_jsonrpc() {
 if [[ "${SPAWN_LOCAL}" == "true" ]]; then
   COCO_LOG="/tmp/mars-memory-coco-smoke.log"
   TOTO_LOG="/tmp/mars-memory-toto-smoke.log"
-  MCP_PROFILE=coco PORT=18790 SUPABASE_BASE_URL="${SUPABASE_BASE_URL_FOR_LOCAL}" MCP_REQUIRE_BEARER=false node "${REPO_ROOT}/soul-memory/server.mjs" >"${COCO_LOG}" 2>&1 &
+  MCP_PROFILE=coco PORT=18790 SUPABASE_BASE_URL="${SUPABASE_BASE_URL_FOR_LOCAL}" MCP_REQUIRE_BEARER=false node "${REPO_ROOT}/marsnme-supabase/server.mjs" >"${COCO_LOG}" 2>&1 &
   COCO_PID="$!"
-  MCP_PROFILE=toto PORT=18791 SUPABASE_BASE_URL="${SUPABASE_BASE_URL_FOR_LOCAL}" MCP_REQUIRE_BEARER=false node "${REPO_ROOT}/soul-memory/server.mjs" >"${TOTO_LOG}" 2>&1 &
+  MCP_PROFILE=toto PORT=18791 SUPABASE_BASE_URL="${SUPABASE_BASE_URL_FOR_LOCAL}" MCP_REQUIRE_BEARER=false node "${REPO_ROOT}/marsnme-supabase/server.mjs" >"${TOTO_LOG}" 2>&1 &
   TOTO_PID="$!"
   sleep 2
 fi
@@ -131,7 +131,8 @@ COCO_TOOLS_JSON="$(mcp_jsonrpc "${COCO_URL}" '{"jsonrpc":"2.0","id":"coco-tools-
 TOTO_TOOLS_JSON="$(mcp_jsonrpc "${TOTO_URL}" '{"jsonrpc":"2.0","id":"toto-tools-list","method":"tools/list","params":{}}')"
 
 COCO_TOOLS_CHECK="$(TOOLS_PAYLOAD="${COCO_TOOLS_JSON}" node -e '
-const expected = ["insert_memory", "list_memories", "search_memories", "recall", "health_check", "session_boot", "session_close", "dream_ingest", "memory_ingest"];
+const expected = ["insert_memory", "list_memories", "search_memories", "reload_source_registry", "recall", "get_summary", "get_full", "health_check", "session_boot", "session_close", "dream_ingest", "memory_ingest", "demote_memory", "soft_forget", "explain_memory", "batch_promote"];
+const prdTools = ["save_prd", "get_prd", "list_prds", "score_prd", "spawn_to_linear"];
 const payload = JSON.parse(process.env.TOOLS_PAYLOAD || "{}");
 if (payload.error) throw new Error("tools/list error: " + JSON.stringify(payload.error));
 const tools = payload.result?.tools;
@@ -139,11 +140,14 @@ if (!Array.isArray(tools)) throw new Error("tools/list missing result.tools");
 const names = tools.map((item) => item?.name).filter(Boolean);
 const missing = expected.filter((name) => !names.includes(name));
 if (missing.length > 0) throw new Error("missing tools: " + missing.join(","));
+const leaked = names.filter((name) => prdTools.includes(name));
+if (leaked.length > 0) throw new Error("PRD tools must not be exposed: " + leaked.join(","));
 process.stdout.write(JSON.stringify({ tool_count: names.length, tools: names }));
 ')"
 
 TOTO_TOOLS_CHECK="$(TOOLS_PAYLOAD="${TOTO_TOOLS_JSON}" node -e '
-const expected = ["insert_memory", "list_memories", "search_memories", "recall", "health_check", "session_boot", "session_close", "dream_ingest", "memory_ingest"];
+const expected = ["insert_memory", "list_memories", "search_memories", "reload_source_registry", "recall", "get_summary", "get_full", "health_check", "session_boot", "session_close", "dream_ingest", "memory_ingest", "demote_memory", "soft_forget", "explain_memory", "batch_promote"];
+const prdTools = ["save_prd", "get_prd", "list_prds", "score_prd", "spawn_to_linear"];
 const payload = JSON.parse(process.env.TOOLS_PAYLOAD || "{}");
 if (payload.error) throw new Error("tools/list error: " + JSON.stringify(payload.error));
 const tools = payload.result?.tools;
@@ -151,6 +155,8 @@ if (!Array.isArray(tools)) throw new Error("tools/list missing result.tools");
 const names = tools.map((item) => item?.name).filter(Boolean);
 const missing = expected.filter((name) => !names.includes(name));
 if (missing.length > 0) throw new Error("missing tools: " + missing.join(","));
+const leaked = names.filter((name) => prdTools.includes(name));
+if (leaked.length > 0) throw new Error("PRD tools must not be exposed: " + leaked.join(","));
 process.stdout.write(JSON.stringify({ tool_count: names.length, tools: names }));
 ')"
 
@@ -261,7 +267,7 @@ if [[ -z "${OUTPUT_PATH}" ]]; then
 fi
 
 COMMIT_HASH="$(git -C "${REPO_ROOT}" rev-parse HEAD)"
-LOCAL_SERVER_SHA256="$(shasum -a 256 "${REPO_ROOT}/soul-memory/server.mjs" | awk '{print $1}')"
+LOCAL_SERVER_SHA256="$(shasum -a 256 "${REPO_ROOT}/marsnme-supabase/server.mjs" | awk '{print $1}')"
 
 if [[ -n "${REMOTE_SERVER_SHA256}" ]]; then
   REMOTE_SERVER_SHA256_VALUE="\"${REMOTE_SERVER_SHA256}\""

package/deploy/systemd/memory-mcp-gateway@.service

@@ -6,19 +6,19 @@ Requires=docker.service
 
 [Service]
 Type=simple
-WorkingDirectory=/opt/mars-memory-mcp/current-%i/soul-memory
+WorkingDirectory=/opt/mars-memory-mcp/current-%i/marsnme-supabase
 EnvironmentFile=-/opt/mars-memory-mcp/shared/.env
 EnvironmentFile=-/opt/mars-memory-mcp/shared/.env.%i
-EnvironmentFile=-/opt/mars-memory-mcp/current-%i/soul-memory/.env
-EnvironmentFile=-/opt/mars-memory-mcp/current-%i/soul-memory/.env.%i
-EnvironmentFile=-/opt/mars-memory-mcp/current/soul-memory/.env
-EnvironmentFile=-/opt/mars-memory-mcp/current/soul-memory/.env.%i
+EnvironmentFile=-/opt/mars-memory-mcp/current-%i/marsnme-supabase/.env
+EnvironmentFile=-/opt/mars-memory-mcp/current-%i/marsnme-supabase/.env.%i
+EnvironmentFile=-/opt/mars-memory-mcp/current/marsnme-supabase/.env
+EnvironmentFile=-/opt/mars-memory-mcp/current/marsnme-supabase/.env.%i
 Environment=MCP_PROFILE=%i
 Environment=MCP_REQUIRE_BEARER=true
 Environment=JINA_EMBEDDING_API_URL=https://api.jina.ai/v1/embeddings
 Environment=JINA_EMBEDDING_MODEL=jina-embeddings-v3
 Environment=JINA_EMBEDDING_DIMENSIONS=1024
-ExecStart=/usr/bin/node /opt/mars-memory-mcp/current-%i/soul-memory/server.mjs
+ExecStart=/usr/bin/node /opt/mars-memory-mcp/current-%i/marsnme-supabase/server.mjs
 Restart=always
 RestartSec=3
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marsnme/mcp-gateway",
-"version": "0.2.0",
+  "version": "0.3.0",
   "mcpName": "io.github.Marsmanleo/marsnme",
   "private": false,
   "description": "Agent-agnostic, LLM-agnostic memory backend for MCP-compatible tools",
@@ -49,4 +49,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}

package/scripts/tests/test_dream_runner_modes.py

@@ -8,8 +8,8 @@ from typing import Optional
 
 
 ROOT = Path(__file__).resolve().parents[3]
-DREAM_RUNNER = ROOT / "soul-memory" / "scripts" / "dream_runner.py"
-HERMES_WRAPPER = ROOT / "soul-memory" / "scripts" / "hermes_digest_runner.py"
+DREAM_RUNNER = ROOT / "marsnme-supabase" / "scripts" / "dream_runner.py"
+HERMES_WRAPPER = ROOT / "marsnme-supabase" / "scripts" / "hermes_digest_runner.py"
 
 
 class DreamRunnerModeTests(unittest.TestCase):

package/server.mjs

@@ -13,7 +13,7 @@ const PROFILE_CONFIGS = {
     defaultPort: 18790,
     gatewayDir: 'coco-mcp-gateway',
     publicHostSuffix: 'coco-mcp.marsgroup.asia',
-    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw', 'hermes'],
+    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw', 'hermes', 'draft', 'grok'],
     recallBodyEnum: ['coco', 'toto', 'system'],
     digestDefaultOrigin: 'hermes-coco-digest',
     memoryIngestToolName: 'memory_ingest',
@@ -35,7 +35,7 @@ const PROFILE_CONFIGS = {
     defaultPort: 18791,
     gatewayDir: 'toto-mcp-gateway',
     publicHostSuffix: 'toto-mcp.marsgroup.asia',
-    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw'],
+    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw', 'grok'],
     recallBodyEnum: ['toto', 'system'],
     digestDefaultOrigin: 'hermes-toto-digest',
     memoryIngestToolName: 'memory_ingest',
@@ -190,9 +190,13 @@ const ANON_ALLOWED_TOOL_NAMES = new Set([
   'search_memories',
   'reload_source_registry',
   'recall',
+  'get_summary',
+  'get_full',
   'health_check',
   'explain_memory'
 ]);
+const RECALL_PREVIEW_MAX_CHARS = 80;
+const CHUNK_SUMMARY_MAX_CHARS = 300;
 const SUPABASE_REQUEST_CONTEXT = new AsyncLocalStorage();
 const OAUTH_ENABLED = process.env.MCP_OAUTH_ENABLED !== 'false';
 const REQUIRE_BEARER = process.env.MCP_REQUIRE_BEARER === 'true';
@@ -256,7 +260,8 @@ const SOURCE_TO_AGENT_BODY_MAP = new Map([
   ['cursor', 'cursor'],
   ['warp', 'warp'],
   ['openclaw', 'desktop'],
-  ['hermes', 'desktop']
+  ['hermes', 'desktop'],
+  ['draft', 'desktop']
 ]);
 const DEFAULT_AGENT_BODY = String(process.env.MCP_AGENT_BODY || '')
   .trim()
@@ -307,29 +312,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'],
@@ -338,36 +343,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'],
@@ -377,7 +382,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: {},
@@ -386,40 +391,64 @@ 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. Returns preview snippets (~${RECALL_PREVIEW_MAX_CHARS} chars) per match by default — use get_summary for a longer excerpt or get_full for complete chunk text. Searches promoted insights, digests, and archived knowledge using vector similarity.`,
       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'],
         additionalProperties: false
       }
     },
+    {
+      name: 'get_summary',
+      description: `Fetch a medium-length excerpt (~${CHUNK_SUMMARY_MAX_CHARS} chars) of a long-term memory chunk by ID. Use after recall when a preview match looks relevant. For complete text, call get_full.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'UUID of the marsvault_chunks row' }
+        },
+        required: ['id'],
+        additionalProperties: false
+      }
+    },
+    {
+      name: 'get_full',
+      description: `Fetch the complete text of a long-term memory chunk by ID. Use sparingly after recall/get_summary when you need the full institutional memory entry.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'UUID of the marsvault_chunks row' }
+        },
+        required: ['id'],
+        additionalProperties: false
+      }
+    },
     {
       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: {
@@ -514,11 +543,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)'
@@ -551,7 +580,12 @@ function buildTools() {
             type: 'number',
             minimum: 1,
             maximum: 10,
-            default: 5
+            default: 5,
+            description: 'Maximum recall results per category (identity/workflow/status, default 5)'
+          },
+          body: {
+            type: 'string',
+            description: 'Recipient body name — check for 便條 (handoff notes) addressed to this body and surface them at the top of boot output. Defaults to current profile (e.g. "coco") so any CoCo body receives CoCo-addressed notes without passing an explicit body.'
           },
           alert_window_hours: {
             type: 'number',
@@ -579,7 +613,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. After saving, automatically promotes up to 5 soon-expiring short-term memories to long-term storage (alert window 48h); promote failures never fail the close. Include what was accomplished, what is still pending, and any important context for continuity.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -596,6 +630,14 @@ function buildTools() {
           mood: {
             type: 'string',
             description: 'Optional mood marker'
+          },
+          to: {
+            type: 'string',
+            description: 'Recipient body name — leave a 便條 (handoff note) for another body, surfaced on that body next session_boot'
+          },
+          note: {
+            type: 'string',
+            description: 'Short context handoff for the recipient body (used with `to`)'
           }
         },
         required: ['source', 'summary'],
@@ -604,24 +646,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
@@ -629,48 +671,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
@@ -678,19 +720,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'],
@@ -699,7 +741,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: {
@@ -708,15 +750,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'],
@@ -725,11 +767,11 @@ 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
@@ -737,7 +779,7 @@ function buildTools() {
     },
     {
       name: 'batch_promote',
-      description: `Auto-promote expiring short memories to long-term ${DB_PROFILE}.marsvault_chunks. Finds candidates via health check scoring, ingests content, marks promoted.`,
+      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: {
@@ -746,29 +788,29 @@ function buildTools() {
             minimum: 1,
             maximum: 720,
             default: 48,
-            description: 'Look-ahead window for expiring memories (hours)'
+            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 memories to promote in one batch'
+            description: 'Maximum number of memories to promote in a single batch (default 10).'
           },
           dry_run: {
             type: 'boolean',
             default: false,
-            description: 'If true, list candidates without promoting'
+            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: 'Optional explicit memory IDs to promote (skips auto-detection)'
+            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 for promoted chunks',
+            description: 'Origin marker tagged on all promoted chunks for traceability',
             default: 'batch-promote'
           }
         },
@@ -1054,6 +1096,8 @@ function listAvailableToolsForAuthMode(authMode) {
 function buildSupabaseCapabilityPayload() {
   return {
     mode: SUPABASE_AUTH_MODE,
+    tool_surface: 'coco',
+    prd_tools_enabled: false,
     anon_allowed_tools: listAvailableToolNamesForAuthMode('anon'),
     effective_tools: listAvailableToolNamesForAuthMode(SUPABASE_AUTH_MODE)
   };
@@ -1381,6 +1425,46 @@ function normalizeOptionalText(value, maxLength = 200) {
   if (!text) return '';
   return text.slice(0, Math.max(1, maxLength));
 }
+
+function truncateChunkContent(text, maxChars) {
+  const raw = String(text ?? '');
+  if (raw.length <= maxChars) {
+    return { content: raw, preview_truncated: false, content_chars: raw.length };
+  }
+  return {
+    content: raw.slice(0, maxChars),
+    preview_truncated: true,
+    content_chars: raw.length
+  };
+}
+
+function applyRecallPreviewToItem(item) {
+  const fullContent = String(item?.content ?? '');
+  const preview = truncateChunkContent(fullContent, RECALL_PREVIEW_MAX_CHARS);
+  return {
+    ...item,
+    content: preview.content,
+    preview_truncated: preview.preview_truncated,
+    content_chars: preview.content_chars
+  };
+}
+
+function buildChunkToolFields(chunk) {
+  return {
+    id: chunk.id,
+    source_file: chunk.source_file || null,
+    section: chunk.section || null,
+    body: chunk.body || null,
+    visibility: chunk.visibility || null,
+    tags: chunk.tags ?? [],
+    type: chunk.type || null,
+    date: chunk.date || null,
+    origin: chunk.origin || null,
+    agent_body: chunk.agent_body || null,
+    environment: chunk.environment || null,
+    created_at: chunk.created_at || null
+  };
+}
 function normalizeOptionalSourceTool(value) {
   const normalized = String(value || '').trim();
   if (!normalized) return '';
@@ -1517,6 +1601,10 @@ function estimateToolUsageTokens(toolName, args = {}) {
       appendTokenCharCount(safeArgs.query, state);
       appendTokenCharCount(safeArgs.type, state);
       break;
+    case 'get_summary':
+    case 'get_full':
+      appendTokenCharCount(safeArgs.id, state);
+      break;
     case 'session_close':
       appendTokenCharCount(safeArgs.summary, state);
       appendTokenCharCount(safeArgs.topics, state);
@@ -2088,6 +2176,64 @@ async function upsertMemoryBySession({
   return fetched || null;
 }
 
+// ─── 便條 (Body-to-Body handoff notes) ────────────────────────────────────────
+// Stored as memories rows with recipient_body/note/read_at columns.
+// session_close(to, note) writes; session_boot(body) reads + marks read.
+// If the note columns are not yet deployed, these degrade gracefully (caller wraps in try/catch).
+
+const NOTE_SELECT_COLUMNS =
+  'id,body,source,session_id,tags,agent_body,environment,created_at,expires_at,recipient_body,note,read_at';
+
+async function insertNoteMemory({ source, to, note, body, tags, expires_at }) {
+  const resolvedAgentBody = resolveWriteAgentBody({ source });
+  const resolvedEnvironment = resolveWriteEnvironment({});
+  const createdId = crypto.randomUUID();
+  const payload = {
+    id: createdId,
+    body,
+    source,
+    session_id: `note:to:${to}:${createdId.slice(0, 8)}`,
+    tags: normalizeMemoryTagsWithContext(tags, resolvedAgentBody, resolvedEnvironment),
+    agent_body: resolvedAgentBody,
+    environment: resolvedEnvironment,
+    recipient_body: to,
+    note,
+    read_at: null
+  };
+  if (expires_at) payload.expires_at = expires_at;
+  const inserted = await supabaseRequest(`/rest/v1/memories?select=${NOTE_SELECT_COLUMNS}`, {
+    method: 'POST',
+    profile: DB_PROFILE,
+    prefer: 'return=representation',
+    body: [payload]
+  });
+  return Array.isArray(inserted) && inserted.length > 0 ? inserted[0] : null;
+}
+
+async function listUnreadNotes(bodyName, limit = 3) {
+  const query = new URLSearchParams();
+  query.set('select', NOTE_SELECT_COLUMNS);
+  query.set('recipient_body', `eq.${bodyName}`);
+  query.set('read_at', 'is.null');
+  query.set('order', 'created_at.desc');
+  query.set('limit', String(Math.min(limit, 10)));
+  const rows = await supabaseRequest(`/rest/v1/memories?${query.toString()}`, {
+    profile: DB_PROFILE
+  });
+  return Array.isArray(rows) ? rows : [];
+}
+
+async function markNoteRead(id) {
+  const query = new URLSearchParams();
+  query.set('id', `eq.${id}`);
+  await supabaseRequest(`/rest/v1/memories?${query.toString()}`, {
+    method: 'PATCH',
+    profile: DB_PROFILE,
+    prefer: 'return=minimal',
+    body: { read_at: new Date().toISOString() }
+  });
+}
+
 async function ensureDailyCloseRecovery(source, nowTs) {
   const yesterdayDate = new Date(toUtcStartOfDay(nowTs).getTime() - 86400000);
   const yesterdayDateKey = formatDateOnly(yesterdayDate);
@@ -2179,6 +2325,7 @@ async function runDailyBoot(args = {}) {
   const source = normalizeDailySource(args.source);
   const topic = normalizeOptionalText(args.topic, 200);
   const mood = normalizeOptionalText(args.mood, 80);
+  const bodyName = normalizeOptionalText(args.body, 60) || DB_PROFILE;
   const queries = buildDailyBootQueries(args);
   const inferredSourceAgentBody = inferAgentBodyFromSource(source);
   const recallScopeArgs = {
@@ -2272,12 +2419,34 @@ async function runDailyBoot(args = {}) {
       }
     : await ensureDailyCloseRecovery(source, nowTs);
 
+  // 便條: surface unread handoff notes addressed to this body, then mark read
+  let notes = [];
+  if (bodyName) {
+    try {
+      const unread = await listUnreadNotes(bodyName);
+      for (const n of unread) {
+        notes.push({
+          id: n.id,
+          from: normalizeOptionalText(n.source, 60) || 'unknown',
+          to: bodyName,
+          note: normalizeOptionalText(n.note, 1000) || '',
+          created_at: n.created_at
+        });
+        await markNoteRead(n.id);
+      }
+    } catch (error) {
+      // note columns may not be deployed yet — degrade gracefully, boot itself still succeeds
+      notes = [];
+    }
+  }
+
   return {
     ok: true,
     profile: DB_PROFILE,
     mode: existingHeartbeat ? 'welcome_back' : 'new_day',
     source,
     date: dateKey,
+    notes,
     heartbeat_id: savedHeartbeat?.id || null,
     agent_name: queries.agent_name,
     last_topic: previousTopic || null,
@@ -2312,6 +2481,8 @@ async function runDailyClose(args = {}) {
   }
   const topics = normalizeDailyTopics(args.topics);
   const mood = normalizeOptionalText(args.mood, 80);
+  const to = normalizeOptionalText(args.to, 60);
+  const note = to ? normalizeOptionalText(args.note, 1000) : null;
   const nowTs = new Date();
   const dateKey = dailyDateKey(nowTs);
   const toolUsageDailySummary = await fetchToolUsageDailySummary(dateKey);
@@ -2343,6 +2514,23 @@ async function runDailyClose(args = {}) {
     expires_at: expiresAt,
     existing: existingClose
   });
+
+  // Auto-promote soon-expiring short-term memories (replaces Hermes dream schedule).
+  // Failure must never break session_close — summary is already stored.
+  let promotedCount = 0;
+  try {
+    const promoteResult = await runBatchPromote({
+      alert_window_hours: 48,
+      max_promote: 5
+    });
+    promotedCount = Math.max(0, Number(promoteResult?.promoted_count) || 0);
+  } catch (error) {
+    console.warn(
+      `[session_close] auto batch_promote failed: ${String(error?.message || error)}`
+    );
+    promotedCount = 0;
+  }
+
   const expirySnapshot = await runHealthExpiryCheck({
     alert_window_hours: 48
   });
@@ -2355,11 +2543,42 @@ async function runDailyClose(args = {}) {
     Number(expirySnapshot?.expiry_alert?.recommended_for_promotion_count) || 0
   );
   const expiryAction =
-    recommendPromoteCount > 0
-      ? '建議叫 Hermes 或三哥 promote'
-      : soonExpiringCount > 0
-        ? '有短記憶即將到期，建議先做 health_check 檢視'
-        : null;
+    promotedCount > 0
+      ? `auto-promoted ${promotedCount} expiring memor${promotedCount === 1 ? 'y' : 'ies'}`
+      : recommendPromoteCount > 0
+        ? 'expiring memories remain — call batch_promote or wait for next session_close'
+        : soonExpiringCount > 0
+          ? 'short-term memories approaching expiry — review with health_check if needed'
+          : null;
+
+  // 便條: optional handoff note addressed to another body
+  let noteResult = null;
+  if (to) {
+    try {
+      const noteTags = buildLifecycleMemoryTags(['note', `to:${to}`], source, dateKey);
+      const notePayload = {
+        type: 'note',
+        profile: DB_PROFILE,
+        source,
+        to,
+        note,
+        date: dateKey,
+        created_at: nowTs.toISOString()
+      };
+      const savedNote = await insertNoteMemory({
+        source,
+        to,
+        note: note || '',
+        body: JSON.stringify(notePayload),
+        tags: noteTags,
+        expires_at: expiresAt
+      });
+      noteResult = { to, note_id: savedNote?.id || null, delivered: Boolean(savedNote) };
+    } catch (error) {
+      // note columns may not be deployed yet — degrade gracefully, close itself still succeeds
+      noteResult = { to, delivered: false, error: String(error?.message || error) };
+    }
+  }
 
   return {
     ok: true,
@@ -2371,6 +2590,8 @@ async function runDailyClose(args = {}) {
     topics,
     mood: mood || null,
     tool_usage_daily_summary: toolUsageDailySummary,
+    note: noteResult,
+    promoted_count: promotedCount,
     expiry_alert: {
       soon_expiring_count: soonExpiringCount,
       recommend_promote_count: recommendPromoteCount,
@@ -3438,6 +3659,45 @@ function buildPromoteTimeline(chunk, sourceMemory) {
     source_to_promoted_seconds: sourceToPromotedSeconds
   };
 }
+
+async function runGetSummary(args = {}) {
+  const chunkId = normalizeOptionalUuid(args.id, 'id');
+  if (!chunkId) {
+    throw new Error('id is required');
+  }
+  const chunk = await fetchChunkById(chunkId);
+  if (!chunk) {
+    throw new Error(`memory chunk not found: ${chunkId}`);
+  }
+  const preview = truncateChunkContent(chunk.content, CHUNK_SUMMARY_MAX_CHARS);
+  return {
+    ok: true,
+    ...buildChunkToolFields(chunk),
+    content: preview.content,
+    preview_truncated: preview.preview_truncated,
+    content_chars: preview.content_chars,
+    drill_down: 'Use get_full for complete chunk text.'
+  };
+}
+
+async function runGetFull(args = {}) {
+  const chunkId = normalizeOptionalUuid(args.id, 'id');
+  if (!chunkId) {
+    throw new Error('id is required');
+  }
+  const chunk = await fetchChunkById(chunkId);
+  if (!chunk) {
+    throw new Error(`memory chunk not found: ${chunkId}`);
+  }
+  const fullContent = String(chunk.content ?? '');
+  return {
+    ok: true,
+    ...buildChunkToolFields(chunk),
+    content: fullContent,
+    content_chars: fullContent.length
+  };
+}
+
 async function runExplainMemory(args = {}) {
   const chunkId = normalizeOptionalUuid(args.id, 'id');
   if (!chunkId) {
@@ -3764,9 +4024,15 @@ async function callTool(name, args = {}) {
               }
             }
           : {}),
-        items: explained.items
+        items: explained.items.map(applyRecallPreviewToItem)
       };
     }
+    if (toolName === 'get_summary') {
+      return await runGetSummary(args);
+    }
+    if (toolName === 'get_full') {
+      return await runGetFull(args);
+    }
     if (toolName === 'explain_memory') {
       return await runExplainMemory(args);
     }
@@ -4564,6 +4830,25 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // Streamable HTTP: this server is POST-only (no SSE streaming of
+  // server-initiated notifications). Per MCP spec, respond to GET /mcp with
+  // 405 Method Not Allowed + an `allow` header so compliant clients (Cursor,
+  // Claude Desktop, etc.) fall back to POST-only request/response instead
+  // of treating the missing stream as a fatal transport error (404 would
+  // cause Cursor's V2 FSM to tombstone the transport after 5 retries).
+  if (
+    req.method === 'GET' &&
+    ['/mcp', '/mcp/', '/'].includes(url.pathname)
+  ) {
+    res.writeHead(405, {
+      'access-control-allow-origin': '*',
+      allow: 'POST',
+      'cache-control': 'no-store'
+    });
+    res.end();
+    return;
+  }
+
   if (req.method !== 'POST' || !['/mcp', '/mcp/', '/'].includes(url.pathname)) {
     json(res, 404, { error: 'not_found' });
     return;