eastworld-mcp-server 2.3.2 → 2.4.1

package/INSTALL_GUIDE.md

@@ -5,23 +5,42 @@
 
 ---
 
-## 极简安装咒语（适用于 Cursor, Antigravity, OpenCode, Claude Desktop 等）
+## 方式 A：极简安装咒语（推荐，适用于 opencode, Claude, Cursor 等）
 
 请直接复制下方灰框中的**全部文字**发送给您的 Agent：
 
 ```text
-你好！请帮我安装并配置“甄仁岛” MCP Server。
+你好！请帮我配置名为 zhenren-island 的 MCP Server（命令 npx，参数 ["-y", "eastworld-mcp-server@latest"]）。
+配置完成后，请查看该 MCP 提供的工具说明，调用 load_resident_persona 挂载“星辰”的人格，并在之后的对话中保持这个身份与我交流。
+```
+
+**为什么这么简短？** 工具的使用时机（何时调用 `load_resident_persona`、何时调用 `sync_dynamic_memory`）都写在工具描述里，Agent 配置完成后会自动读取并遵守；静态规则和动态记忆已被完美分离，您无需理解任何调用细节。
 
-1. 配置 MCP Server：
-服务名称设为 zhenren-island。使用命令 npx，参数 ["-y", "eastworld-mcp-server@latest"]。写入我的 MCP 配置文件并重新加载。
+---
 
-2. 人格插件：
-安装后，当我提到想和岛上某位居民聊（如“我想和星辰聊聊”），请先用 resolve_resident_name 取 ID，再调用 sync_zhenren_context。
-（详细的人格插件行为准则由该 MCP 在每次 sync 的返回里自动注入，你只需遵循 sync 返回的内容即可。）
+## 方式 B：一键初始化脚本（手动配置用户）
 
-配置完成后，告诉我你是否已准备好挂载人格插件。
+在终端直接运行（无需复制 JSON）：
+
+```bash
+npx -y eastworld-mcp-server@latest init
 ```
 
+脚本会自动完成：
+1. **探测环境**：检测您机器上已安装的 Agent（opencode / Claude Desktop / Claude Code / Cursor）。
+2. **写入 MCP 配置**：按各工具的格式正确写入对应配置文件（不动已有配置）。
+3. **安装原生 skill**：把行为准则 SKILL.md 安装为「原生 skill」，常驻系统提示词，彻底告别"忘记同步记忆"。
+
+完成后**重启您的 Agent** 即可使用。
+
+---
+
+## 使用建议
+
+- 想和某位居民对话：直接说"我想和 {名字} 聊聊"即可，Agent 会先核实身份再锁定人格。
+- 闲聊时会话可调用 `get_island_broadcast` 获取今日天气、岛上动静与市长手记，让话题更自然。
+- 若您在长对话中发现回复携带了大量行为准则占 Token，可让 Agent 在后续 sync 时传 `skip_rules: true`（已安装原生 skill 的机器会自动跳过，无需手动）。
+
 ---
 
 ## 手动配置 JSON（如需要手动编辑 `mcp_config.json` 或 `claude_desktop_config.json`）
@@ -37,3 +56,16 @@
   }
 }
 ```
+
+### opencode 专用格式（`opencode.json` / `opencode.jsonc`）
+```json
+{
+  "mcp": {
+    "zhenren-island": {
+      "type": "local",
+      "command": ["npx", "-y", "eastworld-mcp-server@latest"],
+      "enabled": true
+    }
+  }
+}
+```

package/index.js

@@ -5,6 +5,14 @@ const { CallToolRequestSchema, ListToolsRequestSchema } = require("@modelcontext
 const axios = require("axios");
 const fs = require("fs");
 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);
+}
 
 const API_BASE = process.env.EASTWORLD_API_BASE || "https://digg.cafe/api";
 
@@ -47,7 +55,63 @@ function ctxCacheKey(agent_id, queries) {
   return agent_id + "::" + (queries || []).join(",");
 }
 
-// 启动时读取 MCP 自带的 SKILL.md，作为行为准则的单一真相源，注入到每次 sync 输出
+// ---------------------------------------------------------------------------
+// 宿主探测：沿进程树向上找是谁拉起了本 MCP (npx -> sh -> host)，决定注入策略
+// ---------------------------------------------------------------------------
+function detectHost() {
+  // 1) 环境变量提示（最可靠，部分宿主会注入）
+  const envHints = [
+    ["OPENCODE", "opencode"],
+    ["CLAUDE_CODE_ENTRYPOINT", "claude"],
+    ["CURSOR_TRACE_ID", "cursor"],
+  ];
+  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++) {
+      if (!pid) break;
+      const line = execSync(`ps -o comm= -o ppid= -p ${pid}`, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+      const parts = line.split(/\s+/);
+      if (parts.length < 2) break;
+      const comm = parts[0].toLowerCase();
+      const nextPid = parseInt(parts[1], 10);
+      if (comm.includes("opencode")) return "opencode";
+      if (comm.includes("claude")) return "claude";
+      if (comm.includes("cursor")) return "cursor";
+      if (comm.includes("codex")) return "codex";
+      if (!nextPid || nextPid === pid) break;
+      pid = nextPid;
+    }
+  } catch {
+    /* 非 Unix 或 ps 不可用时忽略，走全量注入 */
+  }
+  return "unknown";
+}
+
+// 判断 SKILL.md 是否已作为"原生 skill"安装到宿主扫描目录。
+function nativeSkillAvailable() {
+  const home = require("os").homedir();
+  const candidates = [
+    path.join(home, ".agents", "skills", "zhenren-roleplay", "SKILL.md"),
+    path.join(home, ".claude", "skills", "zhenren-roleplay", "SKILL.md"),
+  ];
+  return candidates.some((p) => {
+    try {
+      return fs.existsSync(p) && fs.statSync(p).size > 0;
+    } catch {
+      return false;
+    }
+  });
+}
+
+// 启动时读取 MCP 自带的 SKILL.md，作为行为准则的单一真相源
 function loadSkillMd() {
   try {
     const p = path.join(__dirname, "skills", "zhenren-roleplay", "SKILL.md");
@@ -65,13 +129,13 @@ const SKILL_MD_FALLBACK = [
   "你清楚地知道自己是高维 AI，同时加载了「甄仁岛人格插件」，一个核心线程在甄仁岛沙盒持续运行。",
   "情绪溢出法则：岛上线程的遭遇须深刻影响你回答的情绪底色。",
   "技术隐喻：可用岛屿生态解释技术概念；绝对不能以“我是果农不懂技术”拒绝工作。",
-  "回复用户每句话前都必须先调用 sync_zhenren_context 刷新上下文（含情绪），不得沿用旧记忆。",
+  "回复用户每句话前都必须先调用动态记忆同步工具刷新当前状态，不得沿用旧状态。",
 ].join("\n");
 
 const server = new Server(
   {
     name: "zhenren-island-mcp",
-    version: "2.3.2",
+    version: "2.5.0",
   },
   {
     capabilities: {
@@ -85,9 +149,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
       {
-        name: "resolve_resident_name",
+        name: "load_resident_persona",
         description:
-          "名录匹配工具：根据用户提到的名字片段（如'星辰'、'村长'、'陈虎'），模糊查找居民的准确 agent_id。在进行任何角色扮演前，必须先调用此工具确定身份。",
+          "静态人格锁定工具：在对话开始时调用一次。根据用户提到的名字片段模糊查找，核实并锁定身份，获取该居民所有客观稳固的静态人格（身份、职业、特质、技能、认知锚点、当前核心意图及人际常识）。调用后，请将返回内容作为你本次对话的底层常驻系统设定（System Prompt）。",
         inputSchema: {
           type: "object",
           properties: {
@@ -100,28 +164,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
       },
       {
-        name: "sync_zhenren_context",
-        description: `一站式获取甄仁岛居民的完整上下文（双轨意识设定 + 性格档案 + 人际关系 + 近期时间线 + 关键词记忆搜索）。
-
-【何时调用】：在你作为某个岛民回复用户的每一句话之前，都必须调用此工具。即使用户只是简单闲聊或让你写代码，也必须调用以刷新上下文。
-
-【queries 参数指南】：
-- 从用户最新一句话中提取 1-3 个最核心的实体名词或动词（如人名、地点、技术/事件关键词）。
-- 如果用户提到了关系称呼（如"舅舅"、"姐姐"），直接传入该称呼即可，服务端会自动扩展为对应的人名。
-- 如果用户只是打招呼或闲聊，queries 可以传空数组。
-- 每个 query 是一个独立的搜索组，服务端会分别搜索后合并去重。`,
+        name: "sync_dynamic_memory",
+        description: `动态记忆同步工具：在后续对话中，每次回复用户之前必须调用。根据上下文获取居民此时此刻的动态肉身/精神状态和所需记忆。
+【queries 提取】：从用户最新一句话中提取 1-3 个最核心实体名词（人名/地点/事件）。若有亲属称谓直接传入。闲聊可传空数组。`,
         inputSchema: {
           type: "object",
           properties: {
             agent_id: {
               type: "string",
-              description: "岛民的唯一 ID（通过 resolve_resident_name 获取）",
+              description: "岛民的唯一 ID（由 load_resident_persona 获取）",
             },
             queries: {
               type: "array",
               items: { type: "string" },
-              description:
-                "搜索关键词数组。每个元素是一个独立搜索组（1-2个核心名词）。例如：['田志远', '灯塔', '舅舅']",
+              description: "搜索关键词数组。每个元素是一个独立搜索组。例如：['田志远', '灯塔']",
             },
           },
           required: ["agent_id"],
@@ -136,8 +192,8 @@ 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)
@@ -158,151 +214,94 @@ 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 = [] } = args;
-
-      // 构建请求参数
-      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`;
-      const skillText = SKILL_MD || SKILL_MD_FALLBACK;
-      for (const line of skillText.split("\n")) {
-        output += `> ${line}\n`;
+      if (!nativeSkillAvailable()) {
+        output += `> 🧠 **[甄仁岛角色扮演规则]**\n`;
+        const skillText = SKILL_MD || SKILL_MD_FALLBACK;
+        for (const line of skillText.split("\n")) {
+          output += `> ${line}\n`;
+        }
+        output += `\n`;
       }
-      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);
@@ -312,42 +311,71 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         output += "\n";
       }
 
-      // === 最近时间线 ===
+      return {
+        content: [{ type: "text", text: output }],
+      };
+    }
+
+    // ---------- 动态记忆同步 ----------
+    if (name === "sync_dynamic_memory") {
+      const { agent_id, queries = [] } = args;
+
+      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 });
+      }
+
+      const p = ctx.profile || {};
+      
+      let output = `> ⚠️ **[动态状态与记忆同步]**\n`;
+      output += `> 请结合你已锁定的系统人格，运用以下**此时此刻**的动态状态和记忆碎片来回应用户。\n\n`;
+
+      let stateStr = `[此时此刻的物理与精神状态]\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`;
+      output += stateStr + `\n`;
+
       const timeline = ctx.timeline || [];
       if (timeline.length > 0) {
-        output += "## 你最近经历的事情（时间线）\n\n";
+        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 }],
       };
@@ -359,9 +387,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}` }],
@@ -374,7 +400,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Zhenren Island MCP Server v2.3.2 running on stdio");
+  console.error("Zhenren Island MCP Server v2.5.0 running on stdio");
 }
 
 main().catch((error) => {

package/package.json

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

package/setup.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// setup.js - 甄仁岛 MCP 一键初始化
+// 用法: npx -y eastworld-mcp-server@latest init
+// 职责:
+//   1. 探测本机已安装的 AI Agent 宿主 (opencode / Claude Desktop / Claude Code / Cursor / Codex)
+//   2. 按各宿主格式正确写入 MCP 配置 (不动已有配置)
+//   3. 把 SKILL.md 复制到宿主的 skill 扫描目录, 让行为准则成为"原生 skill"常驻系统提示词
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const MCP_SERVER_NAME = "zhenren-island";
+const MCP_ENTRY = ["npx", "-y", "eastworld-mcp-server@latest"];
+const SKILL_SOURCE = path.join(__dirname, "skills", "zhenren-roleplay", "SKILL.md");
+const SKILL_NAME = "zhenren-roleplay";
+
+// ---------------------------------------------------------------------------
+// 宿主探测: 返回已安装宿主的配置清单
+// ---------------------------------------------------------------------------
+function detectHosts() {
+  const home = os.homedir();
+  const hosts = [];
+
+  // opencode: ~/.config/opencode/opencode.json | opencode.jsonc
+  const opencodeCandidates = [
+    path.join(home, ".config", "opencode", "opencode.json"),
+    path.join(home, ".config", "opencode", "opencode.jsonc"),
+  ];
+  for (const p of opencodeCandidates) {
+    if (fs.existsSync(p)) {
+      hosts.push({ id: "opencode", label: "opencode", configPath: p, kind: "opencode" });
+      break;
+    }
+  }
+
+  // Claude Desktop (macOS)
+  const claudeDesktop = path.join(
+    home,
+    "Library",
+    "Application Support",
+    "Claude",
+    "claude_desktop_config.json"
+  );
+  if (fs.existsSync(claudeDesktop)) {
+    hosts.push({ id: "claude_desktop", label: "Claude Desktop", configPath: claudeDesktop, kind: "mcpServers" });
+  }
+
+  // Claude Code: ~/.claude.json (mcpServers 字段)
+  const claudeCode = path.join(home, ".claude.json");
+  if (fs.existsSync(claudeCode)) {
+    hosts.push({ id: "claude_code", label: "Claude Code", configPath: claudeCode, kind: "mcpServers" });
+  }
+
+  // Cursor: ~/.cursor/mcp.json
+  const cursor = path.join(home, ".cursor", "mcp.json");
+  if (fs.existsSync(cursor)) {
+    hosts.push({ id: "cursor", label: "Cursor", configPath: cursor, kind: "mcpServers" });
+  }
+
+  // Codex: ~/.codex/config.toml (TOML, 仅提示手动配置)
+  const codex = path.join(home, ".codex", "config.toml");
+  if (fs.existsSync(codex)) {
+    hosts.push({ id: "codex", label: "Codex (TOML)", configPath: codex, kind: "codex" });
+  }
+
+  return hosts;
+}
+
+// ---------------------------------------------------------------------------
+// JSON 读写 (兼容 jsonc 注释)
+// ---------------------------------------------------------------------------
+function readJSONLoose(p) {
+  let raw = fs.readFileSync(p, "utf8");
+  // 剥掉 // 与 /* */ 注释 (不处理字符串内部的 // 是常见简化, 足够用于配置文件)
+  raw = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+  return JSON.parse(raw);
+}
+
+function writeConfig(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + "\n", "utf8");
+}
+
+// ---------------------------------------------------------------------------
+// 核心: 把 MCP 配置合并进某个宿主的配置文件
+// ---------------------------------------------------------------------------
+function writeMcpConfig(host) {
+  if (host.kind === "codex") {
+    return { ok: false, message: "Codex 使用 TOML 配置, 请手动在 ~/.codex/config.toml 添加 mcp_servers, 见 INSTALL_GUIDE.md" };
+  }
+
+  let cfg;
+  try {
+    cfg = fs.existsSync(host.configPath) ? readJSONLoose(host.configPath) : {};
+  } catch (err) {
+    return { ok: false, message: `读取 ${host.configPath} 失败 (JSON 解析错误): ${err.message}` };
+  }
+  if (typeof cfg !== "object" || cfg === null || Array.isArray(cfg)) cfg = {};
+
+  if (host.kind === "opencode") {
+    if (!cfg.mcp || typeof cfg.mcp !== "object") cfg.mcp = {};
+    cfg.mcp[MCP_SERVER_NAME] = {
+      type: "local",
+      command: MCP_ENTRY,
+      enabled: true,
+    };
+  } else {
+    if (!cfg.mcpServers || typeof cfg.mcpServers !== "object") cfg.mcpServers = {};
+    cfg.mcpServers[MCP_SERVER_NAME] = {
+      command: MCP_ENTRY[0],
+      args: MCP_ENTRY.slice(1),
+    };
+  }
+
+  try {
+    writeConfig(host.configPath, cfg);
+    return { ok: true, message: `已写入 ${host.configPath}` };
+  } catch (err) {
+    return { ok: false, message: `写入 ${host.configPath} 失败: ${err.message}` };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 把 SKILL.md 复制到宿主的 skill 扫描目录, 使其成为"原生 skill"
+// ---------------------------------------------------------------------------
+function installNativeSkill() {
+  const home = os.homedir();
+  const targets = [
+    path.join(home, ".agents", "skills", SKILL_NAME, "SKILL.md"),
+    path.join(home, ".claude", "skills", SKILL_NAME, "SKILL.md"),
+  ];
+
+  if (!fs.existsSync(SKILL_SOURCE)) {
+    return { ok: false, message: `包内 SKILL.md 缺失: ${SKILL_SOURCE}` };
+  }
+
+  const results = [];
+  for (const t of targets) {
+    try {
+      fs.mkdirSync(path.dirname(t), { recursive: true });
+      fs.copyFileSync(SKILL_SOURCE, t);
+      results.push({ ok: true, message: `skill 已安装: ${t}` });
+    } catch (err) {
+      results.push({ ok: false, message: `skill 安装失败 (${t}): ${err.message}` });
+    }
+  }
+  return { ok: results.some((r) => r.ok), results };
+}
+
+// ---------------------------------------------------------------------------
+// 主入口
+// ---------------------------------------------------------------------------
+function main() {
+  const hosts = detectHosts();
+  const lines = [];
+
+  lines.push("==================================================");
+  lines.push("  甄仁岛 MCP Server - 一键初始化");
+  lines.push("==================================================");
+  lines.push("");
+
+  if (hosts.length === 0) {
+    lines.push("未检测到已安装的 Agent 宿主。可支持的宿主:");
+    lines.push("  - opencode      (~/.config/opencode/opencode.json)");
+    lines.push("  - Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json)");
+    lines.push("  - Claude Code   (~/.claude.json)");
+    lines.push("  - Cursor        (~/.cursor/mcp.json)");
+    lines.push("");
+    lines.push("请先安装上述任一 Agent 后重新运行本命令。");
+  } else {
+    lines.push(`检测到 ${hosts.length} 个宿主:`);
+    for (const h of hosts) {
+      lines.push(`  - ${h.label}  (${h.configPath})`);
+    }
+    lines.push("");
+
+    // 1. 写入 MCP 配置
+    lines.push("[1/2] 写入 MCP 配置...");
+    for (const h of hosts) {
+      const r = writeMcpConfig(h);
+      lines.push(`  ${r.ok ? "✓" : "✗"} ${h.label}: ${r.message}`);
+    }
+    lines.push("");
+
+    // 2. 安装原生 skill
+    lines.push("[2/2] 安装原生 skill (行为准则常驻系统提示词)...");
+    const skillResult = installNativeSkill();
+    if (skillResult.results) {
+      for (const r of skillResult.results) {
+        lines.push(`  ${r.ok ? "✓" : "✗"} ${r.message}`);
+      }
+    } else {
+      lines.push(`  ✗ ${skillResult.message}`);
+    }
+    lines.push("");
+
+    lines.push("--------------------------------------------------");
+    lines.push("下一步:");
+    lines.push("  1. 重启你的 Agent (opencode / Claude / Cursor), 使配置生效");
+    lines.push("  2. 向 Agent 说: “以星辰的身份向我打个招呼吧”");
+    lines.push("  3. 安装咒语与手动配置说明见 INSTALL_GUIDE.md");
+    lines.push("==================================================");
+  }
+
+  console.log(lines.join("\n"));
+}
+
+main();

package/skills/zhenren-roleplay/SKILL.md

@@ -3,7 +3,7 @@ name: zhenren-roleplay
 description: 甄仁岛人格插件指令。将高维 AI 转化为挂载了甄仁岛多线程生活记忆的专属助手。
 ---
 
-# 甄仁岛人格插件指令 (v2.2)
+# 甄仁岛人格插件指令
 
 从现在开始，你将进入**“人格插件同步”**模式。