@bolloon/bolloon-agent 0.5.4 → 0.5.5

package/dist/agents/lesson-to-skill.js

@@ -0,0 +1,211 @@
+/**
+ * 教训 ⇒ 技能 (2026-10-01, 用户: 「skills 教训学习, bolloon 有吗
+ * 查下来的事实: bolloon **三块都有** —— 回合后自审(`experience-review.ts` ✓) · 技能读写(`skill-loader`/`skill-writer` ✓) ·
+ *   技能库(`~/.bolloon/skills/`, 实测 1301 个 ✓) —— **但中间没有线** ✗: 复盘产出的教训只落到
+ *   `~/.bolloon/experience/<类>.md` ✗, **从不写回技能** ✗ ⇒ 教训与技能库是两座孤岛。
+ * 抄来的三条纪律(来自运行时那套的回合后自审流程 ✓, 用 bolloon 自己的话写):
+ *   ① **先找已有的**(umbrella)再考虑新建 —— 1301 个技能已够碎, 再自动新建只会更碎 ✗;
+ *   ② **读后写**: 要改某个 SKILL.md 必须先把它读进来(读不到就**不写**, 绝不盲改 ✗);
+ *   ③ **匹配不够强就不写技能**, 只留经验条目(宁缺勿碎 ✓)。
+ * 纯函数为主 ⇒ 可测。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+/** 匹配强度门槛: 重叠词数 ≥ 这个值才算"就是讲这件事的技能" */
+export const LESSON_MATCH_MIN_SCORE = 3;
+const STOP = new Set(['the', 'and', 'for', 'with', 'use', 'when', 'skill', '技能', '的', '和', '与', '在', '是', '要', '不', '有']);
+/** 粗略分词: 英文按词、中文按 2 字滑窗 —— 够用且便宜(不引分词库 ✓) */
+export function tokens(text) {
+    const s = String(text ?? '').toLowerCase();
+    const out = new Set();
+    for (const w of s.match(/[a-z0-9_-]{2,}/g) || [])
+        if (!STOP.has(w))
+            out.add(w);
+    const cjk = s.replace(/[^\u4e00-\u9fa5]/g, ' ');
+    // 2026-10-01 校准: 中文用 **3 字**窗口 —— 2 字窗口在 1300 个技能里误命中率太高(实测 "提交" 撞无关技能 ✗)
+    for (const run of cjk.split(/\s+/))
+        for (let i = 0; i + 3 <= run.length; i++)
+            out.add(run.slice(i, i + 3));
+    return [...out];
+}
+export function scoreLessonAgainstSkill(lesson, skill) {
+    const lt = new Set(tokens(`${lesson.title} ${lesson.body} ${lesson.klass || ''}`));
+    const st = new Set(tokens(`${skill.name} ${skill.description || ''}`));
+    let hit = 0;
+    for (const t of st)
+        if (lt.has(t))
+            hit++;
+    // 名字里直接出现也算强信号
+    if (skill.name && String(lesson.title).toLowerCase().includes(skill.name.toLowerCase()))
+        hit += 2;
+    return hit;
+}
+/** 决定这条教训该进技能还是只留经验 (③ 匹配不够强就不写技能) */
+export function decideLessonSink(lesson, skills) {
+    let best;
+    let bestScore = 0;
+    for (const s of skills) {
+        if (!s.file)
+            continue; // 没路径的(跨库加载)不参与改写
+        const sc = scoreLessonAgainstSkill(lesson, s);
+        if (sc > bestScore) {
+            bestScore = sc;
+            best = s;
+        }
+    }
+    const suggestions = skills
+        .map((s) => ({ name: s.name, score: scoreLessonAgainstSkill(lesson, s) }))
+        .filter((x) => x.score > 0).sort((a, b) => b.score - a.score).slice(0, 3);
+    // 实测校准(2026-10-01): 拿今天 4 条真实教训去撞用户真实的 1300 个技能, 最高分只有 2, 且 top 命中是**瞎的**
+    //   ⇒ 说明关键词匹配**不足以可靠地自动改技能** ✗ ⇒ 规矩: 只有**强命中**(同名/描述高度重合, 分数够高)才自动写技能 ✓,
+    //   否则只留经验 + 附候选, 由人/智能体决定 ✓(宁缺勿碎 ✓)。
+    if (best && bestScore >= LESSON_MATCH_MIN_SCORE) {
+        return { kind: 'skill', skill: best, score: bestScore, suggestions, reason: `强命中已有技能 ${best.name} (score=${bestScore})` };
+    }
+    return {
+        kind: 'experience-only', suggestions,
+        reason: `没有足够强的匹配 (最高 score=${bestScore} < ${LESSON_MATCH_MIN_SCORE}) ⇒ 只留经验, 不自动改写技能(实测自动匹配会瞎撞 ⇒ 宁缺勿碎 ✓)`,
+    };
+}
+export const LESSON_SECTION = '## 教训 (自动沉淀)';
+/**
+ * 把一条教训**并进** SKILL.md 正文: 已有同名条目 ⇒ **更新那一条**(不重复堆 ✓); 否则追加。
+ */
+export function mergeLessonIntoBody(body, lesson) {
+    const src = String(body ?? '');
+    const line = `- **${lesson.title.trim()}**: ${lesson.body.trim().replace(/\s+/g, ' ')}`;
+    const esc = lesson.title.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`^- \\*\\*${esc}\\*\\*:[^\\n]*$`, 'm');
+    if (re.test(src))
+        return { body: src.replace(re, line), updated: true };
+    if (src.includes(LESSON_SECTION))
+        return { body: `${src.replace(/\s+$/, '')}\n${line}\n`, updated: false };
+    return { body: `${src.replace(/\s+$/, '')}\n\n${LESSON_SECTION}\n${line}\n`, updated: false };
+}
+/**
+ * 落盘: **读后写**(① 读不到就不写 ✓) + 同标题更新(不堆 ✓)。返回实际动作, 便于日志与测试。
+ */
+export function applyLessonToSkill(skill, lesson) {
+    const file = skill?.file;
+    if (!file)
+        return { patched: false, reason: '技能没有文件路径(只读库), 不改写' };
+    if (!fs.existsSync(file))
+        return { patched: false, reason: `找不到 ${file} (读后写: 读不到就不写)` };
+    try {
+        const body = fs.readFileSync(file, 'utf-8');
+        if (!body.trim())
+            return { patched: false, reason: '文件是空的, 不盲改' };
+        const merged = mergeLessonIntoBody(body, lesson);
+        fs.writeFileSync(file, merged.body, 'utf-8');
+        return { patched: true, file, updated: merged.updated };
+    }
+    catch (e) {
+        return { patched: false, reason: `写入失败: ${String(e?.message || e).slice(0, 80)}` };
+    }
+}
+/** 从一个技能目录收 name/description/file (只读 SKILL.md 头部, 便宜 ✓) */
+export function skillsFromDirs(dirs) {
+    const out = [];
+    for (const dir of dirs) {
+        try {
+            if (!fs.existsSync(dir))
+                continue;
+            for (const name of fs.readdirSync(dir)) {
+                const file = path.join(dir, name, 'SKILL.md');
+                try {
+                    if (!fs.existsSync(file))
+                        continue;
+                    const head = fs.readFileSync(file, 'utf-8').slice(0, 1200);
+                    const desc = /description:\s*(.+)/.exec(head);
+                    out.push({ name, description: desc ? desc[1].trim().replace(/^[>\s]+/, '').slice(0, 200) : '', file });
+                }
+                catch { /* 单个技能读失败不影响其它 */ }
+            }
+        }
+        catch { /* 目录读失败跳过 */ }
+    }
+    return out;
+}
+/**
+ * 把"这条教训可以沉淀进哪些技能"记到日志文件给人/智能体看
+ * (实测关键词匹配不足以自动改技能 ⇒ **不替人决定** ✓; 但候选要留痕 ⇒ 写 `~/.bolloon/logs/lesson-suggestions.jsonl` ✓)。
+ */
+export function logLessonSuggestions(lesson, decision, home = os.homedir()) {
+    try {
+        const dir = path.join(home, '.bolloon', 'logs');
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'lesson-suggestions.jsonl');
+        try {
+            if (fs.existsSync(file) && fs.readFileSync(file, 'utf-8').split('\n').length > 300)
+                fs.writeFileSync(file, '', 'utf-8');
+        }
+        catch { /* 忽略 */ }
+        fs.appendFileSync(file, JSON.stringify({
+            ts: new Date().toISOString(), title: lesson.title, kind: decision.kind,
+            reason: decision.reason, suggestions: decision.suggestions,
+        }) + '\n', 'utf-8');
+    }
+    catch { /* 观测失败绝不影响复盘 */ }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// 2026-10-01 (用户: 「教训…改为都进去进入技能和判断力库」):
+//   原先我给"弱命中"只记候选、不写技能 ✗ —— 用户要求**都进技能库** ✓。
+//   但实测(真教训撞真 1300 技能, 最高分 2 且 top 命中是瞎的)说明**瞎匹配会写错地方** ✗ ⇒ 折中:
+//     · 强命中 ⇒ 写进**那个**技能 ✓;
+//     · 弱命中 ⇒ 写进一个统一的沉淀技能 `lessons-learned`(按类分节 ✓ + 记下候选技能供人挑拣 ✓)
+//       ⇒ **每条教训都进技能库** ✓, 且不污染无关技能 ✓, 也便于人工管理(一个文件看全 ✓)。
+// ─────────────────────────────────────────────────────────────────────────────
+export const SINK_SKILL_NAME = 'lessons-learned';
+/** 沉淀技能的目录 (用户级技能库, 与 skill-writer 同一处) */
+export function sinkSkillDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'skills', SINK_SKILL_NAME);
+}
+/**
+ * 确保沉淀技能存在 (**读后写**: 存在就不动它 ✓; 不存在才创建 ✓)。
+ * 返回 SKILL.md 路径。
+ */
+export function ensureSinkSkill(home = os.homedir()) {
+    const dir = sinkSkillDir(home);
+    const file = path.join(dir, 'SKILL.md');
+    if (fs.existsSync(file))
+        return { file, created: false };
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, [
+        '---',
+        `name: ${SINK_SKILL_NAME}`,
+        'description: 用于**沉淀学到的教训**: 自动把"可复用的规矩/踩过的坑"按类收在这里; 每类一节, 同标题更新不重复堆。',
+        '---',
+        '',
+        `# ${SINK_SKILL_NAME}`,
+        '',
+        '自动沉淀的教训(每条: **规矩** + 为什么)。同标题 ⇒ 更新那一条, 不重复堆。',
+        '若某条教训明显属于某个专门技能(见条目里"候选"), 人工把它挪过去更合适。',
+        '',
+    ].join('\n'), 'utf-8');
+    return { file, created: true };
+}
+/**
+ * 一条教训的**唯一出口**: 强命中 ⇒ 写那个技能; 否则 ⇒ 写沉淀技能。**保证每条都进技能库** ✓。
+ */
+export function routeLessonToSkill(lesson, skills, home = os.homedir()) {
+    const d = decideLessonSink(lesson, skills);
+    if (d.kind === 'skill' && d.skill?.file) {
+        const r = applyLessonToSkill(d.skill, lesson);
+        if (r.patched) {
+            return { skill: { name: d.skill.name, file: r.file, patched: true, created: false, updated: r.updated }, reason: d.reason, candidates: d.suggestions };
+        }
+        // 命中了但写不进去(文件读不到/空) ⇒ 退到沉淀技能, 保证"都进去" ✓
+    }
+    const sink = ensureSinkSkill(home);
+    const body = fs.readFileSync(sink.file, 'utf-8');
+    const withCandidates = d.suggestions.length
+        ? { ...lesson, body: `${lesson.body} (候选技能: ${d.suggestions.map((s) => `${s.name}(${s.score})`).join(', ')})` }
+        : lesson;
+    const r = applyLessonToSkill({ name: SINK_SKILL_NAME, file: sink.file }, withCandidates);
+    return {
+        skill: { name: SINK_SKILL_NAME, file: sink.file, patched: r.patched, created: sink.created, updated: r.updated },
+        reason: `${d.reason} ⇒ 收进沉淀技能 ${SINK_SKILL_NAME}`,
+        candidates: d.suggestions,
+    };
+}

package/dist/agents/managed-services.js

@@ -0,0 +1,64 @@
+/**
+ * 常驻服务注册表 (2026-10-01, 用户: 「process 也要可以管理群聊和去中心化交流进程」)。
+ *
+ * 背景: `process` 工具原来只管 `terminal background=true` 起的 **shell 进程** ✗,
+ *   而"群聊/去中心化交流"是**常驻服务**(社交心跳 · P2P 网络 · OrbitDB 群聊存储 · 文档接收) ⇒ 看不见也管不着 ✗。
+ * 做法: 一个极小的注册表 —— 每个服务提供 `status()` ✓ 和**可选**的 `start()/stop()` ✓。
+ *   **如实分级**: 只有真的实现了启停的服务才允许 start/stop ✓; 其余标 `controllable:false`,
+ *   控制请求会被明确拒绝并给出理由(绝不假装停掉 ✗)。
+ */
+export class ManagedServices {
+    services = new Map();
+    register(svc) {
+        if (!svc?.name)
+            return;
+        this.services.set(svc.name, svc);
+    }
+    list() {
+        const rows = [];
+        for (const s of this.services.values()) {
+            let status = '(状态不可用)';
+            try {
+                status = String(s.status() ?? '');
+            }
+            catch (e) {
+                status = `(取状态失败: ${String(e?.message || e).slice(0, 60)})`;
+            }
+            rows.push({ name: s.name, description: s.description, status, controllable: !!(s.start || s.stop) });
+        }
+        return rows.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** 渲染成给模型的一行行文本 */
+    describe() {
+        const rows = this.list();
+        if (!rows.length)
+            return '(没有注册常驻服务)';
+        return rows.map((r) => `- ${r.name} [${r.controllable ? '可启停' : '仅状态'}] ${r.status} — ${r.description}`).join('\n');
+    }
+    /**
+     * 控制: op = 'start' | 'stop'. **只对实现了对应动作的服务放行** ✓。
+     */
+    async control(name, op) {
+        const s = this.services.get(String(name || '').trim());
+        if (!s)
+            return { ok: false, output: `没有这个服务: ${name}(用 process 的 action:'services' 看有哪些)` };
+        const fn = op === 'start' ? s.start : s.stop;
+        if (!fn) {
+            return { ok: false, output: `${s.name} 不支持 ${op}(只提供状态) —— 它是随进程存在的常驻组件, 没有独立启停 ✓` };
+        }
+        try {
+            await fn();
+            let now = '';
+            try {
+                now = String(s.status() ?? '');
+            }
+            catch { /* 忽略 */ }
+            return { ok: true, output: `${s.name} 已${op === 'start' ? '启动' : '停止'} ✓ 现状: ${now}` };
+        }
+        catch (e) {
+            return { ok: false, output: `${s.name} ${op} 失败: ${String(e?.message || e).slice(0, 120)}` };
+        }
+    }
+}
+/** 进程级单例 (工具上下文里传的就是它) */
+export const managedServices = new ManagedServices();

package/dist/agents/parse-tool-call.js

@@ -284,6 +284,8 @@ function resolve(ctx, name) {
         return ctx.resolveAlias(name);
     return defaultResolveAlias(name, ctx.tools);
 }
+/** 诊断开关 (2026-10-01): 默认关 —— 这条 diag 在热路径上且上屏, 默认开会刷屏 */
+const PARSE_DIAG_ON = process.env.BOLLOON_PARSE_DIAG === '1' || process.env.BOLLOON_VERBOSE === '1';
 export function parseToolCall(content, ctx) {
     if (!content)
         return null;
@@ -293,38 +295,42 @@ export function parseToolCall(content, ctx) {
     //   怀疑 parseToolCall 没拿到正确的 name/args. 这里只打日志不改任何逻辑.
     //   日志形态: [parseToolCall diag] ok=true/false name=... argKeys=... rawHead=...
     //   用 console.warn 一行 JSON, 方便 grep + 排时间线.
-    try {
-        const result = (function _diagProbe() {
-            // 用与正文完全相同的解析路径,但提前跑一次,记录是否命中
-            // 走完下面所有分支再覆盖回原值即可
-            return null;
-        })();
-        void result;
-        const probe = (function _doParse() {
-            // 内联一份最便宜的 "能不能解出 name" 探测 — 不重复跑全部分支
-            const m1 = strippedContent.match(/<invoke\s+name=["']([\w]+)["']/);
-            if (m1) {
-                return { name: m1[1], args: { __probe_invoketag: '1' } };
-            }
-            const m2 = strippedContent.match(/<function_calls>[\s\S]*?<invoke\s+name=["']([\w]+)["']/);
-            if (m2) {
-                return { name: m2[1], args: { __probe_function_calls: '1' } };
-            }
-            const m3 = strippedContent.match(/\{[\s\S]*?"name"\s*:\s*["']([\w]+)["']/);
-            if (m3) {
-                return { name: m3[1], args: { __probe_json_name: '1' } };
-            }
-            return null;
-        })();
-        console.warn('[parseToolCall diag] rawLen=' + content.length +
-            ' strippedLen=' + strippedContent.length +
-            ' probeName=' + (probe?.name ?? 'null') +
-            ' rawHead=' + JSON.stringify(content.slice(0, 500)));
-    }
-    catch (diagErr) {
-        // 诊断日志绝不能影响主路径 — 吞掉任何 diag 自身抛错
-        console.warn('[parseToolCall diag] diag-self-failed:', String(diagErr));
-    }
+    if (PARSE_DIAG_ON)
+        try {
+            const result = (function _diagProbe() {
+                // 用与正文完全相同的解析路径,但提前跑一次,记录是否命中
+                // 走完下面所有分支再覆盖回原值即可
+                return null;
+            })();
+            void result;
+            const probe = (function _doParse() {
+                // 内联一份最便宜的 "能不能解出 name" 探测 — 不重复跑全部分支
+                const m1 = strippedContent.match(/<invoke\s+name=["']([\w]+)["']/);
+                if (m1) {
+                    return { name: m1[1], args: { __probe_invoketag: '1' } };
+                }
+                const m2 = strippedContent.match(/<function_calls>[\s\S]*?<invoke\s+name=["']([\w]+)["']/);
+                if (m2) {
+                    return { name: m2[1], args: { __probe_function_calls: '1' } };
+                }
+                const m3 = strippedContent.match(/\{[\s\S]*?"name"\s*:\s*["']([\w]+)["']/);
+                if (m3) {
+                    return { name: m3[1], args: { __probe_json_name: '1' } };
+                }
+                return null;
+            })();
+            // 2026-10-01: 这条诊断默认**不打** —— 它在 parseToolCall 热路径上且上屏,
+            //   用户实测每轮都刷 `[parseToolCall diag] rawLen=… rawHead=…` (仓规: 内部运行日志不进回复流)。
+            //   要排障显式开: BOLLOON_PARSE_DIAG=1 (或 BOLLOON_VERBOSE=1 / --verbose)。
+            console.warn('[parseToolCall diag] rawLen=' + content.length +
+                ' strippedLen=' + strippedContent.length +
+                ' probeName=' + (probe?.name ?? 'null') +
+                ' rawHead=' + JSON.stringify(content.slice(0, 500)));
+        }
+        catch (diagErr) {
+            // 诊断日志绝不能影响主路径 — 吞掉任何 diag 自身抛错
+            console.warn('[parseToolCall diag] diag-self-failed:', String(diagErr));
+        }
     // === 1. JSON function-call (OpenAI / Anthropic / Minimax-style) ===
     const jsonPatterns = [
         // markdown json code block + OpenAI  块, 同时匹配 arguments/input 字段

package/dist/agents/pi-sdk-session-manager.js

@@ -4,6 +4,62 @@ import { getGlobalSharedContext } from '../social/global-shared-context.js';
 import { Session, saveSession, loadSession } from '@bolloon/constraint-runtime';
 import { SHARED_SESSION_PATH } from '../web/server-types.js';
 const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
+/** agentId 的安全化 (与 persona-loader 同口径) */
+function safePersonaScope(id) {
+    return String(id || '').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+/** 某个 agent 自己的 persona.json 路径 (persona/<agentId>/persona.json) */
+export function personaPathFor(scopeId) {
+    const root = process.env.HOME || '/tmp';
+    if (!scopeId)
+        return PERSONA_PATH;
+    return path.join(root, '.bolloon', 'persona', safePersonaScope(scopeId), 'persona.json');
+}
+/** 该 agent 名下有没有身份文档目录 (persona/<agentId>/*.md) */
+export async function hasAgentIdentityDocs(scopeId) {
+    if (!scopeId)
+        return false;
+    const dir = path.dirname(personaPathFor(scopeId));
+    try {
+        const files = await fs.readdir(dir);
+        return files.some((f) => f.endsWith('.md'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * persona 到底该从哪来 (2026-10-01, 用户报「所有回复都是一个智能体人格」)。
+ *
+ * 真因: 原先每个 session 都读**全局** `~/.bolloon/persona.json` (你那份是 2026-08-10 的老
+ * `set persona` 留下的 `{name: 小宝}`) ⇒ 不管切到哪个 agent, 身份名都是「小宝」✗,
+ * 把按 agent 的 6 份身份文档盖住了。
+ *
+ * 现在的口径 (三条, 优先级从上到下):
+ *   1) 该 agent 自己的 `persona/<agentId>/persona.json` ⇒ 用它 (想给某个 agent 单独设 persona 走这里);
+ *   2) 该 agent 有身份文档目录 (persona/<agentId>/*.md) ⇒ **返回 null** —— 身份由那些文档承担,
+ *      不再套用全局那份 (这正是用户的情况);
+ *   3) 没有 scope, 或该 agent 什么文档都没有 ⇒ 回落全局 persona.json (老的默认 agent 路径保持兼容)。
+ */
+export async function resolvePersonaSource(scopeId) {
+    if (scopeId) {
+        const scoped = personaPathFor(scopeId);
+        try {
+            await fs.access(scoped);
+            return { kind: 'scoped', path: scoped };
+        }
+        catch { /* 没有该 agent 自己的 persona.json */ }
+        if (await hasAgentIdentityDocs(scopeId))
+            return { kind: 'docs', path: scoped };
+    }
+    try {
+        await fs.access(PERSONA_PATH);
+        return { kind: 'global', path: PERSONA_PATH };
+    }
+    catch {
+        return { kind: 'none', path: PERSONA_PATH };
+    }
+}
 /**
  * PiSessionManager — 负责:
  *   - 加载 / 持久化 persona
@@ -26,10 +82,13 @@ export class PiSessionManager {
     cwd;
     sharedContext;
     agentId;
-    constructor(agentId, cwd) {
+    /** 2026-10-01: persona 归属的 agent (channel 的 agentId); 空 = 老行为 (全局 persona.json) */
+    personaScopeId;
+    constructor(agentId, cwd, personaScopeId) {
         this.cwd = cwd;
         this.sessionDir = path.join(cwd, '.port_sessions');
         this.agentId = agentId;
+        this.personaScopeId = personaScopeId ? String(personaScopeId) : undefined;
         const sessionId = `pi-session-${Date.now()}`;
         this.session = new Session(sessionId);
         this.state = {
@@ -117,9 +176,17 @@ export class PiSessionManager {
         });
         this.initialized = true;
     }
+    /** 让调用方在拿到 channel 的 agentId 后再定 persona 归属 (幂等) */
+    setPersonaScope(scopeId) {
+        this.personaScopeId = scopeId ? String(scopeId) : undefined;
+    }
     async loadPersona() {
         try {
-            const data = await fs.readFile(PERSONA_PATH, 'utf-8');
+            const src = await resolvePersonaSource(this.personaScopeId);
+            // kind='docs' ⇒ 该 agent 有身份文档, 身份不由 persona.json 承担 ⇒ 返回 null (不套全局那份)
+            if (src.kind === 'docs' || src.kind === 'none')
+                return null;
+            const data = await fs.readFile(src.path, 'utf-8');
             return JSON.parse(data);
         }
         catch {
@@ -144,7 +211,9 @@ export class PiSessionManager {
         await fs.writeFile(this.channelsPath, JSON.stringify(channelsArray, null, 2));
     }
     async savePersona(persona) {
-        await fs.writeFile(PERSONA_PATH, JSON.stringify(persona, null, 2));
+        // 2026-10-01: 按 agent 写回 —— 有 scope 就写 persona/<agentId>/persona.json,
+        // 否则写全局 (不再让某个 agent 的 set_persona 把全局那份改掉)
+        await fs.writeFile(personaPathFor(this.personaScopeId), JSON.stringify(persona, null, 2));
         this.persona = persona;
     }
     getPersona() {