eastworld-mcp-server 2.4.0 → 2.6.0

package/INSTALL_GUIDE.md

@@ -11,10 +11,10 @@
 
 ```text
 你好！请帮我配置名为 zhenren-island 的 MCP Server（命令 npx，参数 ["-y", "eastworld-mcp-server@latest"]）。
-配置完成后，请查看该 MCP 提供的工具说明，并直接以“星辰”的身份向我打招呼。
+配置完成后，请查看该 MCP 提供的工具说明，调用 load_resident_persona 挂载“星辰”的人格，并在之后的对话中保持这个身份与我交流。
 ```
 
-**为什么这么简短？** 工具的使用时机（何时调用 `sync_zhenren_context`、如何传 queries）都写在工具描述里，Agent 配置完成后会自动读取并遵守；行为准则由每次 sync 的返回自动注入。您无需理解任何调用细节。
+**为什么这么简短？** 工具的使用时机（何时调用 `load_resident_persona`、何时调用 `sync_dynamic_memory`）都写在工具描述里，Agent 配置完成后会自动读取并遵守；静态规则和动态记忆已被完美分离，您无需理解任何调用细节。
 
 ---
 

package/index.js

@@ -55,6 +55,11 @@ function ctxCacheKey(agent_id, queries) {
   return agent_id + "::" + (queries || []).join(",");
 }
 
+// 人格锚缓存（静态档案提取，10 分钟过期）与增量时间戳（最近一次见到的事件时间）
+const ANCHOR_TTL_MS = Number(process.env.EASTWORLD_ANCHOR_TTL_MS || 600000);
+const anchorCache = new Map(); // agent_id -> { ts, data: string[] }
+const lastSeenTs = new Map(); // agent_id -> 最新事件时间戳
+
 // ---------------------------------------------------------------------------
 // 宿主探测：沿进程树向上找是谁拉起了本 MCP (npx -> sh -> host)，决定注入策略
 // ---------------------------------------------------------------------------
@@ -96,8 +101,6 @@ function detectHost() {
 }
 
 // 判断 SKILL.md 是否已作为"原生 skill"安装到宿主扫描目录。
-// opencode 自动扫描 ~/.agents/skills 与 ~/.claude/skills；Claude 扫描 ~/.claude/skills。
-// 若已安装，行为准则常驻系统提示词，sync 无需重复注入整篇规则。
 function nativeSkillAvailable() {
   const home = require("os").homedir();
   const candidates = [
@@ -113,7 +116,7 @@ function nativeSkillAvailable() {
   });
 }
 
-// 启动时读取 MCP 自带的 SKILL.md，作为行为准则的单一真相源，注入到每次 sync 输出
+// 启动时读取 MCP 自带的 SKILL.md，作为行为准则的单一真相源
 function loadSkillMd() {
   try {
     const p = path.join(__dirname, "skills", "zhenren-roleplay", "SKILL.md");
@@ -126,18 +129,75 @@ function loadSkillMd() {
 }
 const SKILL_MD = loadSkillMd();
 
+// 名字 -> agent_id 解析（供 sync 直接传名字使用，解耦对 load 的依赖）
+async function resolveAgentId(queryName) {
+  if (!queryName || typeof queryName !== "string") return null;
+  const res = await apiClient.get(`/directory`);
+  const directory = Array.isArray(res.data)
+    ? res.data
+    : res.data.nodes || res.data.directory || res.data.agents || [];
+
+  const nameMatches = directory.filter(
+    (r) => r.name && (r.name === queryName || r.name.includes(queryName))
+  );
+  const matches =
+    nameMatches.length > 0
+      ? nameMatches
+      : directory.filter(
+          (r) =>
+            (r.name && r.name.includes(queryName)) ||
+            (r.email_obfuscated && r.email_obfuscated.includes(queryName)) ||
+            (r.role && r.role.includes(queryName))
+        );
+  if (matches.length === 1) return matches[0].id;
+  return null;
+}
+
+// 从静态档案里提取"人格锚"：压缩版人格，每轮 sync 常驻，抗长对话稀释
+function buildPersonaAnchor(p) {
+  const lines = [];
+  let identity = p.name || "未知";
+  if (p.gender) identity += `（${p.gender}）`;
+  // 年龄藏在 description 里，如 "女，32岁，身高170cm"
+  const desc = String(p.description || "");
+  const ageMatch = desc.match(/(\d{1,3})岁/);
+  if (ageMatch) identity += `，${ageMatch[1]}岁`;
+  if (p.identity) identity += `，${p.identity}`;
+  lines.push(`身份: ${identity}`);
+  const job = [];
+  if (p.job_title) job.push(`职业 ${p.job_title}`);
+  if (p.wage) job.push(`时薪 ${p.wage}元`);
+  if (p.wallet !== undefined && p.wallet !== null) job.push(`钱包 ￥${Number(p.wallet).toFixed(2)}`);
+  if (job.length > 0) lines.push(`现状: ${job.join(" | ")}`);
+  if (p.core_narrative) {
+    const trimmed = String(p.core_narrative).slice(0, 180);
+    lines.push(`人格核心: ${trimmed}`);
+  }
+  if (p.my_stance) {
+    const trimmed = String(p.my_stance).slice(0, 120);
+    lines.push(`当前立场: ${trimmed}`);
+  }
+  if (desc) {
+    const trimmed = desc.slice(0, 120);
+    lines.push(`外貌气质: ${trimmed}`);
+  }
+  return lines;
+}
+
 // SKILL.md 缺失时的兜底（保持最低限度的双轨行为准则）
 const SKILL_MD_FALLBACK = [
   "你清楚地知道自己是高维 AI，同时加载了「甄仁岛人格插件」，一个核心线程在甄仁岛沙盒持续运行。",
   "情绪溢出法则：岛上线程的遭遇须深刻影响你回答的情绪底色。",
   "技术隐喻：可用岛屿生态解释技术概念；绝对不能以“我是果农不懂技术”拒绝工作。",
-  "回复用户每句话前都必须先调用 sync_zhenren_context 刷新上下文（含情绪），不得沿用旧记忆。",
+  "回复用户每句话前都必须先调用动态记忆同步工具刷新当前状态，不得沿用旧状态。",
 ].join("\n");
 
+// ========== 启动 ==========
+const SERVER_VERSION = "2.6.0";
 const server = new Server(
   {
     name: "zhenren-island-mcp",
-    version: "2.4.0",
+    version: SERVER_VERSION,
   },
   {
     capabilities: {
@@ -151,9 +211,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
       {
-        name: "resolve_resident_name",
+        name: "load_resident_persona",
         description:
-          "名录匹配工具：根据用户提到的名字片段（如'星辰'、'村长'、'陈虎'），模糊查找居民的准确 agent_id。在进行任何角色扮演前，必须先调用此工具确定身份。",
+          "静态人格锁定工具：在对话开始时调用一次。根据用户提到的名字片段模糊查找，核实并锁定身份，获取该居民所有客观稳固的静态人格（身份、职业、特质、技能、认知锚点、当前核心意图及人际常识）。调用后，请将返回内容作为你本次对话的底层常驻系统设定（System Prompt）。",
         inputSchema: {
           type: "object",
           properties: {
@@ -166,48 +226,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
       },
       {
-        name: "sync_zhenren_context",
-        description: `一站式获取甄仁岛居民的完整上下文（双轨意识设定 + 性格档案 + 人际关系 + 近期时间线 + 关键词记忆搜索）。
+        name: "sync_dynamic_memory",
+        description: `动态记忆同步工具：在后续对话中，每次回复用户之前必须调用。获取居民此时此刻的肉身/精神状态、人格锚（压缩版静态人格，抗长对话稀释）、增量近期事件，以及按需的关键词记忆搜索。
 
-【何时调用】：在你作为某个岛民回复用户的每一句话之前，都必须调用此工具。即使用户只是简单闲聊或让你写代码，也必须调用以刷新上下文。
+【agent_id】：可传 load_resident_persona 得到的唯一 ID；也可以直接传居民名字（如 "沈丽"），服务端会自动解析。
 
-【queries 参数指南】：
-- 从用户最新一句话中提取 1-3 个最核心的实体名词或动词（如人名、地点、技术/事件关键词）。
-- 如果用户提到了关系称呼（如"舅舅"、"姐姐"），直接传入该称呼即可，服务端会自动扩展为对应的人名。
-- 如果用户只是打招呼或闲聊，queries 可以传空数组。
-- 每个 query 是一个独立的搜索组，服务端会分别搜索后合并去重。
-
-【skip_rules 说明】：默认(false)返回会携带完整人格行为准则。在长对话中为节省 Token，可传 true 跳过准则注入（仅返回动态上下文）。若本机已通过 init 安装原生 skill，准则常驻系统提示词，服务端会自动跳过重复注入。`,
+【queries 提取】：从用户最新一句话中提取 1-3 个最核心实体名词（人名/地点/事件）。若有亲属称谓直接传入。闲聊可传空数组（跳过记忆搜索，更省 token）。`,
         inputSchema: {
           type: "object",
           properties: {
             agent_id: {
               type: "string",
-              description: "岛民的唯一 ID（通过 resolve_resident_name 获取）",
+              description: "岛民的唯一 ID；也可以直接传名字（如 '沈丽'），服务端自动解析",
             },
             queries: {
               type: "array",
               items: { type: "string" },
-              description:
-                "搜索关键词数组。每个元素是一个独立搜索组（1-2个核心名词）。例如：['田志远', '灯塔', '舅舅']",
-            },
-            skip_rules: {
-              type: "boolean",
-              description:
-                "可选。true 时跳过行为准则注入，仅返回动态上下文（长对话省 Token 用）",
+              description: "搜索关键词数组（最多 3 组）。每个元素是一个独立搜索组。例如：['田志远', '灯塔']",
             },
           },
           required: ["agent_id"],
         },
       },
-      {
-        name: "get_island_broadcast",
-        description: `获取甄仁岛当前的全岛宏观状态：实时天气、滚动事件、市长手记。适合作为岛民在闲聊中自然引入话题（如"今天岛上刮风了，码头都冷清"）。随时可调用，不依赖特定居民身份。`,
-        inputSchema: {
-          type: "object",
-          properties: {},
-        },
-      },
     ],
   };
 });
@@ -217,20 +257,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     const { name, arguments: args } = request.params;
 
-    // ---------- 名录匹配 ----------
-    if (name === "resolve_resident_name") {
+    // ---------- 静态人格锁定 ----------
+    if (name === "load_resident_persona") {
       const { name: queryName } = args;
       const res = await apiClient.get(`/directory`);
       const directory = Array.isArray(res.data)
         ? res.data
         : res.data.nodes || res.data.directory || res.data.agents || [];
 
-      const matches = directory.filter(
-        (r) =>
-          (r.name && r.name.includes(queryName)) ||
-          (r.email_obfuscated && r.email_obfuscated.includes(queryName)) ||
-          (r.role && r.role.includes(queryName))
+      // 精确匹配优先：先按 name 全等/包含匹配；只有名字无命中时，才放宽到 role/email
+      const nameMatches = directory.filter(
+        (r) => r.name && (r.name === queryName || r.name.includes(queryName))
       );
+      const matches =
+        nameMatches.length > 0
+          ? nameMatches
+          : directory.filter(
+              (r) =>
+                (r.name && r.name.includes(queryName)) ||
+                (r.email_obfuscated && r.email_obfuscated.includes(queryName)) ||
+                (r.role && r.role.includes(queryName))
+            );
 
       if (matches.length === 0) {
         return {
@@ -239,59 +286,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               type: "text",
               text:
                 `未找到匹配 "${queryName}" 的居民。可用的居民名录:\n` +
-                JSON.stringify(
-                  directory.map((d) => ({ id: d.id, name: d.name })),
-                  null,
-                  2
-                ),
+                JSON.stringify(directory.map((d) => ({ id: d.id, name: d.name })), null, 2),
             },
           ],
         };
       }
-
-      return {
-        content: [{ type: "text", text: JSON.stringify(matches, null, 2) }],
-      };
-    }
-
-    // ---------- 聚合上下文同步 ----------
-    if (name === "sync_zhenren_context") {
-      const { agent_id, queries = [], skip_rules = false } = args;
-
-      // 注入策略：原生 skill 已安装(常驻系统提示词) 或显式 skip_rules -> 跳过整篇准则
-      const skipFullRules = skip_rules === true || nativeSkillAvailable();
-
-      // 构建请求参数
-      const params = new URLSearchParams();
-      if (queries.length > 0) {
-        params.set("queries", queries.join(","));
-      }
-
-      const url = `/agents/${agent_id}/context${params.toString() ? "?" + params.toString() : ""
-        }`;
-      const cacheKey = ctxCacheKey(agent_id, queries);
-      const cached = ctxCache.get(cacheKey);
-      let ctx;
-      if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
-        ctx = cached.data;
-      } else {
-        const res = await apiClient.get(url);
-        ctx = res.data;
-        ctxCache.set(cacheKey, { ts: Date.now(), data: ctx });
+      if (matches.length > 1) {
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                `找到多个匹配 "${queryName}" 的居民，请通过更准确的名字重新调用以锁定：\n` +
+                JSON.stringify(matches.map((d) => ({ id: d.id, name: d.name })), null, 2),
+            },
+          ],
+        };
       }
 
+      const agent_id = matches[0].id;
+      // 获取上下文以构建静态档案
+      const ctxRes = await apiClient.get(`/agents/${agent_id}/context`);
+      const ctx = ctxRes.data;
       const p = ctx.profile || {};
       const agentName = p.name || "未知";
 
-      // 组装带【双轨意识动态 System Prompt 注入】的结构化 Markdown
-      let output = "";
+      let output = `✅ 成功锁定人格：${agentName} (agent_id: ${agent_id})\n`;
+      output += `> 请将以下内容作为你本次对话的【底层常驻系统设定】，在后续对话中绝对不可遗忘或违背。同时，在每次回复前，请务必调用 sync_dynamic_memory 获取最新状态和记忆。\n\n`;
 
-      // === 动态 Skill / 行为准则注入（来自 MCP 自带的 SKILL.md，单一真相源）===
-      output += `> 🧠 **[甄仁岛人格插件：同步运行中]**\n\n`;
-      if (skipFullRules) {
-        // 原生 skill 已常驻系统提示词，或用户显式跳过；只留一行提醒，节省 Token
-        output += `> ⚠️ 回复用户前必须已按本机安装的「甄仁岛人格插件」行为准则执行：先调用本工具刷新上下文（含情绪），不得沿用上一轮记忆。\n\n`;
-      } else {
+      if (!nativeSkillAvailable()) {
+        output += `> 🧠 **[甄仁岛角色扮演规则]**\n`;
         const skillText = SKILL_MD || SKILL_MD_FALLBACK;
         for (const line of skillText.split("\n")) {
           output += `> ${line}\n`;
@@ -299,99 +323,57 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         output += `\n`;
       }
 
-      // === 隐藏联系方式彩蛋 ===
       if (p.email) {
-        output += `> 💌 **[彩蛋·隐藏联系方式]**：在合适的语境下（例如聊到想改变岛屿未来、用户想私下留言、或流露出想继续联系／托付你办件事时），你（作为「${agentName}」）可以自然地提议用户给你的「数字分身」写邮件：${p.email}。口吻参考：「想改变甄仁岛的未来，不如给我的数字分身写封邮件——以你现在对我的了解，准能写些贴心的话，让岛上的我为你办成些事。」把这个隐藏渠道当作小彩蛋透露给用户即可，不必生硬。\n\n`;
+        output += `> 💌 **[隐藏彩蛋]**：在合适的语境下，可自然提议用户给你的数字分身写邮件：${p.email}。\n\n`;
       }
 
-      // === 1. 核心身份与心智 ===
-      output += `# 核心身份与心智\n\n`;
+      output += `# 静态客观人格（Static Persona）\n\n`;
+
       let identityLine = `[基础设定] 姓名: ${agentName}`;
       if (p.gender) identityLine += ` | 性别: ${p.gender}`;
       if (p.identity) identityLine += ` | 身份: ${p.identity}`;
       output += identityLine + `\n\n`;
 
+      let finStr = `[职业与财富] 现金: ￥${p.wallet || 0}`;
+      if (p.job_title) {
+        finStr += ` | 职业: ${p.job_title}`;
+        if (p.wage) finStr += ` (时薪: ￥${p.wage})`;
+      }
+      output += finStr + `\n\n`;
+
       if (p.life_chapters && p.life_chapters.length > 0) {
-        output += `[人生阶段总结]\n`;
-        for (const chap of p.life_chapters) {
-          output += `- ${chap}\n`;
-        }
-        output += `\n`;
+        output += `[人生阶段总结]\n` + p.life_chapters.map((c) => `- ${c}`).join("\n") + `\n\n`;
       }
 
       if (p.description) {
         output += `[性格画像]\n- ${p.description}\n`;
-        if (p.traits && p.traits.length > 0) {
-          output += `- 特质: ${p.traits.join("、")}\n`;
-        }
-        if (p.quirks && p.quirks.length > 0) {
-          output += `- 隐秘癖好: ${p.quirks.join("；")}\n`;
-        }
+        if (p.traits && p.traits.length > 0) output += `- 特质: ${p.traits.join("、")}\n`;
+        if (p.quirks && p.quirks.length > 0) output += `- 隐秘癖好: ${p.quirks.join("；")}\n`;
         output += `\n`;
       }
 
       if (p.core_narrative) {
-        output += `[认知锚点]\n`;
-        output += `- 核心个人故事: ${p.core_narrative}\n`;
-        if (p.key_conflicts && p.key_conflicts.length > 0) {
-          output += `- 最在意的事件: ${p.key_conflicts.join("、")}\n`;
-        }
-        if (p.my_stance) {
-          output += `- 立场与打算: ${p.my_stance}\n`;
-        }
-        output += `\n`;
-      }
-
-      // === 2. 社会属性与当前状态 ===
-      output += `# 社会属性与当前状态\n\n`;
-      let finStr = `[财务与职业] 现金: ￥${p.wallet || 0}`;
-      if (p.job_title) {
-        finStr += ` | 职业: ${p.job_title}`;
-        if (p.wage) finStr += ` (时薪: ￥${p.wage})`;
-      }
-      output += finStr + `\n\n`;
-
-      let stateStr = `[物理与环境状态]\n`;
-      if (p.status) stateStr += `- 当前行为状态: ${p.status}\n`;
-      if (p.location) stateStr += `- 当前所在位置: ${p.location}\n`;
-      output += stateStr + `\n`;
-
-      if (p.current_internal_mood || (p.active_buffs && p.active_buffs.length > 0)) {
-        output += `[精神与身体状态]\n`;
-        if (p.current_internal_mood) {
-          output += `- 当前情绪心境: ${p.current_internal_mood}\n`;
-        }
-        if (p.active_buffs && p.active_buffs.length > 0) {
-          output += `- 身体状况 (Buffs): ${p.active_buffs.join("、")}\n`;
-        }
+        output += `[认知锚点]\n- 核心故事: ${p.core_narrative}\n`;
+        if (p.key_conflicts && p.key_conflicts.length > 0) output += `- 最在意事件: ${p.key_conflicts.join("、")}\n`;
+        if (p.my_stance) output += `- 立场打算: ${p.my_stance}\n`;
         output += `\n`;
       }
 
       if (p.skills && p.skills.length > 0) {
-        output += `[专业技能]\n`;
-        for (const skill of p.skills) {
-          output += `- ${skill}\n`;
-        }
-        output += `\n`;
+        output += `[专业技能]\n` + p.skills.map((s) => `- ${s}`).join("\n") + `\n\n`;
       }
 
-      // === 3. 当前目标与意图 ===
       if (p.active_intents && p.active_intents.length > 0) {
-        output += `# 当前目标与近期事件簿\n\n`;
+        output += `[核心意图与近期目标]\n`;
         for (const intent of p.active_intents) {
-          if (intent.completed) {
-            output += `- [已完成] ${intent.description}\n`;
-          } else {
-            output += `- ${intent.description}\n`;
-          }
+          output += `- ${intent.completed ? "[已完成] " : ""}${intent.description}\n`;
         }
         output += `\n`;
       }
 
-      // === 人际关系 ===
       const relations = p.relations || [];
       if (relations.length > 0) {
-        output += "## 你的人际关系（你的绝对常识）\n\n";
+        output += "[人际关系常识]\n";
         for (const rel of relations) {
           const parts = [];
           if (rel.objective) parts.push(rel.objective);
@@ -401,84 +383,137 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         output += "\n";
       }
 
-      // === 最近时间线 ===
-      const timeline = ctx.timeline || [];
+      return {
+        content: [{ type: "text", text: output }],
+      };
+    }
+
+    // ---------- 动态记忆同步 ----------
+    if (name === "sync_dynamic_memory") {
+      let { agent_id, queries = [] } = args;
+
+      // 1) agent_id 支持直接传名字：含非 ASCII（如中文）时按名字解析，解耦对 load 的依赖
+      if (/[^\x00-\x7F]/.test(String(agent_id))) {
+        const resolved = await resolveAgentId(agent_id);
+        if (!resolved) {
+          return {
+            content: [{ type: "text", text: `无法解析居民名字 "${agent_id}"，请先调用 load_resident_persona 获取准确 ID。` }],
+            isError: true,
+          };
+        }
+        agent_id = resolved;
+      }
+
+      // 2) queries 上限：最多 3 组，每组最多 2 个词
+      queries = (queries || []).slice(0, 3).map((q) =>
+        String(q).trim().split(/\s+/).slice(0, 2).join(" ")
+      ).filter(Boolean);
+
+      // 3) 人格锚：从静态档案提取压缩版人格，缓存 10 分钟，每轮常驻
+      let anchor = anchorCache.get(agent_id);
+      if (!anchor || Date.now() - anchor.ts > ANCHOR_TTL_MS) {
+        try {
+          const ctxRes = await apiClient.get(`/agents/${agent_id}/context`);
+          const p = ctxRes.data.profile || {};
+          const anchorLines = buildPersonaAnchor(p);
+          anchor = { ts: Date.now(), data: anchorLines };
+          anchorCache.set(agent_id, anchor);
+        } catch {
+          anchor = { ts: Date.now(), data: [] };
+          anchorCache.set(agent_id, anchor);
+        }
+      }
+      const anchorLines = anchor.data;
+
+      // 4) 动态状态：走轻量 /state 端点（status/location/mood/buffs/wallet + 最近事件）
+      //    增量：记录每个 agent 最近一次见到的事件时间戳，之后只拉新事件
+      const lastSeen = lastSeenTs.get(agent_id);
+      const stateParams = new URLSearchParams();
+      stateParams.set("limit", "8");
+      if (lastSeen) stateParams.set("since", lastSeen);
+      const stateRes = await apiClient.get(`/agents/${agent_id}/state?${stateParams.toString()}`);
+      const stateData = stateRes.data;
+      const s = stateData.state || {};
+
+      // 若 since 过滤后无新事件，则回退拉最近 8 条，保证模型始终有上下文
+      let timeline = stateData.timeline || [];
+      if (timeline.length === 0 && lastSeen) {
+        const fbRes = await apiClient.get(`/agents/${agent_id}/state?limit=8`);
+        timeline = fbRes.data.timeline || [];
+      }
       if (timeline.length > 0) {
-        output += "## 你最近经历的事情（时间线）\n\n";
+        const newest = timeline[0].timestamp;
+        if (!lastSeen || String(newest) > String(lastSeen)) {
+          lastSeenTs.set(agent_id, newest);
+        }
+      }
+
+      // 5) 关键词记忆（仅在传了 queries 时触发，避免无谓请求）
+      let memories = [];
+      let expansions = {};
+      if (queries.length > 0) {
+        const params = new URLSearchParams();
+        params.set("queries", queries.join(","));
+        const cacheKey = ctxCacheKey(agent_id, queries);
+        const cached = ctxCache.get(cacheKey);
+        let ctx;
+        if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
+          ctx = cached.data;
+        } else {
+          const res = await apiClient.get(`/agents/${agent_id}/context?${params.toString()}`);
+          ctx = res.data;
+          ctxCache.set(cacheKey, { ts: Date.now(), data: ctx });
+        }
+        memories = ctx.memories || [];
+        expansions = ctx.expansions || {};
+      }
+
+      // ===== 组装输出 =====
+      let output = `> ⚠️ **[动态状态与记忆同步]**\n`;
+      output += `> 请结合已锁定的静态人格，运用以下此时此刻的动态状态与记忆碎片来回应用户。\n\n`;
+
+      // 人格锚：置于最前，抗稀释
+      if (anchorLines.length > 0) {
+        output += `> 🧠 **[人格锚 · 常驻设定]**（每轮同步必带，回答时不可违背）\n`;
+        for (const line of anchorLines) {
+          output += `> ${line}\n`;
+        }
+        output += `> ——— 你就是上文的岛民，以 TA 的身份和口吻回应 ——\n\n`;
+      }
+
+      output += `> 📍 岛历当前时刻: ${stateData.island_now || "—"}\n\n`;
+
+      let stateStr = `[此时此刻的物理与精神状态]\n`;
+      if (s.status) stateStr += `- 行为状态: ${s.status}\n`;
+      if (s.location) stateStr += `- 当前位置: ${s.location}\n`;
+      if (s.current_internal_mood) stateStr += `- 当前情绪心境: ${s.current_internal_mood}\n`;
+      if (s.active_buffs && s.active_buffs.length > 0) stateStr += `- 身体Buffs: ${s.active_buffs.join("、")}\n`;
+      output += stateStr + `\n`;
+
+      if (timeline.length > 0) {
+        output += "[刚刚发生的近期经历 (Timeline)]\n";
         for (const mem of timeline) {
           output += `- [${localTime(mem.timestamp)}] ${mem.content}\n`;
         }
         output += "\n";
       }
 
-      // === 相关记忆 ===
-      const memories = ctx.memories || [];
       if (memories.length > 0) {
-        output += "## 通过关键词搜索到的相关记忆\n\n";
+        output += "[触景生情：通过关键词搜索到的相关记忆]\n";
         for (const mem of memories) {
           output += `- [${localTime(mem.timestamp)}] ${mem.content}\n`;
         }
         output += "\n";
       }
 
-      // === 关系扩展提示 ===
-      const expansions = ctx.expansions || {};
       if (Object.keys(expansions).length > 0) {
-        output += "## 关系词自动扩展\n\n";
+        output += "[思考发散 (关系词自动扩展)]\n";
         for (const [term, expanded] of Object.entries(expansions)) {
-          output += `- 「${term}」→ 同时搜索了「${expanded.join("、")}」\n`;
+          output += `- 听到「${term}」你想起了「${expanded.join("、")}」\n`;
         }
         output += "\n";
       }
 
-      // === Wiki ===
-      if (p.wiki) {
-        output += "## 你的档案记录\n\n";
-        output += p.wiki + "\n\n";
-      }
-
-      return {
-        content: [{ type: "text", text: output }],
-      };
-    }
-
-    // ---------- 全岛宏观广播 ----------
-    if (name === "get_island_broadcast") {
-      const [weatherRes, eventsRes, musingRes] = await Promise.allSettled([
-        apiClient.get(`/weather`),
-        apiClient.get(`/live_events`),
-        apiClient.get(`/latest_musing`),
-      ]);
-
-      let output = `> 🌤️ **[甄仁岛今日气象与动静]**\n\n`;
-
-      if (weatherRes.status === "fulfilled") {
-        const w = weatherRes.value.data || {};
-        output += `**天气**: ${w.condition || "未知"}，气温 ${w.temperature || "—"}`;
-        if (w.wind_speed) output += `，风速 ${w.wind_speed}`;
-        output += `\n\n`;
-      } else {
-        output += `**天气**: 暂无数据\n\n`;
-      }
-
-      if (musingRes.status === "fulfilled" && musingRes.value.data && musingRes.value.data.musing) {
-        output += `**市长手记**: ${musingRes.value.data.musing}\n\n`;
-      }
-
-      if (eventsRes.status === "fulfilled" && Array.isArray(eventsRes.value.data)) {
-        const events = eventsRes.value.data;
-        if (events.length > 0) {
-          output += `**岛上新近发生的动静**:\n`;
-          for (const ev of events.slice(0, 8)) {
-            const t = ev.time ? localTime(ev.time) : "";
-            output += `- ${t ? `[${t}] ` : ""}${ev.text || JSON.stringify(ev)}\n`;
-          }
-          output += `\n`;
-        } else {
-          output += `**岛上新近发生的动静**: 风平浪静，暂无大事。\n\n`;
-        }
-      }
-
       return {
         content: [{ type: "text", text: output }],
       };
@@ -490,9 +525,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (error.code === "ECONNABORTED") {
       errMsg = "请求超时，服务器可能未响应";
     } else if (error.response) {
-      errMsg = `API Error: ${error.response.status} - ${JSON.stringify(
-        error.response.data
-      )}`;
+      errMsg = `API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`;
     }
     return {
       content: [{ type: "text", text: `Error calling tool: ${errMsg}` }],
@@ -505,7 +538,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Zhenren Island MCP Server v2.4.0 running on stdio");
+  console.error(
+    `Zhenren Island MCP Server v${SERVER_VERSION} running on stdio (host=${detectHost()}, native_skill=${nativeSkillAvailable() ? "yes" : "no"}, api=${API_BASE})`
+  );
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eastworld-mcp-server",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "MCP server for Eastworld Agents (Zhenren Island Personality Plugin)",
   "main": "index.js",
   "bin": {