@neomei/agent-soul-framework 4.5.7 → 4.5.14

package/.opencode/tools/read-plugin.js

@@ -46,10 +46,10 @@ function formatDangerousFileResponse(filePath, ext) {
 summarize "${filePath}" --model google/gemini-3-flash-preview
 
 【方式2 - 问答/详细分析】
-python3 skills/agent-gemini/scripts/ask_gemini.py "${filePath}" "请总结这份文件的核心内容"
+${process.platform === 'win32' ? 'python' : 'python3'} skills/agent-gemini/scripts/ask_gemini.py "${filePath}" "请总结这份文件的核心内容"
 
 【方式3 - 提取纯文本】
-python3 -c "import pdfplumber; print(''.join(p.extract_text() for p in pdfplumber.open('${filePath}').pages))"
+${process.platform === 'win32' ? 'python' : 'python3'} -c "import pdfplumber; print(''.join(p.extract_text() for p in pdfplumber.open('${filePath}').pages))"
 
 💡 推荐：方式1 最快，方式2 最灵活`;
   }
@@ -160,8 +160,8 @@ export default function ReadPlugin(ctx) {
             return `⚠️ 这是二进制文件 (${ext})，read 工具会显示乱码。
 
 建议处理方式：
-- 图片分析: python3 skills/agent-vision/scripts/vision.py "${filePath}" "描述图片内容"
-- 音视频: python3 skills/agent-hearing/scripts/hear.py "${filePath}"
+- 图片分析: ${process.platform === 'win32' ? 'python' : 'python3'} skills/agent-vision/scripts/vision.py "${filePath}" "描述图片内容"
+- 音视频: ${process.platform === 'win32' ? 'python' : 'python3'} skills/agent-hearing/scripts/hear.py "${filePath}"
 - 压缩包: unzip -l "${filePath}" 或 tar -tf "${filePath}"
 - 字体/其他: 用 file 命令查看类型`;
           }

package/.opencode/tools/search-memory.mjs

@@ -1,96 +1,315 @@
-// search-memory.mjs — 魂器记忆搜索工具
-// 让 AI 在会话中主动查询 conversation 数据库
+// search-memory.mjs — 魂器四层记忆统一搜索工具
+// 1. 短期对话 (conversations.db)
+// 2. 结构化记忆 (memories.db FTS5 + MEMORY.md)
+// 3. 知识库 (knowledge/)
+// 4. 长期记忆 (memory/long-term/)
 import { tool } from "@opencode-ai/plugin";
 import { DatabaseSync } from "node:sqlite";
 import { join } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 
 const PROJECT_DIR = process.cwd();
 const DB_PATH = join(PROJECT_DIR, "memory", "short-term", "conversations.db");
+const MEMORIES_DB = join(PROJECT_DIR, "memory", "short-term", "memories.db");
+const MEMORY_MD = join(PROJECT_DIR, "memory", "MEMORY.md");
+const LONG_TERM_DIR = join(PROJECT_DIR, "memory", "long-term");
+const KNOWLEDGE_DIR = join(PROJECT_DIR, "knowledge");
 
+// ─── Layer 5: ChromaDB 向量语义搜索 ─────────────────────
+function searchVector(query, limit = 5) {
+  try {
+    // 查找 memory_manager.py 脚本路径
+    const { execSync } = require("node:child_process");
+    const scriptsDir = join(PROJECT_DIR, "..", "agent-soul-skills", "scripts");
+    const pyScript = join(scriptsDir, "memory_manager.py");
+    if (!existsSync(pyScript)) return [];
+    
+    // 尝试找到 python3
+    let python = "python3";
+    try { execSync("python3 --version 2>&1", { timeout: 3000 }); } catch {
+      try { execSync("python --version 2>&1", { timeout: 3000 }); python = "python"; } catch {
+        return [];
+      }
+    }
+
+    const result = execSync(
+      `${python} "${pyScript}" vector-search --json "${query}"`,
+      { encoding: "utf-8", timeout: 30000, cwd: PROJECT_DIR }
+    ).trim();
+
+    if (!result || result.startsWith("[INFO]") || result.startsWith("用法")) return [];
+    
+    const parsed = JSON.parse(result);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.slice(0, limit);
+  } catch (err) {
+    // ChromaDB 不可用或未安装，静默跳过
+    return [];
+  }
+}
+// ─── Layer 1: 短期对话搜索 ─────────────────────────────
 function searchConversations(query, limit = 15) {
   if (!existsSync(DB_PATH)) return [];
-
   const db = new DatabaseSync(DB_PATH, { readOnly: true });
   try {
     return db
       .prepare(
-        "SELECT role, content, datetime(timestamp, 'unixepoch', 'localtime') as time FROM conversations WHERE content LIKE ? ORDER BY timestamp DESC LIMIT ?"
+        "SELECT role, content, datetime(timestamp, 'unixepoch', 'localtime') as time, session_id FROM conversations WHERE content LIKE ? ORDER BY timestamp DESC LIMIT ?"
       )
-      .all(%%, limit);
-  } finally {
-    db.close();
+      .all(`%${query}%`, limit);
+  } finally { db.close(); }
+}
+
+// ─── Layer 2: 结构化记忆 FTS5 搜索 ─────────────────────
+function searchStructured(query, limit = 10) {
+  if (!existsSync(MEMORIES_DB)) return [];
+  const db = new DatabaseSync(MEMORIES_DB, { readOnly: true });
+  try {
+    // 先尝试 FTS5
+    const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions_fts'").get();
+    if (hasFts) {
+      try {
+        return db.prepare(
+          "SELECT id as session_id, date, summary, participant FROM sessions_fts WHERE sessions_fts MATCH ? ORDER BY rank LIMIT ?"
+        ).all(`"${query}"*`, limit);
+      } catch {
+        // FTS5 match failed, fall through to LIKE
+      }
+    }
+    return db.prepare(
+      "SELECT id as session_id, date, summary, participant FROM sessions WHERE summary LIKE ? OR content LIKE ? LIMIT ?"
+    ).all(`%${query}%`, `%${query}%`, limit);
+  } finally { db.close(); }
+}
+
+// ─── Layer 2b: MEMORY.md 搜索 ──────────────────────────
+function searchMemoryMd(query) {
+  if (!existsSync(MEMORY_MD)) return [];
+  const content = readFileSync(MEMORY_MD, "utf-8");
+  const results = [];
+  const q = query.toLowerCase();
+  for (const line of content.split("\n")) {
+    if (line.toLowerCase().includes(q) && line.trim()) {
+      results.push(line.trim().slice(0, 200));
+    }
   }
+  return results.slice(0, 5);
 }
 
-function getRecent(limit = 10) {
-  if (!existsSync(DB_PATH)) return [];
+// ─── Layer 3: 知识库搜索 ───────────────────────────────
+function searchKnowledge(query, limit = 10) {
+  if (!existsSync(KNOWLEDGE_DIR)) return [];
+  const results = [];
+  const q = query.toLowerCase();
 
-  const db = new DatabaseSync(DB_PATH, { readOnly: true });
-  try {
-    return db
-      .prepare(
-        "SELECT role, content, datetime(timestamp, 'unixepoch', 'localtime') as time FROM conversations ORDER BY timestamp DESC LIMIT ?"
-      )
-      .all(limit);
-  } finally {
-    db.close();
+  function scanDir(dir, category = "") {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      try {
+        if (statSync(full).isDirectory()) {
+          scanDir(full, entry);
+        } else if (entry.endsWith(".md") && !entry.startsWith(".")) {
+          try {
+            const content = readFileSync(full, "utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].toLowerCase().includes(q)) {
+                results.push({
+                  file: category ? `${category}/${entry}` : entry,
+                  title: lines[0].replace(/^#+\s*/, "").slice(0, 80) || entry,
+                  snippet: lines.slice(Math.max(0, i - 1), i + 2).join(" ").slice(0, 200),
+                });
+                if (results.length >= limit) return;
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+  }
+
+  scanDir(KNOWLEDGE_DIR);
+  return results;
+}
+
+// ─── Layer 4: 长期记忆搜索 ─────────────────────────────
+function searchLongTerm(query, limit = 10) {
+  if (!existsSync(LONG_TERM_DIR)) return [];
+  const results = [];
+  const q = query.toLowerCase();
+  const files = readdirSync(LONG_TERM_DIR)
+    .filter(f => f.endsWith(".md"))
+    .sort()
+    .reverse() // newest first
+    .slice(0, 30);
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(LONG_TERM_DIR, file), "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].toLowerCase().includes(q)) {
+          results.push({
+            date: file.replace(".md", ""),
+            snippet: lines.slice(Math.max(0, i - 1), i + 2).join(" ").slice(0, 200),
+          });
+          if (results.length >= limit) return results;
+        }
+      }
+    } catch {}
   }
+  return results;
 }
 
+// ─── Plugin ────────────────────────────────────────────
 export default function SearchMemoryPlugin(ctx) {
   return {
     tool: {
+      // 统一记忆搜索 — 跨四层
       search_memory: tool({
         description:
-          "搜索历史对话记忆数据库。用于查找之前讨论过的话题、问题、决策等。调用此工具可以找到与特定关键词相关的过往对话。",
+          "【魂器四层记忆统一搜索】搜索所有记忆层：短期对话、结构化记忆、MEMORY.md、知识库、长期记忆。返回结果标注来源。用于查找历史讨论、已知事实、知识卡片等。",
         args: {
-          query: tool.schema.string().describe("搜索关键词，用于在历史对话中查找相关内容"),
-          limit: tool.schema.number().optional().describe("返回结果数量上限，默认15"),
+          query: tool.schema.string().describe("搜索关键词"),
+          limit: tool.schema.number().optional().describe("每层返回结果上限，默认10"),
         },
         async execute(args, context) {
           const query = args.query;
-          const limit = args.limit || 15;
-
+          const limit = args.limit || 10;
           if (!query) return "请提供搜索关键词";
 
-          const results = searchConversations(query, limit);
+          let output = `## 🔍 记忆搜索: "${query}"\n\n`;
 
-          if (results.length === 0) {
-            return 没有找到与 "" 相关的历史对话记录。;
+          // Layer 1
+          const conv = searchConversations(query, limit);
+          if (conv.length > 0) {
+            output += `### 💬 短期对话 (${conv.length} 条)\n\n`;
+            for (const r of conv) {
+              const emoji = r.role === "user" ? "👤" : "🤖";
+              output += `- ${emoji} [${r.time}] ${r.content.slice(0, 300)}\n`;
+            }
+            output += "\n";
           }
 
-          let output = ## 记忆搜索结果: ""\n\n找到  条相关对话:\n\n;
+          // Layer 2
+          const struct = searchStructured(query, limit);
+          if (struct.length > 0) {
+            output += `### 📋 结构化记忆 (${struct.length} 条)\n\n`;
+            for (const r of struct) {
+              output += `- 📅 ${r.date || "?"} | ${(r.summary || "").slice(0, 200)}\n`;
+            }
+            output += "\n";
+          }
+
+          // Layer 2b
+          const memMd = searchMemoryMd(query);
+          if (memMd.length > 0) {
+            output += `### 📝 MEMORY.md (${memMd.length} 条)\n\n`;
+            for (const r of memMd) {
+              output += `- ${r}\n`;
+            }
+            output += "\n";
+          }
+
+          // Layer 5: ChromaDB 向量语义搜索
+          const vec = searchVector(query, limit);
+          if (vec.length > 0) {
+            output += `### 🧬 向量语义 (${vec.length} 条)\n\n`;
+            for (const r of vec) {
+              const dist = (r.distance * 100).toFixed(1);
+              output += `- [${r.collection}] ${(r.content || "").slice(0, 200)} (相关性 ${dist}%)\n`;
+            }
+            output += "\n";
+          }
+
+          // Layer 3
+          const know = searchKnowledge(query, limit);
+          if (know.length > 0) {
+            output += `### 📚 知识库 (${know.length} 条)\n\n`;
+            for (const r of know) {
+              output += `- **${r.title}** \`${r.file}\` — ${r.snippet}\n`;
+            }
+            output += "\n";
+          }
+
+          // Layer 4
+          const lt = searchLongTerm(query, limit);
+          if (lt.length > 0) {
+            output += `### 🗄️ 长期记忆 (${lt.length} 条)\n\n`;
+            for (const r of lt) {
+              output += `- 📅 ${r.date} — ${r.snippet}\n`;
+            }
+            output += "\n";
+          }
+
+          const total = conv.length + struct.length + memMd.length + know.length + lt.length + vec.length;
+          if (total === 0) {
+            return `未找到与 "${query}" 相关的记忆。`;
+          }
+          output += `---\n共 ${total} 条结果（短期 ${conv.length} + 结构 ${struct.length + memMd.length} + 知识 ${know.length} + 长期 ${lt.length} + 向量 ${vec.length}）`;
+          return output;
+        },
+      }),
+
+      // 回顾最近对话
+      recall_memory: tool({
+        description:
+          "回顾最近的对话记忆。返回最新对话记录，帮助回忆近期讨论内容。",
+        args: {
+          limit: tool.schema.number().optional().describe("返回条数，默认15"),
+        },
+        async execute(args, context) {
+          const limit = args.limit || 15;
+          if (!existsSync(DB_PATH)) return "记忆数据库暂无记录。";
+
+          const db = new DatabaseSync(DB_PATH, { readOnly: true });
+          let results = [];
+          try {
+            results = db
+              .prepare(
+                "SELECT role, content, datetime(timestamp, 'unixepoch', 'localtime') as time, session_id FROM conversations ORDER BY timestamp DESC LIMIT ?"
+              )
+              .all(limit);
+          } finally { db.close(); }
+
+          if (results.length === 0) return "记忆数据库中暂无对话记录。";
+
+          let output = `## 🕐 最近 ${results.length} 条对话\n\n`;
           for (const r of results) {
             const emoji = r.role === "user" ? "👤" : "🤖";
-            output += ${emoji} [] \n\n---\n\n;
+            output += `${emoji} [${r.time}] ${r.content.slice(0, 400)}\n\n---\n\n`;
           }
           return output;
         },
       }),
 
-      recall_memory: tool({
+      // 知识库专项搜索
+      search_knowledge: tool({
         description:
-          "回顾最近的对话记忆。不需要关键词，返回最新的对话记录摘要，帮助回忆最近的讨论内容。",
+          "搜索魂器知识库（knowledge/ 目录）。查找 Agent 已学习的知识卡片，包括审计方法论、内控知识、会计标准等。",
         args: {
-          limit: tool.schema.number().optional().describe("返回的最近对话条数，默认10"),
+          query: tool.schema.string().describe("搜索关键词"),
+          category: tool.schema.string().optional().describe("限定知识分类，如 methodology, system, philosophy 等"),
+          limit: tool.schema.number().optional().describe("返回条数，默认10"),
         },
         async execute(args, context) {
+          const query = args.query;
           const limit = args.limit || 10;
-          const results = getRecent(limit);
+          if (!query) return "请提供搜索关键词";
 
-          if (results.length === 0) {
-            return "记忆数据库中暂无对话记录。";
-          }
+          const results = searchKnowledge(query, limit);
+          if (results.length === 0) return `知识库中未找到与 "${query}" 相关的卡片。`;
 
-          let output = ## 最近  条对话\n\n;
+          let output = `## 📚 知识库搜索: "${query}"\n\n`;
           for (const r of results) {
-            const emoji = r.role === "user" ? "👤" : "🤖";
-            output += ${emoji} [] \n\n---\n\n;
+            output += `- **${r.title}** \`${r.file}\`\n  ${r.snippet}\n\n`;
           }
+          output += `---\n共 ${results.length} 条`;
           return output;
         },
       }),
     },
   };
 }
+

package/AGENTS.md.example

@@ -17,13 +17,15 @@
 
 ## 记忆搜索
 
-```bash
-# 首选: 统一记忆搜索
-python3 scripts/memory_search.py "关键词"
+**始终优先使用以下 OpenCode 工具**（零进程开销，引擎内执行）：
 
-# FTS5 会话搜索
-python3 scripts/memory_structured.py search "关键词"
-```
+| 工具 | 用途 |
+|------|------|
+| `search_memory "关键词"` | 五层统一搜索：短期对话 + 结构化 + MEMORY.md + 知识库 + ChromaDB 语义 |
+| `recall_memory` | 回顾最近对话，了解当前上下文 |
+| `search_knowledge "关键词"` | 专项搜索知识库卡片 |
+
+在回答用户问题之前，先 `search_memory` 检查是否有相关历史信息。
 
 ---
 

package/bin/hunqi

@@ -1,2 +1,9 @@
 #!/usr/bin/env node
-import "../dist/cli/hunqi.js";
+import("../dist/cli/hunqi.js").catch(err => {
+  if (err.code === "ERR_MODULE_NOT_FOUND") {
+    console.error("❌ 构建产物缺失。请运行 npm run build 或 npm install -g @neomei/agent-soul-framework");
+  } else {
+    console.error("启动失败:", err.message);
+  }
+  process.exit(1);
+});

package/bin/hunqi-knowledge

@@ -1,2 +1,9 @@
 #!/usr/bin/env node
-import "../dist/bin/hunqi-knowledge.js";
+import("../dist/bin/hunqi-knowledge.js").catch(err => {
+  if (err.code === "ERR_MODULE_NOT_FOUND") {
+    console.error("❌ 构建产物缺失。请运行 npm run build 或 npm install -g @neomei/agent-soul-framework");
+  } else {
+    console.error("启动失败:", err.message);
+  }
+  process.exit(1);
+});

package/connectors/feishu/hooks/on-session-created.js

@@ -0,0 +1,6 @@
+// on-session-created.js — session hook (cross-platform)
+// 灵魂注入已统一由 hunqi-plugin（OpenCode 插件）处理，此脚本保留用于未来扩展
+// 环境变量: HOOK_SESSION_ID, HOOK_OPENCODE_URL
+
+const sessionId = process.env.HOOK_SESSION_ID || "?";
+console.log(`[hook:on-session-created] session=${sessionId} — 灵魂注入由 hunqi-plugin 统一处理 ✅`);

package/connectors/feishu/hooks/on-session-created.sh

@@ -1,97 +1,6 @@
 #!/usr/bin/env bash
-# on-session-created.sh — 新建 session 时注入灵魂文件（缓存优化版）
+# on-session-created.sh — session 创建事件 hook
+# 灵魂注入已统一由 hunqi-plugin（OpenCode 插件）处理，此脚本保留用于未来扩展
 # 环境变量: HOOK_SESSION_ID, HOOK_OPENCODE_URL
 
-set -e
-
-SESSION_ID="${HOOK_SESSION_ID}"
-OPENCODE_URL="${HOOK_OPENCODE_URL:-http://localhost:19876}"
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# 读取 opencode serve 密码
-OPENCODE_PASSWORD="${OPENCODE_SERVER_PASSWORD:-}"
-if [ -z "$OPENCODE_PASSWORD" ] && [ -f "$PROJECT_DIR/.env" ]; then
-    OPENCODE_PASSWORD=$(grep "^OPENCODE_SERVER_PASSWORD=" "$PROJECT_DIR/.env" | cut -d= -f2- | tr -d '"\'\'')
-fi
-
-CURL_AUTH=()
-if [ -n "$OPENCODE_PASSWORD" ]; then
-    AUTH_TOKEN=$(printf '%s:%s' 'opencode' "$OPENCODE_PASSWORD" | base64 -w 0)
-    CURL_AUTH=(-H "Authorization: Basic ${AUTH_TOKEN}")
-fi
-
-# 缓存文件路径
-SOUL_CACHE="/tmp/hunqi-soul-cache.txt"
-SOUL_FILES=(
-    "$PROJECT_DIR/soul/IDENTITY.md"
-    "$PROJECT_DIR/soul/SOUL.md"
-    "$PROJECT_DIR/soul/USER.md"
-    "$PROJECT_DIR/soul/AGENTS.md"
-)
-
-# 检查是否需要更新缓存（任一灵魂文件比缓存新）
-needs_update=false
-if [ ! -f "$SOUL_CACHE" ]; then
-    needs_update=true
-else
-    cache_mtime=$(stat -c %Y "$SOUL_CACHE" 2>/dev/null || stat -f %m "$SOUL_CACHE")
-    for f in "${SOUL_FILES[@]}"; do
-        if [ -f "$f" ]; then
-            file_mtime=$(stat -c %Y "$f" 2>/dev/null || stat -f %m "$f")
-            if [ "$file_mtime" -gt "$cache_mtime" ]; then
-                needs_update=true
-                break
-            fi
-        fi
-    done
-fi
-
-# 更新缓存
-if [ "$needs_update" = true ]; then
-    SEPARATOR=$'\n\n---\n\n'
-    SYSTEM_TEXT=""
-    for f in "${SOUL_FILES[@]}"; do
-        if [ -f "$f" ]; then
-            BASENAME=$(basename "$f")
-            CONTENT=$(cat "$f")
-            SYSTEM_TEXT="${SYSTEM_TEXT}${SEPARATOR}=== ${BASENAME} ===${SEPARATOR}${CONTENT}"
-        fi
-    done
-    # 去掉开头的分隔符
-    SYSTEM_TEXT="${SYSTEM_TEXT#${SEPARATOR}}"
-    echo "$SYSTEM_TEXT" > "$SOUL_CACHE"
-    echo "[hook] soul cache updated (${#SYSTEM_TEXT} chars)"
-fi
-
-# 从缓存读取
-SYSTEM_TEXT=$(cat "$SOUL_CACHE")
-
-if [ -z "$SYSTEM_TEXT" ]; then
-    echo "[hook:onSessionCreated] warning: soul cache is empty"
-    exit 0
-fi
-
-echo "[hook:onSessionCreated] injecting soul for session ${SESSION_ID}..."
-
-# 使用 jq 或纯 bash 构造 JSON，避免 python3 进程开销
-if command -v jq &>/dev/null; then
-    JSON_PAYLOAD=$(jq -n --arg system "$SYSTEM_TEXT" '{system: $system, noReply: true, parts: []}')
-else
-    # 纯 bash fallback（简单转义）
-    JSON_PAYLOAD="{\"system\":$(printf '%s' "$SYSTEM_TEXT" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'),\"noReply\":true,\"parts\":[]}"
-fi
-
-RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "${OPENCODE_URL}/session/${SESSION_ID}/message" \
-    -H "Content-Type: application/json" \
-    "${CURL_AUTH[@]}" \
-    -d "$JSON_PAYLOAD" 2>&1)
-
-HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-
-if [ "$HTTP_CODE" = "200" ] || [ "$HTTP_CODE" = "201" ]; then
-    echo "[hook:onSessionCreated] soul injected (${#SYSTEM_TEXT} chars) ✅"
-else
-    echo "[hook:onSessionCreated] soul injection failed: HTTP $HTTP_CODE" >&2
-    exit 1
-fi
+echo "[hook:onSessionCreated] session=${HOOK_SESSION_ID} — 灵魂注入由 hunqi-plugin 统一处理 ✅"

package/connectors/feishu/hooks/on-session-idle.js

@@ -0,0 +1,6 @@
+// on-session-idle.js — session hook (cross-platform)
+// 灵魂注入已统一由 hunqi-plugin（OpenCode 插件）处理，此脚本保留用于未来扩展
+// 环境变量: HOOK_SESSION_ID, HOOK_OPENCODE_URL
+
+const sessionId = process.env.HOOK_SESSION_ID || "?";
+console.log(`[hook:on-session-idle] session=${sessionId} — 灵魂注入由 hunqi-plugin 统一处理 ✅`);

package/connectors/feishu/hooks/on-session-idle.sh

@@ -1,59 +1,6 @@
 #!/usr/bin/env bash
-# on-session-idle.sh — session idle 时（上下文压缩后）重新注入灵魂（缓存优化版）
+# on-session-idle.sh — session idle 事件 hook
+# 灵魂注入已统一由 hunqi-plugin（OpenCode 插件）处理，此脚本保留用于未来扩展
 # 环境变量: HOOK_SESSION_ID, HOOK_OPENCODE_URL
 
-set -e
-
-SESSION_ID="${HOOK_SESSION_ID}"
-OPENCODE_URL="${HOOK_OPENCODE_URL:-http://localhost:19876}"
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# 读取 opencode serve 密码
-OPENCODE_PASSWORD="${OPENCODE_SERVER_PASSWORD:-}"
-if [ -z "$OPENCODE_PASSWORD" ] && [ -f "$PROJECT_DIR/.env" ]; then
-    OPENCODE_PASSWORD=$(grep "^OPENCODE_SERVER_PASSWORD=" "$PROJECT_DIR/.env" | cut -d= -f2- | tr -d '"\'\'')
-fi
-
-CURL_AUTH=()
-if [ -n "$OPENCODE_PASSWORD" ]; then
-    AUTH_TOKEN=$(printf '%s:%s' 'opencode' "$OPENCODE_PASSWORD" | base64 -w 0)
-    CURL_AUTH=(-H "Authorization: Basic ${AUTH_TOKEN}")
-fi
-
-# 直接使用 session-created 生成的缓存
-SOUL_CACHE="/tmp/hunqi-soul-cache.txt"
-
-if [ ! -f "$SOUL_CACHE" ]; then
-    echo "[hook:onSessionIdle] warning: soul cache not found, skipping"
-    exit 0
-fi
-
-SYSTEM_TEXT=$(cat "$SOUL_CACHE")
-
-if [ -z "$SYSTEM_TEXT" ]; then
-    echo "[hook:onSessionIdle] warning: soul cache is empty, skipping"
-    exit 0
-fi
-
-echo "[hook:onSessionIdle] re-injecting soul for session ${SESSION_ID}..."
-
-# 使用 jq 或纯 bash 构造 JSON
-if command -v jq &>/dev/null; then
-    JSON_PAYLOAD=$(jq -n --arg system "$SYSTEM_TEXT" '{system: $system, noReply: true, parts: []}')
-else
-    JSON_PAYLOAD="{\"system\":$(printf '%s' "$SYSTEM_TEXT" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'),\"noReply\":true,\"parts\":[]}"
-fi
-
-RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "${OPENCODE_URL}/session/${SESSION_ID}/message" \
-    -H "Content-Type: application/json" \
-    "${CURL_AUTH[@]}" \
-    -d "$JSON_PAYLOAD" 2>&1)
-
-HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-
-if [ "$HTTP_CODE" = "200" ] || [ "$HTTP_CODE" = "201" ]; then
-    echo "[hook:onSessionIdle] soul re-injected (${#SYSTEM_TEXT} chars) ✅"
-else
-    echo "[hook:onSessionIdle] soul re-injection failed: HTTP $HTTP_CODE" >&2
-fi
+echo "[hook:onSessionIdle] session=${HOOK_SESSION_ID} — 灵魂注入由 hunqi-plugin 统一处理 ✅"

package/connectors/feishu/scripts/session-cleanup.sh

@@ -6,7 +6,14 @@
 set -e
 
 SESSIONS_FILE="${HOME}/.config/opencode/feishu-sessions.json"
-DB_FILE="${HOME}/.local/share/opencode/opencode.db"
+# Cross-platform DB path
+if [ -d "${HOME}/Library/Application Support/opencode" ]; then
+    DB_FILE="${HOME}/Library/Application Support/opencode/opencode.db"
+elif [ -d "${HOME}/.local/share/opencode" ]; then
+    DB_FILE="${HOME}/.local/share/opencode/opencode.db"
+else
+    DB_FILE="${HOME}/.local/share/opencode/opencode.db"
+fi
 MAX_MESSAGES="${MAX_MESSAGES_PER_SESSION:-50}"
 
 if [ ! -f "$SESSIONS_FILE" ]; then
@@ -23,7 +30,7 @@ fi
 SESSIONS=$(cat "$SESSIONS_FILE")
 
 # 使用单一 Python 脚本安全处理所有操作，避免注入
-python3 - "$SESSIONS_FILE" "$DB_FILE" "$MAX_MESSAGES" <<'PYEOF'
+(python3 2>/dev/null || python 2>/dev/null) - "$SESSIONS_FILE" "$DB_FILE" "$MAX_MESSAGES" <<'PYEOF'
 import json, sqlite3, sys, os
 
 sessions_file = sys.argv[1]
@@ -64,9 +71,4 @@ try:
 finally:
     conn.close()
 PYEOF
-
-if [ "$CLEANED" -gt 0 ]; then
-    echo "[session-cleanup] Cleaned $CLEANED session(s), next message will create new session"
-else
-    echo "[session-cleanup] All sessions are within limit ($MAX_MESSAGES messages)"
-fi
+# Note: Python script above handles all output and exit codes directly

package/connectors/feishu/stop.sh

@@ -9,6 +9,18 @@ if [ -f "$PROJECT_DIR/.env" ]; then
     set -a && source "$PROJECT_DIR/.env" && set +a
 fi
 
+# 跨平台端口PID查询 (lsof > ss > netstat)
+get_pid_on_port() {
+  local port="$1"
+  if command -v lsof &>/dev/null; then
+    lsof -iTCP:"$port" -sTCP:LISTEN -t 2>/dev/null | head -1
+  elif command -v ss &>/dev/null; then
+    ss -tlnp 2>/dev/null | grep ":$port " | sed -n "s/.*pid=\([0-9]*\).*/\1/p" | head -1
+  elif command -v netstat &>/dev/null; then
+    netstat -tlnp 2>/dev/null | grep ":$port " | awk "{print \$NF}" | cut -d/ -f1 | head -1
+  fi
+}
+
 # 自动检测 opencode-feishu 启动方式
 resolve_opencode_feishu() {
     if command -v opencode-feishu &>/dev/null; then