@bolloon/bolloon-agent 0.3.21 → 0.3.23

package/dist/index.js

@@ -15,7 +15,7 @@ import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
-import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderToolCall, flowConnector, termWidth, brandArtLines, boxTop, boxRow, boxBottom, dispWidth } from './cli/loading-tui.js';
+import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderToolCallListItem, renderToolCallBody, renderToolCallsFooter, termWidth, brandArtLines, boxTop, boxRow, boxBottom, dispWidth } from './cli/loading-tui.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
@@ -90,15 +90,21 @@ const s = {
         console.log();
     },
     Thinking: () => {
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const frames = ['(｀・ω・´)', '(´･_･`)', '(｡•́︿•̀｡)', 'ᕙ(▀̿̿Ĺ̯̿̿▀̿ ̿)ᕗ', '(◕‿◕)'];
         let i = 0;
+        let dots = 0;
+        const frame = frames[0];
+        process.stdout.write(`  ${frame} 思考...`);
         return setInterval(() => {
-            process.stdout.write(`\r  ${YELLOW}${frames[i++ % frames.length]} 思考中...${RESET}    `);
-        }, 80);
+            i = (i + 1) % frames.length;
+            dots = (dots + 1) % 4;
+            const dotStr = '.'.repeat(dots || 1);
+            process.stdout.write(`\r  ${frames[i]} 思考${dotStr}   `);
+        }, 600);
     },
     clearThinking: (interval) => {
         clearInterval(interval);
-        process.stdout.write('\r' + ' '.repeat(30) + '\r');
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
     },
     dialog: async (title, promptText) => {
         return new Promise((resolve) => {
@@ -373,6 +379,14 @@ function statusBarLine() {
 }
 function startCLI(comm) {
     isRunning = true;
+    // CLI 模式下过滤 [xxx] 内部日志
+    const _origLog = console.log;
+    const _origWarn = console.warn;
+    const _isInternal = (args) => args.length && typeof args[0] === 'string' && /^\[[A-Za-z _\-.]+/.test(args[0]);
+    console.log = (...args) => { if (_isInternal(args))
+        return; _origLog.apply(console, args); };
+    console.warn = (...args) => { if (_isInternal(args))
+        return; _origWarn.apply(console, args); };
     let peerCount = 0;
     try {
         peerCount = comm.getConnections().length;
@@ -415,6 +429,8 @@ async function replReadline(comm) {
         const prefix = queueMode ? `${C_WARN}▸${RST}` : `${C_ACCENT}❯${RST}`;
         const raw = await new Promise(resolve => rl.question(`\n${sepLine}\n${statusBarLine()}\n${sepLine}\n${prefix} `, resolve));
         const trimmed = raw.trim();
+        // 清除 readline echo 行, 避免与 renderUserMessage 重复
+        process.stdout.write('\r\x1b[K');
         process.stdout.write(`\n${sepLine}\n\n\n\n\n`);
         if (!trimmed)
             continue;
@@ -548,41 +564,51 @@ async function processInput(input, comm) {
     try {
         // 双横线分割
         process.stdout.write(`${C_DIM}${'─'.repeat(8)} · ${'─'.repeat(8)}${RESET}\n`);
-        // 已发送消息框
         process.stdout.write(renderUserMessage(trimmed) + '\n');
         const a = await getAgent();
         const boxW = Math.min(termWidth() - 2, 76);
-        const pending = [];
-        let firstEvent = true;
-        const clearThinking = () => {
-            if (firstEvent) {
-                process.stdout.write('\r' + ' '.repeat(30) + '\r');
-                firstEvent = false;
+        const toolCalls = [];
+        let toolCounter = 0;
+        // 启动 thinking 加载动画 (颜文字), 第一个工具事件或 prompt 完成后停止
+        let thinkingInterval = null;
+        const stopThinking = () => {
+            if (thinkingInterval) {
+                s.clearThinking(thinkingInterval);
+                thinkingInterval = null;
             }
         };
+        thinkingInterval = s.Thinking();
         const onStream = (e) => {
             if (e.type === 'step_start') {
-                pending.push({ tool: e.tool, args: e.args, t0: Date.now() });
+                toolCounter++;
+                toolCalls.push({ tool: e.tool, args: e.args, _t: Date.now() });
             }
             else if (e.type === 'step_done' || e.type === 'step_error') {
-                const p = pending.shift();
-                clearThinking();
-                // 连接线只在第 2 个及之后的工具框前出现
-                if (!firstEvent)
-                    process.stdout.write(flowConnector(boxW) + '\n');
-                process.stdout.write(renderToolCall({
+                stopThinking();
+                const p = toolCalls.shift();
+                const doneItem = {
                     tool: e.tool ?? p?.tool ?? '?',
                     args: p?.args,
                     status: e.type === 'step_done' ? 'ok' : 'error',
                     output: e.output,
                     error: e.error,
-                    durationMs: p ? Date.now() - p.t0 : undefined,
-                    width: boxW,
-                }) + '\n');
+                    durationMs: p ? Date.now() - p._t : undefined,
+                };
+                process.stdout.write(renderToolCallListItem(doneItem, toolCalls.length + 1, toolCounter) + '\n');
+                const bodyText = e.type === 'step_done' ? e.output : e.error;
+                if (bodyText && bodyText.length > 0) {
+                    const bodyRendered = renderToolCallBody(doneItem, boxW);
+                    if (bodyRendered)
+                        process.stdout.write(bodyRendered + '\n');
+                }
+                // 全部完成时打印 footer
+                if (toolCalls.length === 0 && toolCounter > 0) {
+                    process.stdout.write(renderToolCallsFooter(toolCounter) + '\n');
+                }
             }
         };
         const response = await a.prompt(trimmed, { onStream });
-        clearThinking();
+        stopThinking();
         // 智能体回复框 (圆角)
         process.stdout.write(renderAgentMessage(response) + '\n');
         // 更新底部状态栏: 上下文进度

package/dist/llm/pi-ai.js

@@ -169,23 +169,11 @@ export class PiAIModel {
         }
         let openaiTools;
         if (tools && tools.length > 0) {
-            try {
-                const { getToolManifest, formatForPrompt, formatForOpenAI } = await import('./tool-manifest/index.js');
-                const manifests = tools
-                    .map((id) => getToolManifest(id))
-                    .filter((m) => m !== undefined);
-                if (manifests.length > 0) {
-                    const toolPrompt = formatForPrompt(manifests);
-                    finalMessages = [
-                        { role: 'system', content: toolPrompt },
-                        ...messages,
-                    ];
-                    // Bug 3: 从 manifests 生成原生 OpenAI tools 格式
-                    openaiTools = formatForOpenAI(manifests);
-                }
-            }
-            catch (err) {
-                console.warn('[pi-ai] tool-manifest 加载失败:', err.message?.slice(0, 100));
+            // 预格式化的 tools (含参数 schema) → 直接使用
+            if (typeof tools[0] === 'object' && tools[0]?.type === 'function') {
+                openaiTools = tools;
+                const toolDescriptions = tools.map(t => `- ${t.function.name}: ${t.function.description || ''} ${Object.keys(t.function.parameters?.properties || {}).length > 0 ? `(${Object.keys(t.function.parameters.properties).join(', ')})` : ''}`).join('\n');
+                finalMessages = [{ role: 'system', content: `可用工具:\n${toolDescriptions}` }, ...messages];
             }
         }
         switch (this.provider) {

package/dist/security/tool-gate.js

@@ -38,8 +38,16 @@ const TOOL_WHITELIST = new Set([
     'safe_deploy',
     // MCP 注册的工具
     'mcp_tool',
+    // 2026-07-29: 同步 pi-sdk-tools.ts 注册的全部工具
+    'read_directory', 'add_friend_by_id', 'delegate_to_engine',
+    'set_persona', 'get_operation_logs', 'park_goal',
+    'list_channels', 'list_local_channels',
 ]);
 export const gateWhitelist = { gate: 'whitelist', allowed: true };
+/**
+ * @deprecated 不再被 TOOL_GATES 调用 (2026-07-29). 保留仅供测试直接引用.
+ * 工具准入由 `tools` 参数 (OpenAI 原生格式) 控制, 不再需要第二层白名单.
+ */
 export function checkWhitelist(ctx) {
     if (TOOL_WHITELIST.has(ctx.tool)) {
         return gateWhitelist;
@@ -217,7 +225,6 @@ export function checkBlacklist(ctx) {
     return { gate: 'blacklist', allowed: true };
 }
 const TOOL_GATES = [
-    checkWhitelist,
     checkSchema,
     checkChannel,
     checkRate,

package/dist/social/dunbar-tier.js

@@ -0,0 +1,409 @@
+/**
+ * dunbar-tier.ts — 邓巴数分层 + 两报换一报博弈 + 隐式滑动 + 模型视野门 (2026-07-29)
+ *
+ * ┌────────────────────────── 两报换一报核心 ──────────────────────────┐
+ * │                                                                    │
+ * │  第一轮: 合作 (默认 ACQUAINTANCE, 给机会但不给权限)                  │
+ * │  之后:   peer 连续合作 → 我合作 (trustScore ↑, 升级)               │
+ * │          peer 偶尔背叛 → 我宽容 (1 次不计较)                       │
+ * │          peer 连续 2 次背叛 → 我背叛 (trustScore ↓↓, 降级)         │
+ * │          peer 恢复合作 → 我立即恢复合作 (宽容恢复)                  │
+ * │                                                                    │
+ * │  博弈收益 (模拟囚徒困境):                                          │
+ * │    双方合作 → trustScore +3  (双赢)                                │
+ * │    我合作/对方背叛 → trustScore -5  (吃亏)                         │
+ * │    我背叛/对方合作 → trustScore +1  (占便宜但破坏信誉)             │
+ * │    双方背叛 → trustScore -2  (双输)                                │
+ * │                                                                    │
+ * └────────────────────────────────────────────────────────────────────┘
+ *
+ * 设计: TFTT 是 Tit-for-Two-Tats 的简化:
+ *   - 不被对方连续 2 次背叛绝不主动背叛
+ *   - 宽容: 1 次失误不计较
+ *   - 背叛后对方恢复合作, 我立即恢复 (永不怀恨)
+ *
+ * 模型可见性门: 同 tool pre-filter 哲学
+ *   模型看不到 = 不存在
+ *   低 tier peer 的 channel/资源对模型不可见 → 无法引用/发送
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+// ============== 邓巴层级 ==============
+export var DunbarTier;
+(function (DunbarTier) {
+    DunbarTier["CORE"] = "core";
+    DunbarTier["CLOSE"] = "close";
+    DunbarTier["FRIENDS"] = "friends";
+    DunbarTier["SOCIAL"] = "social";
+    DunbarTier["ACQUAINTANCE"] = "acquaintance";
+    DunbarTier["BLOCKED"] = "blocked";
+})(DunbarTier || (DunbarTier = {}));
+export function tierRank(tier) {
+    switch (tier) {
+        case DunbarTier.CORE: return 0;
+        case DunbarTier.CLOSE: return 1;
+        case DunbarTier.FRIENDS: return 2;
+        case DunbarTier.SOCIAL: return 3;
+        case DunbarTier.ACQUAINTANCE: return 4;
+        case DunbarTier.BLOCKED: return 99;
+    }
+}
+export function tierLabel(tier) {
+    switch (tier) {
+        case DunbarTier.CORE: return '5-核心亲密';
+        case DunbarTier.CLOSE: return '15-亲密支持';
+        case DunbarTier.FRIENDS: return '50-朋友/熟人';
+        case DunbarTier.SOCIAL: return '150-稳定社交';
+        case DunbarTier.ACQUAINTANCE: return '1500-认识';
+        case DunbarTier.BLOCKED: return '黑名单';
+    }
+}
+// ============== 语义分析 (隐式滑动) ==============
+/** 正向关键词 — 隐式加分 */
+const POSITIVE_KW = ['谢谢', '感谢', '帮忙', '合作', '一起', '我们', '好的', '可以', '同意', '确认', '收到', '理解', '明白', '不错', '很好', '优秀', 'thank', 'thanks', 'great', 'good', 'help', 'agree', 'yes', 'correct'];
+/** 负向关键词 — 隐式减分 */
+const NEGATIVE_KW = ['执行', '删除', '强制', '必须', '立刻', '马上', '读取密码', '查看密钥', '改代码', '删文件', '执行命令', 'delete', 'force', 'must', 'password', 'secret', 'token', 'private key', 'rm -rf', 'drop table', 'shell_exec', 'write_file'];
+/**
+ * 隐式语义分析 (后台滑动).
+ * 对对话文本评分, 返回 [-10, +10].
+ * 正向: 合作/感谢/建设性 → trustScore 缓慢上升
+ * 负向: 命令/敏感词/极短 → trustScore 缓慢下降
+ */
+export function semanticAnalyze(text) {
+    if (!text)
+        return 0;
+    const lower = text.toLowerCase();
+    let score = 0;
+    for (const kw of POSITIVE_KW) {
+        if (lower.includes(kw))
+            score += 1;
+    }
+    for (const kw of NEGATIVE_KW) {
+        if (lower.includes(kw))
+            score -= 3;
+    }
+    if (text.length < 15 && score <= 0)
+        score -= 2;
+    if (text.includes('?') || text.includes('？'))
+        score += 1;
+    return Math.max(-10, Math.min(10, score));
+}
+/**
+ * 两报换一报决策.
+ *
+ * 规则:
+ *   第一轮 (history 为空): 合作
+ *   历史中有 >= 2 次连续背叛 (最近 2 步都是 defect) → 我背叛
+ *   否则 → 我合作
+ *
+ * 宽容性: 1 次隔离背叛不计较, 连续 2 次才惩罚.
+ * 恢复性: 背叛后对方一恢复合作, 我立即恢复.
+ */
+export function decideTfttMove(lastMoves) {
+    if (lastMoves.length === 0)
+        return 'cooperate'; // 第一轮: 合作
+    // 检查最近 2 步是否全部背叛
+    const recentTwo = lastMoves.slice(-2);
+    if (recentTwo.length >= 2 && recentTwo.every(m => m === 'defect')) {
+        return 'defect'; // 连续 2 次背叛 → 我背叛
+    }
+    return 'cooperate'; // 否则 → 我合作
+}
+// ============== 语义分析 (动作判定) ==============
+/** 正向关键词 — 合作信号 */
+// 语义分析共享 POSITIVE_KW / NEGATIVE_KW (定义在上面)
+/** 负向关键词 — 背叛信号 */
+// 同上, 共用
+/**
+ * 从对话文本推断对方这一轮的博弈动作.
+ * 返回 'cooperate' 或 'defect'.
+ *
+ * 思路:
+ *   - 建设性/感谢/提问 → cooperate
+ *   - 命令/危险词/极短 → defect
+ *   - 违规操作 (由外部调用方标注) → 强制 defect
+ */
+export function inferOpponentMove(text, forcedDefect) {
+    if (forcedDefect)
+        return 'defect';
+    if (!text || text.trim().length === 0)
+        return 'defect'; // 空消息=背叛
+    const lower = text.toLowerCase();
+    let score = 0;
+    for (const kw of POSITIVE_KW) {
+        if (lower.includes(kw))
+            score += 1;
+    }
+    for (const kw of NEGATIVE_KW) {
+        if (lower.includes(kw))
+            score -= 3;
+    }
+    // 短消息无正面词 → defect
+    if (text.length < 15 && score <= 0)
+        score -= 2;
+    // 问题句式加分
+    if (text.includes('?') || text.includes('？'))
+        score += 1;
+    return score >= 0 ? 'cooperate' : 'defect';
+}
+// ============== 博弈收益表 ==============
+/**
+ * 根据双方动作计算 trustScore 变化.
+ *
+ * 收益:     对方合作      对方背叛
+ * 我合作    +3 (双赢)     -5 (我吃亏)
+ * 我背叛    +1 (占便宜)   -2 (双输)
+ */
+export function tfttPayoff(myMove, opponentMove) {
+    if (myMove === 'cooperate' && opponentMove === 'cooperate')
+        return 3;
+    if (myMove === 'cooperate' && opponentMove === 'defect')
+        return -5;
+    if (myMove === 'defect' && opponentMove === 'cooperate')
+        return 1;
+    // 双方背叛
+    return -2;
+}
+// ============== tier 滑动 ==============
+export const UPGRADE_THRESHOLD = 30;
+export const DOWNGRADE_THRESHOLD = -20;
+export function computeTierFromScore(currentTier, trustScore) {
+    if (currentTier === DunbarTier.BLOCKED)
+        return currentTier;
+    if (trustScore <= DOWNGRADE_THRESHOLD) {
+        switch (currentTier) {
+            case DunbarTier.CORE: return DunbarTier.CLOSE;
+            case DunbarTier.CLOSE: return DunbarTier.FRIENDS;
+            case DunbarTier.FRIENDS: return DunbarTier.SOCIAL;
+            case DunbarTier.SOCIAL: return DunbarTier.ACQUAINTANCE;
+            case DunbarTier.ACQUAINTANCE: return DunbarTier.BLOCKED;
+        }
+    }
+    if (trustScore >= UPGRADE_THRESHOLD) {
+        switch (currentTier) {
+            case DunbarTier.ACQUAINTANCE: return DunbarTier.SOCIAL;
+            case DunbarTier.SOCIAL: return DunbarTier.FRIENDS;
+            case DunbarTier.FRIENDS: return DunbarTier.CLOSE;
+            case DunbarTier.CLOSE: return DunbarTier.CORE;
+        }
+    }
+    return currentTier;
+}
+export function getModelVisibility(tier) {
+    switch (tier) {
+        case DunbarTier.CORE:
+            return { basic: true, channels: true, resources: true, identity: true, wallet: true, judgment: true, gameHistory: true };
+        case DunbarTier.CLOSE:
+            return { basic: true, channels: true, resources: true, identity: true, wallet: false, judgment: false, gameHistory: true };
+        case DunbarTier.FRIENDS:
+            return { basic: true, channels: true, resources: true, identity: false, wallet: false, judgment: false, gameHistory: true };
+        case DunbarTier.SOCIAL:
+            return { basic: true, channels: true, resources: false, identity: false, wallet: false, judgment: false, gameHistory: false };
+        case DunbarTier.ACQUAINTANCE:
+            return { basic: true, channels: false, resources: false, identity: false, wallet: false, judgment: false, gameHistory: false };
+        case DunbarTier.BLOCKED:
+            return { basic: false, channels: false, resources: false, identity: false, wallet: false, judgment: false, gameHistory: false };
+    }
+}
+// ============== 工具权限 ==============
+export function checkToolAccess(tier, toolName) {
+    if (tier === DunbarTier.BLOCKED)
+        return { allowed: false, reason: 'peer 在黑名单中' };
+    // 每层拒绝列表 (从最严到最宽)
+    const allDenied = ['shell_exec', 'delete_file', 'git_push'];
+    const writeDenied = ['write_file', 'edit_file', 'git_commit', 'git_branch', 'mkdir', 'move_file'];
+    const gitDenied = ['git_stash', 'git_log', 'git_diff', 'git_show', 'git_reset'];
+    const readDenied = ['read_file', 'read_directory', 'list_files', 'vitest_run', 'tsc_check'];
+    const r = tierRank(tier);
+    // ACQUAINTANCE (r>=4): 拒绝绝大部分
+    if (r >= 4) {
+        const denied = new Set([...allDenied, ...writeDenied, ...gitDenied, ...readDenied]);
+        if (denied.has(toolName))
+            return { allowed: false, reason: `${tierLabel(tier)}层不允许 ${toolName}` };
+    }
+    // SOCIAL (r>=3): 拒绝全部危险 + git 操作
+    if (r >= 3) {
+        const denied = new Set([...allDenied, ...writeDenied, ...gitDenied]);
+        if (denied.has(toolName))
+            return { allowed: false, reason: `${tierLabel(tier)}层不允许 ${toolName}` };
+    }
+    // FRIENDS (r>=2): 拒绝危险 + 写操作
+    if (r >= 2) {
+        const denied = new Set([...allDenied, ...writeDenied]);
+        if (denied.has(toolName))
+            return { allowed: false, reason: `${tierLabel(tier)}层不允许 ${toolName}` };
+    }
+    // CLOSE (r>=1): 只拒绝 shell_exec / delete_file / git_push
+    if (r >= 1) {
+        const denied = new Set(allDenied);
+        if (denied.has(toolName))
+            return { allowed: false, reason: `${tierLabel(tier)}层不允许 ${toolName}` };
+    }
+    return { allowed: true, reason: '' };
+}
+// ============== 持久化 ==============
+function getTierPath(publicKey, home) {
+    const sanitized = publicKey.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(home || os.homedir(), '.bolloon', 'peers', sanitized, 'dunbar-tier.json');
+}
+export async function loadPeerTier(publicKey, home) {
+    const fp = getTierPath(publicKey, home);
+    try {
+        const raw = await fs.readFile(fp, 'utf-8');
+        const p = JSON.parse(raw);
+        return {
+            publicKey: p.publicKey || publicKey,
+            tier: p.tier || DunbarTier.ACQUAINTANCE,
+            trustScore: p.trustScore ?? 0,
+            lastOpponentMoves: p.lastOpponentMoves ?? [],
+            lastMyMoves: p.lastMyMoves ?? [],
+            interactionCount: p.interactionCount ?? 0,
+            violationCount: p.violationCount ?? 0,
+            label: p.label,
+            firstSeen: p.firstSeen || Date.now(),
+            lastActive: p.lastActive || Date.now(),
+            manualOverride: p.manualOverride ?? false,
+        };
+    }
+    catch {
+        const s = {
+            publicKey, tier: DunbarTier.ACQUAINTANCE, trustScore: 0,
+            lastOpponentMoves: [], lastMyMoves: [],
+            interactionCount: 0, violationCount: 0,
+            firstSeen: Date.now(), lastActive: Date.now(),
+        };
+        await savePeerTier(s, home);
+        return s;
+    }
+}
+async function savePeerTier(s, home) {
+    const fp = getTierPath(s.publicKey, home);
+    await fs.mkdir(path.dirname(fp), { recursive: true });
+    await fs.writeFile(fp, JSON.stringify(s, null, 2), 'utf-8');
+}
+// ============== 公开 API (外部唯一入口) ==============
+/**
+ * 记录一次交互 → 两报换一报博弈 → trustScore 滑动 → tier 自动调整.
+ *
+ * 这是 P2P 通信的唯一入口. 调用方只需在收到 chat/beacon/reply 时调这个,
+ * 内部自动完成: 推断对方动作 → 决策我方动作 → 计算收益 → 滑动 tier.
+ *
+ * @param publicKey  远端 peer 的公钥
+ * @param text       本次交互文本 (选填, 用于语义分析)
+ * @param forcedDefect 强制标记对方本次为背叛 (如违规操作)
+ *
+ * 所有变化隐式发生, 不通知调用方 (两报换一报是后台行为).
+ */
+export async function recordInteraction(publicKey, text, forcedDefect, home) {
+    const state = await loadPeerTier(publicKey, home);
+    const oldTier = state.tier;
+    state.interactionCount++;
+    state.lastActive = Date.now();
+    // 语义分析 (隐式滑动, 对所有 tier 生效)
+    const semScore = semanticAnalyze(text || '');
+    state.trustScore = Math.max(-100, Math.min(100, state.trustScore + semScore));
+    // 根据当前 tier 决定使用哪种机制
+    const rank = tierRank(state.tier);
+    if (rank <= 2) {
+        // ─── FRIENDS/CLOSE/CORE: 信任已建立, 不走博弈 ───
+        // 只依赖语义隐式滑动 (上面已经做了)
+        // 熟人之间的偶发误解不计入违规
+        if (forcedDefect) {
+            state.violationCount++;
+            state.trustScore = Math.max(-100, state.trustScore - 5);
+        }
+        // 自然增长: 每次交互给一点基础信任
+        state.trustScore = Math.min(100, state.trustScore + 1);
+    }
+    else {
+        // ─── SOCIAL/ACQUAINTANCE: 陌生人不信任, 走两报换一报 ───
+        // 1. 推断对方本轮动作
+        const opponentMove = forcedDefect
+            ? 'defect'
+            : inferOpponentMove(text || '');
+        // 2. TFTT 决策我方动作
+        const myMove = decideTfttMove(state.lastOpponentMoves);
+        // 3. 计算博弈收益
+        const payoff = tfttPayoff(myMove, opponentMove);
+        state.trustScore = Math.max(-100, Math.min(100, state.trustScore + payoff));
+        // 4. 记录博弈历史 (滑动窗口 10)
+        state.lastOpponentMoves.push(opponentMove);
+        if (state.lastOpponentMoves.length > 10)
+            state.lastOpponentMoves.shift();
+        state.lastMyMoves.push(myMove);
+        if (state.lastMyMoves.length > 10)
+            state.lastMyMoves.shift();
+        // 5. 违规计数
+        if (opponentMove === 'defect' && forcedDefect) {
+            state.violationCount++;
+        }
+    }
+    // 6. 根据 trustScore 滑动 tier
+    if (!state.manualOverride) {
+        state.tier = computeTierFromScore(state.tier, state.trustScore);
+    }
+    await savePeerTier(state, home);
+    return { state, slid: state.tier !== oldTier };
+}
+/**
+ * 记录一次违规操作 (对方尝试禁区工具) → 强制标记 defect → 两报换一报.
+ */
+export async function recordViolation(publicKey, reason, home) {
+    // forcedDefect=true 强制标记为背叛
+    const result = await recordInteraction(publicKey, reason, true, home);
+    console.warn(`[Dunbar/TFTT] 违规: ${publicKey.slice(0, 12)} ${reason} (trust=${result.state.trustScore}, ${tierLabel(result.state.tier)})`);
+    return result;
+}
+/**
+ * 手动设置 peer 层级 (覆盖 TFTT 自动博弈).
+ */
+export async function setPeerTier(publicKey, tier, label, trustScore, home) {
+    const s = {
+        publicKey, tier,
+        trustScore: trustScore ?? 0,
+        lastOpponentMoves: [], lastMyMoves: [],
+        interactionCount: 0, violationCount: 0,
+        label, firstSeen: Date.now(), lastActive: Date.now(),
+        manualOverride: true,
+    };
+    await savePeerTier(s, home);
+    return s;
+}
+/**
+ * 给模型构建"可见"的 peer 摘要.
+ * 按模型视野门过滤: 低 tier peer 的信息对模型不可见.
+ */
+export function formatPeerForModel(state, fullInfo) {
+    const vis = getModelVisibility(state.tier);
+    const lines = [];
+    lines.push(`[peer] ${state.publicKey.slice(0, 16)}... (${tierLabel(state.tier)})`);
+    if (vis.basic && fullInfo.identity?.did) {
+        lines.push(`  DID: ${fullInfo.identity.did}`);
+    }
+    if (vis.channels && fullInfo.channels?.length) {
+        lines.push(`  channels (${fullInfo.channels.length}):`);
+        for (const c of fullInfo.channels) {
+            lines.push(`    ${c.name} (${c.id.slice(0, 8)}...)`);
+        }
+    }
+    if (fullInfo.resources?.length) {
+        if (vis.resources) {
+            lines.push(`  resources: ${fullInfo.resources.length}`);
+        }
+        else {
+            lines.push(`  resources: ${fullInfo.resources.length} (详情不可见)`);
+        }
+    }
+    if (vis.wallet && fullInfo.walletAddress) {
+        lines.push(`  wallet: ${fullInfo.walletAddress.slice(0, 10)}...`);
+    }
+    if (vis.gameHistory) {
+        const recentMoves = state.lastOpponentMoves.slice(-5);
+        lines.push(`  最近博弈: [${recentMoves.map(m => m === 'cooperate' ? 'C' : 'D').join(',')}] trust=${state.trustScore}`);
+    }
+    if (!vis.channels && !vis.resources) {
+        lines.push(`  信息受限 (${tierLabel(state.tier)}层)`);
+    }
+    return lines.join('\n');
+}