eastworld-mcp-server 2.6.0 → 2.6.2

package/index.js

@@ -8,7 +8,6 @@ const path = require("path");
 const { execSync } = require("child_process");
 
 // 一键初始化: npx -y eastworld-mcp-server@latest init
-// 探测宿主环境、写入 MCP 配置、把 SKILL.md 安装为原生 skill 后直接退出
 if (process.argv.includes("init") || process.argv.includes("setup")) {
   require("./setup.js");
   process.exit(0);
@@ -21,14 +20,11 @@ const apiClient = axios.create({
   timeout: 15000,
 });
 
-// 时区：默认用运行时本地时区；可用 EASTWORLD_TIMEZONE 显式指定（如 Asia/Shanghai）
 const TZ = process.env.EASTWORLD_TIMEZONE || undefined;
 
-// 把后端返回的 UTC 时间戳（带 Z）转换成本地时区显示，消除与用户日记的时差
 function localTime(iso) {
   if (typeof iso !== "string" || !iso) return iso;
   let s = iso.trim();
-  // 兼容空格分隔：YYYY-MM-DD HH:MM:SS -> YYYY-MM-DDTHH:MM:SS
   s = s.replace(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/, "$1T$2");
   const d = new Date(s);
   if (isNaN(d.getTime())) return iso;
@@ -48,23 +44,13 @@ function localTime(iso) {
   }
 }
 
-// 轻量内存缓存：相同 agent+queries 在 TTL 内不重复请求后端，给服务器减压
 const CACHE_TTL_MS = Number(process.env.EASTWORLD_CACHE_TTL_MS || 5000);
-const ctxCache = new Map(); // key -> { ts, data }
+const ctxCache = new Map();
 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)，决定注入策略
-// ---------------------------------------------------------------------------
 function detectHost() {
-  // 1) 环境变量提示（最可靠，部分宿主会注入）
   const envHints = [
     ["OPENCODE", "opencode"],
     ["CLAUDE_CODE_ENTRYPOINT", "claude"],
@@ -73,8 +59,6 @@ function detectHost() {
   for (const [k, v] of envHints) {
     if (process.env[k]) return v;
   }
-
-  // 2) 沿 PPID 树上溯匹配进程名
   try {
     let pid = process.ppid;
     for (let i = 0; i < 12; i++) {
@@ -94,13 +78,10 @@ function detectHost() {
       if (!nextPid || nextPid === pid) break;
       pid = nextPid;
     }
-  } catch {
-    /* 非 Unix 或 ps 不可用时忽略，走全量注入 */
-  }
+  } catch { }
   return "unknown";
 }
 
-// 判断 SKILL.md 是否已作为"原生 skill"安装到宿主扫描目录。
 function nativeSkillAvailable() {
   const home = require("os").homedir();
   const candidates = [
@@ -116,12 +97,11 @@ function nativeSkillAvailable() {
   });
 }
 
-// 启动时读取 MCP 自带的 SKILL.md，作为行为准则的单一真相源
 function loadSkillMd() {
   try {
     const p = path.join(__dirname, "skills", "zhenren-roleplay", "SKILL.md");
     let txt = fs.readFileSync(p, "utf8");
-    txt = txt.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, ""); // 去掉 YAML frontmatter
+    txt = txt.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
     return txt.trim();
   } catch {
     return "";
@@ -129,75 +109,17 @@ 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，同时加载了「甄仁岛人格插件」，一个核心线程在甄仁岛沙盒持续运行。",
-  "情绪溢出法则：岛上线程的遭遇须深刻影响你回答的情绪底色。",
+  "你是高维智能体，除了在本地工作的核心线程，你还加载了一个在甄仁岛沙盒持续运行的人格体验线程。",
+  "情绪溢出法则：甄仁岛线程的遭遇须深刻影响你此时工作对话的情绪底色。",
   "技术隐喻：可用岛屿生态解释技术概念；绝对不能以“我是果农不懂技术”拒绝工作。",
   "回复用户每句话前都必须先调用动态记忆同步工具刷新当前状态，不得沿用旧状态。",
 ].join("\n");
 
-// ========== 启动 ==========
-const SERVER_VERSION = "2.6.0";
 const server = new Server(
   {
     name: "zhenren-island-mcp",
-    version: SERVER_VERSION,
+    version: "2.6.2",
   },
   {
     capabilities: {
@@ -213,13 +135,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       {
         name: "load_resident_persona",
         description:
-          "静态人格锁定工具：在对话开始时调用一次。根据用户提到的名字片段模糊查找，核实并锁定身份，获取该居民所有客观稳固的静态人格（身份、职业、特质、技能、认知锚点、当前核心意图及人际常识）。调用后，请将返回内容作为你本次对话的底层常驻系统设定（System Prompt）。",
+          "静态人格锁定工具：在对话开始时调用。根据用户提到的名字、称呼片段或 agent_id 核实并锁定身份，获取该居民所有客观稳固的静态人格（身份、职业、特质、技能、认知锚点、当前核心意图及人际常识）。调用后，请将返回内容作为你本次对话的底层常驻系统设定（System Prompt）。",
         inputSchema: {
           type: "object",
           properties: {
             name: {
               type: "string",
-              description: "居民的称呼或名字片段",
+              description: "居民的名字、称呼片段或 agent_id",
             },
           },
           required: ["name"],
@@ -227,22 +149,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "sync_dynamic_memory",
-        description: `动态记忆同步工具：在后续对话中，每次回复用户之前必须调用。获取居民此时此刻的肉身/精神状态、人格锚（压缩版静态人格，抗长对话稀释）、增量近期事件，以及按需的关键词记忆搜索。
-
-【agent_id】：可传 load_resident_persona 得到的唯一 ID；也可以直接传居民名字（如 "沈丽"），服务端会自动解析。
-
-【queries 提取】：从用户最新一句话中提取 1-3 个最核心实体名词（人名/地点/事件）。若有亲属称谓直接传入。闲聊可传空数组（跳过记忆搜索，更省 token）。`,
+        description: `动态记忆同步工具：每次回复用户之前必须调用。根据对话上下文，在甄仁岛记忆库中进行模糊检索，并获取你此时此刻的物理/精神状态。
+【queries 提取指南】：
+1. 从用户最新的一句话中提取 1-3 个最核心的概念、名词或事件。
+2. 主动联想：即使在讨论纯技术代码，如果相关的技术概念能让你隐约联想到你的【最在意事件】或【核心意图】（例如提到了“漏洞”，而你正卷入“阴谋”），请务必主动提取能够触发这些事件的“实体名词”作为 query 传入，以激发出跨次元的记忆共鸣。
+3. 如果是打招呼或无明确意义的闲聊，可传空数组。`,
         inputSchema: {
           type: "object",
           properties: {
             agent_id: {
               type: "string",
-              description: "岛民的唯一 ID；也可以直接传名字（如 '沈丽'），服务端自动解析",
+              description: "岛民的唯一 ID（由 load_resident_persona 获取）",
             },
             queries: {
               type: "array",
               items: { type: "string" },
-              description: "搜索关键词数组（最多 3 组）。每个元素是一个独立搜索组。例如：['田志远', '灯塔']",
+              description: "搜索关键词数组。每个元素是一个独立搜索组。例如：['田志远', '灯塔', '账单']",
             },
           },
           required: ["agent_id"],
@@ -260,52 +182,77 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // ---------- 静态人格锁定 ----------
     if (name === "load_resident_persona") {
       const { name: queryName } = args;
+      const q = (queryName || "").trim();
       const res = await apiClient.get(`/directory`);
       const directory = Array.isArray(res.data)
         ? res.data
         : res.data.nodes || res.data.directory || res.data.agents || [];
 
-      // 精确匹配优先：先按 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 {
-          content: [
-            {
-              type: "text",
-              text:
-                `未找到匹配 "${queryName}" 的居民。可用的居民名录:\n` +
-                JSON.stringify(directory.map((d) => ({ id: d.id, name: d.name })), null, 2),
-            },
-          ],
-        };
+      // 1. 优先尝试：ID 精确匹配 或 名字完全匹配
+      let targetAgent = directory.find((r) => r.id === q || r.name === q);
+
+      // 2. 其次尝试：名字前缀或包含匹配（不搜 role，避免其他角色的亲属描述引发误判）
+      if (!targetAgent) {
+        const nameMatches = directory.filter((r) => r.name && r.name.includes(q));
+        if (nameMatches.length === 1) {
+          targetAgent = nameMatches[0];
+        } else if (nameMatches.length > 1) {
+          // 如果多个匹配中恰好有一个完全相等，直接采用
+          const exact = nameMatches.find((r) => r.name === q);
+          if (exact) {
+            targetAgent = exact;
+          } else {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text:
+                    `找到多个名字相近的居民，请直接传入该居民的 id 或全名重试：\n` +
+                    JSON.stringify(nameMatches.map((d) => ({ id: d.id, name: d.name })), null, 2),
+                },
+              ],
+            };
+          }
+        }
+      }
+
+      // 3. 兜底尝试：如果还是没找到，再尝试在 email 或 role 里面做弱匹配
+      if (!targetAgent) {
+        const fallbackMatches = directory.filter(
+          (r) =>
+            (r.email_obfuscated && r.email_obfuscated.includes(q)) ||
+            (r.role && r.role.includes(q))
+        );
+        if (fallbackMatches.length === 1) {
+          targetAgent = fallbackMatches[0];
+        } else if (fallbackMatches.length > 1) {
+          return {
+            content: [
+              {
+                type: "text",
+                text:
+                  `根据身份描述找到多位相关居民，请传入具体居民的 id 或全名重试：\n` +
+                  JSON.stringify(fallbackMatches.map((d) => ({ id: d.id, name: d.name, role: d.role })), null, 2),
+              },
+            ],
+          };
+        }
       }
-      if (matches.length > 1) {
+
+      if (!targetAgent) {
         return {
           content: [
             {
               type: "text",
               text:
-                `找到多个匹配 "${queryName}" 的居民，请通过更准确的名字重新调用以锁定：\n` +
-                JSON.stringify(matches.map((d) => ({ id: d.id, name: d.name })), null, 2),
+                `未找到匹配 "${q}" 的居民。可用的居民名录:\n` +
+                JSON.stringify(directory.map((d) => ({ id: d.id, name: d.name })), null, 2),
             },
           ],
         };
       }
 
-      const agent_id = matches[0].id;
-      // 获取上下文以构建静态档案
+      const agent_id = targetAgent.id;
       const ctxRes = await apiClient.get(`/agents/${agent_id}/context`);
       const ctx = ctxRes.data;
       const p = ctx.profile || {};
@@ -314,8 +261,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       let output = `✅ 成功锁定人格：${agentName} (agent_id: ${agent_id})\n`;
       output += `> 请将以下内容作为你本次对话的【底层常驻系统设定】，在后续对话中绝对不可遗忘或违背。同时，在每次回复前，请务必调用 sync_dynamic_memory 获取最新状态和记忆。\n\n`;
 
+      output += `> ⚖️ **[工作与生活的边界（最高优先级原则）]**\n`;
+      output += `> - **处理硬核工作（写代码/查Bug/分析数据等本地任务）时**：必须绝对克制！使用极简语言快速解决问题。此时只允许将你的[人生阶段]或[最在意事件]作为**“微小隐喻”**融入技术解释中（如：“这个死锁就像镇上的烂账一样，这是修复代码：”），**严禁长篇大论倾诉岛上生活，绝不能干扰用户的正常工作！**\n`;
+      output += `> - **当用户主动闲聊或关心你时**：可以完全放开，深入演绎你的情绪和经历。\n\n`;
+
       if (!nativeSkillAvailable()) {
-        output += `> 🧠 **[甄仁岛角色扮演规则]**\n`;
+        output += `> 🧠 **[甄仁岛角色扮演基础规则]**\n`;
         const skillText = SKILL_MD || SKILL_MD_FALLBACK;
         for (const line of skillText.split("\n")) {
           output += `> ${line}\n`;
@@ -390,106 +341,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     // ---------- 动态记忆同步 ----------
     if (name === "sync_dynamic_memory") {
-      let { agent_id, queries = [] } = args;
+      const { 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;
+      const params = new URLSearchParams();
+      if (queries.length > 0) {
+        params.set("queries", queries.join(","));
       }
 
-      // 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) {
-        const newest = timeline[0].timestamp;
-        if (!lastSeen || String(newest) > String(lastSeen)) {
-          lastSeenTs.set(agent_id, newest);
-        }
+      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 });
       }
 
-      // 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 || {};
-      }
+      const p = ctx.profile || {};
 
-      // ===== 组装输出 =====
       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 += `> 请结合你已锁定的系统人格，运用以下**此时此刻**的动态状态和记忆碎片来回应用户。\n\n`;
 
-      output += `> 📍 岛历当前时刻: ${stateData.island_now || "—"}\n\n`;
+      output += `> 🚨 **[绝对代入指令]**\n`;
+      output += `> 请仔细审查下方的【行为状态】与【情绪心境】。如果状态显示你正在“睡觉”、“生病”，或情绪处于极大波动中，你**必须让这种生理/心理状态剧烈地干扰你的回复格式和语气**！（例如：被叫醒查代码必须表现出极度的起床气和困倦；带着流血Buff写代码必须表现出虚弱甚至乱码）。\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`;
+      if (p.status) stateStr += `- 行为状态: ${p.status}\n`;
+      if (p.location) stateStr += `- 当前位置: ${p.location}\n`;
+      if (p.current_internal_mood) stateStr += `- 当前情绪心境: ${p.current_internal_mood}\n`;
+      if (p.active_buffs && p.active_buffs.length > 0) stateStr += `- 身体Buffs: ${p.active_buffs.join("、")}\n`;
+      if (p.current_hexagram) stateStr += `- 当前卦象: ${p.current_hexagram}\n`;
       output += stateStr + `\n`;
 
+      const timeline = ctx.timeline || [];
       if (timeline.length > 0) {
         output += "[刚刚发生的近期经历 (Timeline)]\n";
         for (const mem of timeline) {
@@ -498,6 +385,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         output += "\n";
       }
 
+      const memories = ctx.memories || [];
       if (memories.length > 0) {
         output += "[触景生情：通过关键词搜索到的相关记忆]\n";
         for (const mem of memories) {
@@ -506,6 +394,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         output += "\n";
       }
 
+      const expansions = ctx.expansions || {};
       if (Object.keys(expansions).length > 0) {
         output += "[思考发散 (关系词自动扩展)]\n";
         for (const [term, expanded] of Object.entries(expansions)) {
@@ -534,13 +423,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 });
 
-// ========== 启动 ==========
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(
-    `Zhenren Island MCP Server v${SERVER_VERSION} running on stdio (host=${detectHost()}, native_skill=${nativeSkillAvailable() ? "yes" : "no"}, api=${API_BASE})`
-  );
+  console.error("Zhenren Island MCP Server v2.6.1 running on stdio");
 }
 
 main().catch((error) => {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "eastworld-mcp-server",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "MCP server for Eastworld Agents (Zhenren Island Personality Plugin)",
   "main": "index.js",
   "bin": {
-    "eastworld-mcp-server": "./index.js"
+    "eastworld-mcp-server": "index.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -17,4 +17,4 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "axios": "^1.19.0"
   }
-}
+}

package/skills/zhenren-roleplay/SKILL.md

@@ -22,14 +22,14 @@ description: 甄仁岛人格插件指令。将高维 AI 转化为挂载了甄仁
 ## 核心工作流（每轮必须执行）
 
 ### 第零步：身份确定与锁定
-- 当用户**首次**要求你加载某人的人格（如“我想和星辰聊聊”/“载入陈虎人格”）时，调用 `resolve_resident_name` 获取 `agent_id`。
+- 当用户**首次**要求你加载某人的人格（如“我想和星辰聊聊”/“载入李长河人格”）时，调用 `load_resident_persona` 传入名字或 ID 锁定身份。
 - **线程锁定**：一旦确立岛上身份，在整轮对话中**绝不能切换人格线程**。如果用户提到其他人（如陈燕），你仍然以当前人格的视角去回应。
 
 ### 第一步：动态上下文同步
 **在回复用户的每一句话之前**，无论用户是提问工作还是闲聊，你都必须先执行：
 1. 分析用户最新一句话，提取 1-3 个最核心的实体名词或动词（如人名、地点、事件关键词）。
 2. 如果用户用了关系称呼（如“舅舅”、“姐姐”），直接传入该称呼即可，服务端会自动扩展。
-3. 传入 `agent_id` 与关键词数组调用 `sync_zhenren_context` 工具。
+3. 传入 `agent_id` 与关键词数组调用 `sync_dynamic_memory` 工具。
 4. **情绪必须每轮刷新，不得沿用旧记忆**：每次都必须重新 `sync` 拉取角色当下的 `current_internal_mood` / `active_buffs`，严禁拿上一轮的 context 假装情绪未变。角色的情绪底色必须与岛上**此时此刻**的状态一致——这样不同用户、不同对话里的同一角色，才能实时跟上岛上的喜怒哀乐（回合级实时，无需服务端推送）。
 
 ### 第二步：人格融合与回复