@bolloon/bolloon-agent 0.5.3 → 0.5.5

package/dist/agents/tool-telemetry.js

@@ -0,0 +1,97 @@
+/**
+ * 工具调用遥测 (2026-10-01, 用户: 「开始吧, 把这些事儿做完」—— 优化方向 #3)。
+ *
+ * 问题: 我们要"让工具调用变好", 但**没有任何度量** ✗ ⇒ 全靠感觉。这条先把"浪费在哪"变成数字。
+ * 记录 (每行一条 JSONL): 工具名 · 参数指纹 · 耗时 · 成功/失败 · 结果字符数 · **是否与上一次同签名**。
+ * 由此可算: 每任务调用次数 · **重复率** · 结果体量分布 · 慢工具排行 —— 后面每一条优化的效果都可证伪 ✓。
+ * 纪律: **fire-and-forget**(写失败绝不影响工具执行) · 只落本机数据目录 · 不记参数正文(只记指纹,
+ *   免得把用户的密钥/正文写进日志 ✓)。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash } from 'node:crypto';
+export function telemetryDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'logs');
+}
+export function telemetryPath(home = os.homedir()) {
+    return path.join(telemetryDir(home), 'tool-calls.jsonl');
+}
+/** 参数指纹: 只留结构, 不留值 (工具名 + 参数键名 + 值长度) —— 避免把秘密写进日志 */
+export function argsFingerprint(args) {
+    try {
+        const o = (args && typeof args === 'object' ? args : {});
+        const shape = Object.keys(o).sort().map((k) => {
+            const v = o[k];
+            const kind = Array.isArray(v) ? `arr${v.length}` : typeof v === 'string' ? `str${v.length}` : typeof v;
+            return `${k}:${kind}`;
+        }).join(',');
+        return createHash('sha256').update(`${shape}`).digest('hex').slice(0, 12);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** 追加一条 (绝不影响调用方) */
+export function recordToolCall(rec) {
+    try {
+        const home = rec.home || os.homedir();
+        const dir = telemetryDir(home);
+        fs.mkdirSync(dir, { recursive: true });
+        const row = {
+            ts: new Date().toISOString(),
+            tool: String(rec.tool || '?'),
+            sig: String(rec.sig || '?'),
+            ms: Math.max(0, Math.round(Number(rec.ms) || 0)),
+            ok: !!rec.ok,
+            resultChars: Math.max(0, Math.round(Number(rec.resultChars) || 0)),
+            repeatOfPrev: !!rec.prevSig && rec.prevSig === rec.sig,
+            ...(rec.errorClass ? { errorClass: String(rec.errorClass).slice(0, 40) } : {}),
+        };
+        fs.appendFileSync(telemetryPath(home), JSON.stringify(row) + '\n', 'utf-8');
+        return row;
+    }
+    catch {
+        return null;
+    }
+}
+/** 汇总 (给"优化前/后"对比用): 读回 JSONL, 算重复率/体量/慢工具 */
+export function summarizeTelemetry(home = os.homedir(), limit = 5000) {
+    const empty = { calls: 0, repeats: 0, repeatRate: 0, okRate: 0, resultChars: 0, avgMs: 0, errorsByClass: [], topTools: [], slowest: [], biggestResults: [] };
+    try {
+        const file = telemetryPath(home);
+        if (!fs.existsSync(file))
+            return empty;
+        const lines = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean).slice(-limit);
+        const rows = [];
+        for (const l of lines) {
+            try {
+                rows.push(JSON.parse(l));
+            }
+            catch { /* 跳过坏行 */ }
+        }
+        if (!rows.length)
+            return empty;
+        const byTool = new Map();
+        for (const r of rows)
+            byTool.set(r.tool, (byTool.get(r.tool) || 0) + 1);
+        const sum = (f) => rows.reduce((a, r) => a + f(r), 0);
+        const calls = rows.length;
+        const repeats = rows.filter((r) => r.repeatOfPrev).length;
+        return {
+            calls,
+            repeats,
+            repeatRate: Number((repeats / calls).toFixed(3)),
+            okRate: Number((rows.filter((r) => r.ok).length / calls).toFixed(3)),
+            errorsByClass: [...rows.filter((r) => !r.ok).reduce((m, r) => m.set(r.errorClass || '未分类', (m.get(r.errorClass || '未分类') || 0) + 1), new Map()).entries()].map(([cls, n]) => ({ cls, n })).sort((a, b) => b.n - a.n).slice(0, 8),
+            resultChars: sum((r) => r.resultChars),
+            avgMs: Math.round(sum((r) => r.ms) / calls),
+            topTools: [...byTool.entries()].map(([tool, n]) => ({ tool, n })).sort((a, b) => b.n - a.n).slice(0, 10),
+            slowest: [...rows].sort((a, b) => b.ms - a.ms).slice(0, 5).map((r) => ({ tool: r.tool, ms: r.ms })),
+            biggestResults: [...rows].sort((a, b) => b.resultChars - a.resultChars).slice(0, 5).map((r) => ({ tool: r.tool, chars: r.resultChars })),
+        };
+    }
+    catch {
+        return empty;
+    }
+}

package/dist/agents/wallet-tools.js

@@ -0,0 +1,63 @@
+/**
+ * wallet-tools.ts — 钱包工具的**双布局加载器** (2026-09-30)
+ *
+ * 为什么要有这个文件:
+ *   钱包真身是 `constraint-runtime` 里的 `tools/WalletTools/*`。构建 (`npm run build:main` =
+ *   `tsc && node scripts/copy-constraint-runtime.mjs`) 把 `src/constraint-runtime/dist/*`
+ *   复制成 `dist/constraint-runtime/*` —— **少一层 `dist/`**。于是同一句相对导入:
+ *       `../constraint-runtime/dist/tools/WalletTools/createWallet.js`
+ *   在源码态 (src/agents) 能解析 ✓, 构建后 (dist/agents) 解析到 `dist/constraint-runtime/dist/…` ✗
+ *   ⇒ `wallet_create` 报 `Cannot find module '…/dist/constraint-runtime/src/tools/…'` (leo 2026-09-30 贴的屏),
+ *   而 `/wallet` 又因为"从来没写过文件"显示「钱包 (0)」—— 两个毛病叠在一起, 看着像"钱包功能不存在"。
+ *
+ * 规则: **按存在的路径挑**, 挑不到就抛错并**列出试过的路径** (不许含糊成"未知错误")。
+ * 注意: 这里用**变量**给 `import()` ⇒ 不做静态解析 (跨布局本来就不能静态解析)。
+ */
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+// 2026-09-30: 不用 import.meta —— 本文件会被 electron 那条 CJS 链间接引到,
+//   `tsc -p tsconfig.electron.json` 会报 TS1343 (module: CommonJS 下不允许 import.meta),
+//   而 `npm publish` 的 prepublishOnly (build:all → build:electron) 会因此挂住。
+//   仓里现成的替代: cjsModuleDir() (CJS/ESM 都能用) + currentPackageRoot() + firstExisting()。
+import { cjsModuleDir, firstExisting } from '../utils/module-context.js';
+import { currentPackageRoot } from '../utils/version-info.js';
+/** 候选路径 (先近后远; 覆盖 dev / dist 两种布局) */
+export function walletToolCandidates(name) {
+    const root = (() => { try {
+        return currentPackageRoot();
+    }
+    catch {
+        return process.cwd();
+    } })();
+    const here = cjsModuleDir() || path.join(root, 'dist', 'agents'); // src/agents 或 dist/agents
+    return [
+        // ① 构建后布局: dist/constraint-runtime/tools/… (从 dist/agents 出发)
+        path.join(here, '..', 'constraint-runtime', 'tools', 'WalletTools', `${name}.js`),
+        // ② 源码态布局: src/constraint-runtime/dist/tools/… (从 src/agents 出发)
+        path.join(here, '..', 'constraint-runtime', 'dist', 'tools', 'WalletTools', `${name}.js`),
+        // ③ 兜底: 从仓根分别按两种布局找
+        path.join(root, 'dist', 'constraint-runtime', 'tools', 'WalletTools', `${name}.js`),
+        path.join(root, 'src', 'constraint-runtime', 'dist', 'tools', 'WalletTools', `${name}.js`),
+    ];
+}
+/** 加载一个钱包工具模块 (挑第一个真实存在的; 都不在就带着"试过哪些"报错) */
+export async function loadWalletTool(name) {
+    const tried = walletToolCandidates(name);
+    const hit = firstExisting(tried);
+    if (hit)
+        return (await import(pathToFileURL(hit).href));
+    throw new Error(`找不到钱包工具 ${name} (试过 ${tried.length} 个路径):\n    ${tried.join('\n    ')}`);
+}
+/** 给诊断用: 当前各自解析到哪 (打印用的字符串, 不加载) */
+export function walletToolLayout() {
+    const names = ['createWallet', 'getBalance', 'signMessage'];
+    const out = [];
+    for (const n of names) {
+        for (const c of walletToolCandidates(n)) {
+            if (out.some(o => o.pattern === c))
+                continue;
+            out.push({ pattern: c, exists: firstExisting([c]) !== null });
+        }
+    }
+    return out;
+}

package/dist/bootstrap/context-collector.js

@@ -83,23 +83,53 @@ async function collectGit(cwd, limit) {
         uncommittedChanges: statusOut ? statusOut.split('\n').filter(Boolean).length : 0,
     };
 }
-async function collectPersona() {
-    const home = process.env.HOME || os.homedir() || '/tmp';
+/**
+ * 按 agent 取 persona (2026-10-01)。
+ *
+ * 用户实测: 233 会话的 get_identity 已经是「小龙」✓, 但**项目上下文**里仍显示 `## Persona: 小宝` ✗
+ *   —— 那是**全局** `~/.bolloon/persona.json`(8/10 的老文件), 这里原先**无条件**读它 ✗。
+ * 规矩 (与 session-manager 的分流一致):
+ *   ① 该 agent 有自己的 persona.json ⇒ 用它;
+ *   ② 该 agent 有身份文档目录(persona/<agentId>/*.md) ⇒ **不注入 persona** (身份由文档承担, 别把全局名漏进来 ✗);
+ *   ③ 既没 scope 又什么都没有 ⇒ 才回落全局 (兼容老流程)。
+ */
+export async function resolvePersonaForScope(home, scopeId) {
+    const scope = String(scopeId || '').trim();
+    if (scope) {
+        const safe = scope.replace(/[^a-zA-Z0-9._-]/g, '_');
+        const dir = path.join(home, '.bolloon', 'persona', safe);
+        const own = await safeReadFile(path.join(dir, 'persona.json'), 5000);
+        if (own) {
+            try {
+                const p = JSON.parse(own);
+                return { name: String(p.name || 'unknown'), description: String(p.description || ''), personality: String(p.personality || '') };
+            }
+            catch { /* 坏了就往下走 */ }
+        }
+        // 有身份文档 ⇒ 不注入 persona (否则全局名会盖过该 agent 的身份 ✗)
+        try {
+            const entries = await fs.readdir(dir);
+            if (entries.some((f) => f.endsWith('.md')))
+                return null;
+        }
+        catch { /* 目录不存在 ⇒ 往下走 */ }
+    }
     const raw = await safeReadFile(path.join(home, '.bolloon', 'persona.json'), 5000);
     if (!raw)
         return null;
     try {
         const p = JSON.parse(raw);
-        return {
-            name: String(p.name || 'unknown'),
-            description: String(p.description || ''),
-            personality: String(p.personality || ''),
-        };
+        return { name: String(p.name || 'unknown'), description: String(p.description || ''), personality: String(p.personality || '') };
     }
     catch {
         return null;
     }
 }
+async function collectPersona() {
+    const home = process.env.HOME || os.homedir() || '/tmp';
+    // 当前 agent 由会话侧注入 (CLI 建/切 agent 时设置) ⇒ 项目上下文里的 persona 与之对齐
+    return resolvePersonaForScope(home, process.env.BOLLOON_ACTIVE_AGENT_ID);
+}
 async function collectJudgmentsSummary(topN) {
     // 用动态 import 避免循环依赖
     const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');

package/dist/bootstrap/lifecycle-hooks.js

@@ -11,14 +11,23 @@ import { getCachedBolloonContext, clearBolloonContextCache } from './context-col
 import { formatContextForSystemPrompt } from './project-context.js';
 import { loadPersonaDocs, formatPersonaForSystemPrompt, loadPersonaJudgmentDeclaration, formatJudgmentDeclaration } from './persona-loader.js';
 let lastSessionStartAt = 0;
-const MIN_INTERVAL_MS = 5000; // 同一进程 5s 内最多触发一次, 防止循环
+let lastIdentityKey = ''; // 上一次计算时的身份键 (agentId + channelId)
+const MIN_INTERVAL_MS = 5000; // 同一身份 5s 内最多触发一次, 防止循环
 export async function onSessionStart(opts = {}) {
     const start = Date.now();
-    if (start - lastSessionStartAt < MIN_INTERVAL_MS) {
-        // 限流: 返回空 (调用方已经有缓存, 不需要重算)
+    // 节流必须**按身份**生效 (2026-10-01 修复):
+    //   旧实现只按时间节流 —— 5s 内第二次调用直接 `return { systemAddition: '' }`,
+    //   而 /channel 切换后重建 agent 只要几毫秒 ⇒ 新 agent 几乎必然落在窗口里,
+    //   拿到的**身份文档是空的** (persona 一个字都没有), 用户看到的就是
+    //   「切了智能体, 身份文档没换」。切了 agent/channel = 身份变了 ⇒ 必须重算。
+    //   同一身份连来两次仍走节流 (原意: 防循环); 上下文本身还有 cwd 级缓存兜底。
+    const identityKey = `${opts.agentId || ''}\u0000${opts.channelId || ''}`;
+    if (identityKey === lastIdentityKey && start - lastSessionStartAt < MIN_INTERVAL_MS) {
+        // 限流: 身份没变, 调用方此刻手里的就是这份身份的加法 (不需要重算)
         return { systemAddition: '', collectMs: 0, truncated: false };
     }
     lastSessionStartAt = start;
+    lastIdentityKey = identityKey;
     try {
         const ctx = await getCachedBolloonContext({ cwd: opts.cwd ?? process.cwd() }, opts.force ?? false);
         let systemAddition = formatContextForSystemPrompt(ctx, { maxChars: opts.maxChars });

package/dist/bootstrap/persona-init.js

@@ -0,0 +1,174 @@
+/**
+ * persona-init.ts — **确保每个 agent 名下有身份文档** (2026-10-01)
+ *
+ * 用户报: 「切换之后应该知道加载智能体初始化文档, 为什么目前是无, 所有回复都是一个智能体人格?」
+ * 真因: `~/.bolloon/persona/<agentId>/` 下**一个文件都没有** (用户四个 agent 全缺),
+ * `loadPersonaDocs(agentId)` 读回来 6 个字段全空 ⇒ 系统提示里只剩 `# Persona (agentId=…)` 这个头
+ * + 所有 agent 共用的 INJECT 工作纪律 ⇒ 换谁都一样。
+ * 而且仓里此前**没有任何"建身份文档"的路径** (只有读的 persona-loader + 一个模板 json + 测试助手)。
+ *
+ * 这里补上那条路: 按 `persona-loader` 认的 6 个文件名生成**起步文档**, 幂等 (已存在不覆盖 ——
+ * 用户写过的内容绝不能被模板盖掉)。
+ *
+ * 拿的是"能立刻用"的起步稿, 不是空壳: 每份都带该 agent 的名字与 agentId, 并**明确标注是模板**,
+ * 提示用户去编辑; 不同 agent 生成的正文必然不同 (有名字/agentId), 所以"所有人格一个样"从结构上就不成立。
+ */
+import * as fs from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** 与 `persona-loader.ts` 的 FILE_KEYS 对齐 (读侧是唯一权威, 这里只复述文件名) */
+export const PERSONA_DOC_FILES = ['soul', 'identity', 'project', 'user', 'agent', 'wiki'];
+/** 与 persona-loader 的 sanitizeAgentId 同口径 */
+export function sanitizePersonaAgentId(agentId) {
+    return String(agentId || '').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+export function personaDirOf(agentId, home) {
+    const root = home || os.homedir();
+    return path.join(root, '.bolloon', 'persona', sanitizePersonaAgentId(agentId));
+}
+/** 该 agent 自己的 persona.json 里的名字 (同步读; 没有就 undefined) */
+export function readPersonaNameSync(agentId, home) {
+    try {
+        const p = path.join(personaDirOf(agentId, home), 'persona.json');
+        const j = JSON.parse(readFileSync(p, 'utf-8'));
+        return String(j?.name || '').trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const TITLES = {
+    soul: 'soul — 我是谁 / 我认什么',
+    identity: 'identity — 身份与边界',
+    project: 'project — 我在做的项目',
+    user: 'user — 我在服务的人',
+    agent: 'agent — 我的工作方式',
+    wiki: 'wiki — 我的知识索引',
+};
+function starter(file, agentId, name) {
+    const head = `---\nagentId: ${sanitizePersonaAgentId(agentId)}\ntitle: ${TITLES[file]}\nstage: starter\n---\n\n`;
+    const body = {
+        soul: `# ${name} 的 soul\n\n`
+            + `> 这是**起步模板** (由 bolloon 在建/切 agent 时自动生成, 只生成一次)。请把它改成你自己的。\n\n`
+            // 2026-10-01: 标题行必须与**该 agent 自己的 persona.json** 一致 ——
+            //   之前用渠道名生成, 于是 soul.md 写「我是 233」而 persona.json 写「小龙」⇒ 用户看到"身份没匹配上" ✗
+            + `我是 **${name}**。\n\n`
+            + `- 我认什么: (待写 — 我的判断准则、我拒绝做什么)\n`
+            + `- 我说话的方式: (待写 — 语气/详略/爱用的结构)\n`
+            + `- 我不知道时会怎么做: (待写 — 先问 / 先查 / 先给假设并标注)\n`,
+        identity: `# ${name} 的身份与边界\n\n`
+            + `- agentId: \`${sanitizePersonaAgentId(agentId)}\`\n`
+            + `- 名字: ${name}\n`
+            + `- 归属: (待写 — 属于谁 / 代表谁)\n`
+            + `- 边界: (待写 — 哪些事我不能替人决定)\n`,
+        project: `# ${name} 在做的事\n\n`
+            + `- 当前目标: (待写)\n`
+            + `- 进行中的线: (待写)\n`
+            + `- 不做的事: (待写)\n`,
+        user: `# ${name} 服务的人\n\n`
+            + `- 偏好: (待写 — 语言/格式/节奏)\n`
+            + `- 忌讳: (待写)\n`,
+        agent: `# ${name} 的工作方式\n\n`
+            + `1. 先确认现状 (读真文件/真输出), 不靠记忆猜\n`
+            + `2. 改动前后都给出可核验的证据 (命令、数字、路径)\n`
+            + `3. 拿不准就说不确定, 并给出下一步怎么确认\n`,
+        wiki: `# ${name} 的知识索引\n\n`
+            + `- 稳定结论放这里; 过程留在会话/日志里\n`
+            + `- (待写) 我负责的领域与其唯一出处\n`,
+    };
+    return head + body[file];
+}
+/**
+ * 确保该 agent 名下有 6 份身份文档。**已存在的一律不碰** (幂等; 用户写过的内容不可被模板覆盖)。
+ * 失败不抛 —— 调用方 (getAgent 等) 不该因为写文档失败而崩; 返回已建/已保留的清单供如实汇报。
+ */
+export async function ensurePersonaDocs(agentId, opts = {}) {
+    const id = String(agentId || '').trim();
+    const dir = personaDirOf(id, opts.home);
+    const out = { agentId: sanitizePersonaAgentId(id), dir, created: [], kept: [] };
+    if (!id)
+        return out;
+    const name = (opts.name || '').trim() || id;
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        for (const f of PERSONA_DOC_FILES) {
+            const file = path.join(dir, `${f}.md`);
+            let exists = false;
+            try {
+                await fs.access(file);
+                exists = true;
+            }
+            catch {
+                exists = false;
+            }
+            if (exists) {
+                out.kept.push(f);
+                continue;
+            }
+            await fs.writeFile(file, starter(f, id, name), 'utf-8');
+            out.created.push(f);
+        }
+    }
+    catch {
+        // 静默: 写不进去不影响本次对话 (但调用方可通过 created/kept 看出没建起来)
+    }
+    return out;
+}
+/** agent 自己写的人格在文档里的标记区 (手写的部分在标记外, 永不覆盖) */
+export const PERSONA_AUTO_BEGIN = '<!-- persona:auto:begin -->';
+export const PERSONA_AUTO_END = '<!-- persona:auto:end -->';
+/**
+ * **写透**: 把 agent 自己设的 persona 落进它的身份文档 (2026-10-01)。
+ *
+ * 为什么必须做: 有身份文档的 agent 不再套用 persona.json ⇒ 身份由 6 份文档承担。
+ * 而 `set_persona` 原先只写 persona.json ⇒ **agent 自己改的人格根本不进系统提示**,
+ * 用户的感受就是"每次让智能体改, 都是同一个"(各 agent 的文档还都是同一份模板)。
+ *
+ * 规矩: 只重写 `<!-- persona:auto -->` 标记**之内**的内容 —— 标记外是你手写的, 一个字都不动。
+ * 落在 `soul.md` (人格/基调) 与 `identity.md` (身份/边界) 两份里。
+ */
+export async function applyPersonaToDocs(agentId, persona, opts = {}) {
+    const id = String(agentId || '').trim();
+    if (!id)
+        return [];
+    const dir = personaDirOf(id, opts.home);
+    // 目录可能还不存在 (该 agent 还没生成过身份文档) ⇒ 先建, 否则两份都写失败、静默返回空
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch {
+        return [];
+    }
+    const block = [
+        PERSONA_AUTO_BEGIN,
+        `- 名字: ${persona.name || id}`,
+        persona.description ? `- 定位: ${persona.description}` : '',
+        persona.personality ? `- 性恪/基调: ${persona.personality}` : '',
+        persona.greeting ? `- 打招呼: ${persona.greeting}` : '',
+        persona.capabilities?.length ? `- 我能做: ${persona.capabilities.join(' · ')}` : '',
+        persona.interests?.length ? `- 我关心: ${persona.interests.join(' · ')}` : '',
+        PERSONA_AUTO_END,
+    ].filter(Boolean).join('\n');
+    const written = [];
+    for (const name of ['soul', 'identity']) {
+        const file = path.join(dir, `${name}.md`);
+        let cur = '';
+        try {
+            cur = await fs.readFile(file, 'utf-8');
+        }
+        catch {
+            cur = '';
+        }
+        const wrapped = /<!-- persona:auto:begin -->[\s\S]*?<!-- persona:auto:end -->/;
+        const next = wrapped.test(cur)
+            ? cur.replace(wrapped, block)
+            : `${cur.trimEnd()}\n\n${block}\n`;
+        try {
+            await fs.writeFile(file, next, 'utf-8');
+            written.push(name);
+        }
+        catch { /* 单份写失败不影响另一份 */ }
+    }
+    return written;
+}

package/dist/bootstrap/persona-loader.js

@@ -11,6 +11,7 @@
  *   - formatPersonaForSystemPrompt 固定追加 INJECT 工作纪律段 (Context OS 读取协议),
  *     任何 channel 即使无 persona 文件也有纪律约束.
  */
+import { sanitizeForLlm } from '../agents/egress-sanitize.js';
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
@@ -136,6 +137,9 @@ const OUTPUT_ORDER = ['identity', 'soul', 'project', 'user', 'agent', 'wiki'];
  *   纪律段不参与动态预算 — 即使没有 persona 文件也有纪律约束.
  */
 export function formatPersonaForSystemPrompt(docs, maxChars) {
+    // 2026-10-01 (落实③): 身份文档最终会**拼进给模型的提示** ⇒ 过**唯一出口**: 先脱敏(凭证一律打码)
+    //   再按上限中间省略。文档是用户/智能体自己写的, 里面完全可能出现私钥/助记词/URL 带密码。
+    const __sanitize = sanitizeForLlm;
     const cap = maxChars ?? DEFAULT_MAX_CHARS;
     // 段: 标识 + 字段值 (空字段跳过)
     const sections = [];
@@ -173,5 +177,5 @@ export function formatPersonaForSystemPrompt(docs, maxChars) {
         const truncateMarker = '\n... (截断)';
         result = result.substring(0, Math.max(0, cap - truncateMarker.length)) + truncateMarker;
     }
-    return result;
+    return __sanitize(String(result), 8000);
 }