@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/agents/subagent-manager.js

@@ -1,5 +1,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+// 2026-09-25 (M3 接缝): 换人必须重签合同的判据只有一份 (纯函数, 零 I/O)
+import { childMatchesContract } from './goal-flywheel/wiring/contract.js';
 const DEFAULT_STORAGE_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'agents');
 const DEFAULT_TASK_TIMEOUT_MS = 5 * 60 * 1000;
 const DEFAULT_MAX_CONCURRENT_TASKS = 10;
@@ -160,10 +162,36 @@ export class SubAgentManager {
     async assignTask(taskId, toAgentId) {
         const task = this.tasks.get(taskId);
         if (task) {
+            // 2026-09-25 (M3): 挂着工作合同的任务 **不许换人而不换合同**。
+            //   合同把 `childAgentId` 钉死了 (回报核验要求 report.childAgentId === contract.childAgentId),
+            //   把同一份合同指给另一个子 Agent ⇒ 新子的回报必然对不上合同, 合规判定整个失效。
+            //   换人的正确做法是**重新派遣** (父侧 signed 新合同) —— 本方法只维护指派关系, 无权签合同,
+            //   所以这里如实拒绝并留痕, 而不是"改了字段就当换成了"。
+            if (task.goalId && task.workId) {
+                const contract = (task.metadata?.workContract ?? null);
+                if (!contract) {
+                    task.reassignRefused = {
+                        code: 'contract_unreadable',
+                        reason: `任务 ${taskId} 挂着 workId=${task.workId} 却读不到合同 → 无法判断新执行者是否与原合同一致, 拒绝换人 (先重签合同)`,
+                    };
+                    await this.saveTasks();
+                    this.notifyTaskListeners(task);
+                    return;
+                }
+                const same = childMatchesContract(contract, toAgentId);
+                if (!same.ok) {
+                    task.reassignRefused = { code: 'requires_new_contract', reason: same.reason };
+                    await this.saveTasks();
+                    this.notifyTaskListeners(task);
+                    return;
+                }
+                task.reassignRefused = null;
+            }
             task.assignedAgentId = toAgentId;
             task.toAgentId = toAgentId;
             task.status = 'assigned';
             task.assignedAt = new Date().toISOString();
+            await this.heartbeatContractedTask(task, task.assignedAt);
             await this.saveTasks();
             this.notifyTaskListeners(task);
         }
@@ -171,6 +199,37 @@ export class SubAgentManager {
     async updateTaskStatus(taskId, status, result, error) {
         const task = this.tasks.get(taskId);
         if (task) {
+            // 2026-09-25 (M3 接缝): 挂了合同的子任务, 任何状态更新都是"子还活着"的证据 → 记一次心跳。
+            //   这是"执行中统一监控"的输入面: 没有心跳, 阻塞巡检只能看见"卡住", 看不见"在动"。
+            await this.heartbeatContractedTask(task);
+            // 2026-09-25 (飞轮接线 P2): 挂着工作合同的任务, "完成" 必须过回报核验 ——
+            //   回一段漂亮话 (没有逐条判据证据) **不算完成**: 任务留在 in_progress, 原因写清楚,
+            //   而 Goal 那边的 pendingReports 保持 (父仍然在等这份回报)。
+            //
+            // 2026-09-25 (M3): 判据从 `task.workId && task.goalId` 收紧成 `task.goalId` ——
+            //   "派前必须有合同"的**反面**: 目标语境下的任务若**没有**合同 (签发失败 / 旧数据),
+            //   它同样不许自称完成 —— 没有合同的回报不核验也不接受 (handleChildReport 的 no_contract)。
+            if (status === 'completed' && task.goalId) {
+                if (!task.workId) {
+                    task.status = 'in_progress';
+                    task.error = '回报不接受为完成: 这条任务在目标语境下**没有工作合同** '
+                        + '(签合同失败或任务早于合同接线) —— 没有合同就没有判据, 无法核验, 不许当完成记账';
+                    await this.saveTasks();
+                    this.notifyTaskListeners(task);
+                    return;
+                }
+                const verdict = await this.validateTaskReport(task, result ?? '');
+                if (!verdict.accepted) {
+                    task.status = 'in_progress';
+                    if (result)
+                        task.result = result;
+                    task.error = `回报核验不过, 不接受为完成: ${verdict.reason}`
+                        + (verdict.missingEvidence.length ? ` [缺证据: ${verdict.missingEvidence.join('; ')}]` : '');
+                    await this.saveTasks();
+                    this.notifyTaskListeners(task);
+                    return;
+                }
+            }
             task.status = status;
             if (result)
                 task.result = result;
@@ -183,6 +242,31 @@ export class SubAgentManager {
             this.notifyTaskListeners(task);
         }
     }
+    /**
+     * 给挂着合同的任务记一次心跳 (P3 的输入面; 只有真写成盘才算数)。
+     *
+     * 为什么放在**真实派遣过程**里而不是让子 Agent 自己记得报: 心跳是"任务还活着"的事实,
+     * 而子 Agent 是最没有动力报心跳的一方 (它卡住了就不会报)。所以由派遣侧在每一次
+     * 真实状态变化 (派出去 / 换人 / 子更新状态) 时落一次 —— 没有这些落点, 阻塞巡检
+     * 只能看到"从来没心跳过", 分不清"卡住"与"刚派出"。
+     *
+     * 失败**不覆盖** `task.error` (那是子 Agent 的事实), 而是记进 `heartbeatError`:
+     * 心跳写不进去 = 监控会看到"无进展", 这件事必须留在任务上, 不许静默。
+     */
+    async heartbeatContractedTask(task, at) {
+        if (!task.goalId || !task.workId)
+            return;
+        const now = at ?? new Date().toISOString();
+        try {
+            const { recordWorkHeartbeat } = await import('./goal-flywheel-wiring.js');
+            await recordWorkHeartbeat(task.goalId, task.workId, now);
+            task.lastHeartbeatAt = now;
+            task.heartbeatError = null;
+        }
+        catch (e) {
+            task.heartbeatError = `心跳写入失败 (监控会看到"无进展"): ${String(e?.message || e).slice(0, 160)}`;
+        }
+    }
     async getTask(taskId) {
         return this.tasks.get(taskId);
     }
@@ -300,14 +384,136 @@ export class SubAgentManager {
             }
         }
     }
-    async delegateTask(fromAgentId, taskDescription, requiredCapabilities, priority = 'normal', input) {
+    async delegateTask(fromAgentId, taskDescription, requiredCapabilities, priority = 'normal', input, contractOptions) {
         const agent = await this.findBestAgentForTask(requiredCapabilities, fromAgentId);
         if (!agent) {
             const task = await this.createTask('delegate', taskDescription.substring(0, 50), taskDescription, fromAgentId, undefined, priority, input);
-            return { task, agent: undefined };
+            const workContract = await this.issueWorkContractFor(fromAgentId, task, requiredCapabilities, contractOptions);
+            // 派前必须有工作合同 (M3): 目标语境下签不出合同 → **(没有收件人时本来也派不出去)**, 但要如实标注
+            if (!workContract && contractOptions?.goalId) {
+                this.refuseDispatchWithoutContract(task, contractOptions?.goalId);
+                await this.saveTasks();
+                return { task, agent: undefined, workContract: undefined };
+            }
+            if (workContract)
+                await this.heartbeatContractedTask(task);
+            await this.saveTasks();
+            return { task, agent: undefined, workContract };
         }
         const task = await this.createTask('delegate', taskDescription.substring(0, 50), taskDescription, fromAgentId, agent.id, priority, input);
-        return { task, agent };
+        // 2026-09-25 (P2): 派遣这件事**本身**就包含签合同 (不是事后再补一份文档);
+        //   有没有空闲子 Agent 不影响合同签发 (合同锁的是能力与判据, 不是某个人)。
+        //
+        // 2026-09-25 (M3): 签不出合同 ⇒ **不派出**。旧形状是"记个 error 照样把任务交出去",
+        //   那等于"派前必须有的合同"在失败路径上直接不存在 (子拿到一段任务描述就开始干,
+        //   回来只有一段文本, 父连判据都没有)。现在: 任务退回 `pending`、不绑执行者、
+        //   返回 `agent: undefined`, 让调用方**没有**可派遣的对象。
+        const workContract = await this.issueWorkContractFor(fromAgentId, task, requiredCapabilities, contractOptions);
+        if (!workContract && contractOptions?.goalId) {
+            this.refuseDispatchWithoutContract(task, contractOptions.goalId);
+            await this.saveTasks();
+            return { task, agent: undefined, workContract: undefined };
+        }
+        if (workContract)
+            await this.heartbeatContractedTask(task);
+        await this.saveTasks();
+        return { task, agent, workContract };
+    }
+    /**
+     * 目标语境下没有合同 ⇒ **不派出** (M3 的"派前必须有合同")。
+     *
+     * 落成事实: 任务退回 `pending` 且**不绑执行者** (没有 `assignedAt`),
+     * `contractRefused` 记下原因。于是:
+     *   · 调用方拿到的 `agent` 是 `undefined` → 没有派遣对象;
+     *   · 任务不会出现在 `getActiveTasks()` 里 (它没被派出去);
+     *   · 原因留在任务上, 父能据此重签合同或交人 (不许静默当"没派过")。
+     */
+    refuseDispatchWithoutContract(task, goalId) {
+        const reason = task.error
+            ? `派前必须有工作合同: 合同没签成 → 不派出 (${task.error})`
+            : '派前必须有工作合同: 合同没签成 → 不派出';
+        task.status = 'pending';
+        task.assignedAgentId = undefined;
+        task.toAgentId = undefined;
+        task.assignedAt = undefined;
+        // Goal 上下文要留在任务上: ① 它说明这次派遣是**为哪个目标**尝试的;
+        //   ② 于是完成门 (`updateTaskStatus` 的 `task.goalId` 判据) 也管得到这条没有合同的任务
+        //      —— 没有合同就不许自称完成, 不留 goalId 的话它就绕过了那道门。
+        if (goalId)
+            task.goalId = goalId;
+        task.contractRefused = { code: 'contract_not_issued', reason };
+    }
+    /**
+     * 给这次派遣签工作合同 (P2)。只有调用方给了 `goalId` 才签 —— 没有长期目标就没有合同上下文,
+     * 这时行为与接线前完全一致 (只记任务)。
+     */
+    async issueWorkContractFor(fromAgentId, task, requiredCapabilities, opts) {
+        if (!opts?.goalId)
+            return undefined;
+        try {
+            const { dispatchChildWork } = await import('./goal-flywheel-wiring.js');
+            const capability = (requiredCapabilities[0] || 'general').trim();
+            const issued = await dispatchChildWork({
+                goalId: opts.goalId,
+                parentRunId: opts.parentRunId ?? `subagent-task:${task.id}`,
+                childAgentId: task.assignedAgentId || task.toAgentId || `(unassigned:${fromAgentId})`,
+                capability,
+                objective: task.description,
+                inputs: { taskId: task.id, input: task.input ?? null },
+                allowedTools: opts.allowedTools ?? [],
+                budget: opts.budget ?? { maxSteps: null, maxDurationMs: this.config.taskTimeoutMs, maxAmount: null, currency: null },
+                deadline: opts.deadline ?? null,
+                successCriteria: (opts.successCriteria?.length ? opts.successCriteria : [task.description]).slice(0, 20),
+                issuedBy: `subagent-manager:${fromAgentId}`,
+            });
+            task.goalId = opts.goalId;
+            task.workId = issued.workId;
+            task.metadata = { ...(task.metadata ?? {}), workContract: issued };
+            await this.saveTasks();
+            return issued;
+        }
+        catch (err) {
+            // 签合同失败 → 如实记在任务上 (不许悄悄降级成"没合同也能派")
+            task.error = `工作合同签发失败: ${String(err?.message || err).slice(0, 200)}`;
+            await this.saveTasks();
+            return undefined;
+        }
+    }
+    /**
+     * 核验挂着合同的子任务回报 (P2)。
+     * 报告可以是**结构化 JSON 文本** (推荐: 子按 `bolloon-work-report/1` 回), 也可以是纯文本 ——
+     * 纯文本没有逐条证据 → **不接受为完成** (这正是要堵的"回一段漂亮话就算完成")。
+     */
+    async validateTaskReport(task, result) {
+        const { handleChildReport } = await import('./goal-flywheel-wiring.js');
+        const contract = (task.metadata?.workContract ?? null);
+        const raw = String(result ?? '');
+        let report = null;
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && typeof parsed.status === 'string') {
+                report = parsed;
+            }
+        }
+        catch { /* 不是 JSON → 当纯文本处理 */ }
+        if (!report) {
+            report = {
+                workId: task.workId,
+                childAgentId: contract?.childAgentId ?? task.assignedAgentId ?? task.toAgentId ?? '(unknown)',
+                status: 'completed',
+                summary: raw.slice(0, 400),
+                evidence: [],
+                artifacts: [],
+                checks: [],
+                unresolvedItems: [],
+                blockReason: null,
+                nextRecommendation: '(未提供)',
+                durationMs: 0,
+                reportedAt: new Date().toISOString(),
+            };
+        }
+        const out = await handleChildReport({ goalId: task.goalId, workId: task.workId, report });
+        return { accepted: out.accepted, reason: out.reason, missingEvidence: out.missingEvidence };
     }
     async consultAgent(fromAgentId, toAgentId, query, taskId) {
         return this.sendMessage(fromAgentId, toAgentId, query, 'query', taskId);

package/dist/agents/task/task-runner.js

@@ -17,13 +17,16 @@ import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as crypto from 'crypto';
-import { createGoal, attachRun, markCriterion, completeGoalIfEligible, readGoal, setCriteria, } from '../goal-store.js';
+import { createGoal, attachRun, markCriterion, readGoal, setCriteria, } from '../goal-store.js';
 import { startRun, recordStep, finishRun, readRun } from '../run-store.js';
+import { captureRunModelConfig } from '../../llm/model-selection.js';
 import { listTransactions, updateTransaction, setTransactionStatus } from '../x402/transaction-store.js';
 import { bridgeTransactionToRunGoal } from '../x402/goal-run-bridge.js';
 import { buyInfoAsTransaction } from '../x402/trade.js';
 import { publishInfo, listInfo } from '../x402/paid-info-store.js';
 import { planTransactionRecovery } from '../x402/payment-recovery.js';
+// 2026-09-25 (M0 接线冻结): CLI 的 Run 终止也必须过唯一责任链 (规则 ③④)
+import * as wiring from '../goal-flywheel-wiring.js';
 import { executeContractSkill, validateResourceOutput, verifyInstallFidelity, loadResourceContract } from '../x402/resource-contract.js';
 import { adviseResource } from './resource-advisor.js';
 import { resolveTaskBudget, checkPurchaseAllowed, previewPurchaseImpact } from './task-budget.js';
@@ -313,11 +316,20 @@ export async function runTask(opts) {
             return { ok: false, card, text: renderReportCard(card), stages, budget, outputIssues: [] };
         }
     }
-    const run = await startRun({ surface: 'cli', goal: opts.task, goalId: goal.goalId });
+    const run = await startRun({
+        surface: 'cli',
+        goal: opts.task,
+        goalId: goal.goalId,
+        // 2026-09-26: 任务执行链同样要记下"这一跑用的是哪一份模型配置"
+        modelConfig: await captureRunModelConfig().catch(() => undefined),
+    });
     await attachRun(goal.goalId, run.runId);
     const fail = async (stage, note, cardOpts, runStatus = 'needs_human') => {
         mark(stage, note);
         await finishRun(run.runId, { status: runStatus, summary: note.slice(0, 200) });
+        // ★ 2026-09-25 (M0 接线冻结, 规则 ④): CLI 任务的每条失败出口也是 Run 的终止 →
+        //   同样过收尾漏斗 (旧写法只 finishRun, 于是这条路径上没有 Memory / Skill 候选 / 权威 continuation)。
+        await wiring.closeTaskRun(run.runId, goal.goalId, note, 'cli');
         const card = buildReportCard({ ...cardOpts, evidenceRef: { goalId: goal.goalId, runId: run.runId, transactionId: cardOpts.evidenceRef?.transactionId }, budgetLines: [...budget.why, ...(cardOpts.budgetLines || [])] });
         return { ok: false, card, text: renderReportCard(card), goalId: goal.goalId, runId: run.runId, transactionId: card.evidenceRef.transactionId, stages, budget, outputIssues: cardOpts.blocker ? [cardOpts.blocker] : [] };
     };
@@ -554,8 +566,9 @@ export async function runTask(opts) {
         summary: evidenceOk ? `任务完成: ${concl.conclusion || '已产出'}` : '未达标 (证据/契约不完整)',
         evidence: [`bridge: step=${bridge.stepWritten} evidence=${bridge.evidenceWritten} goal=${bridge.goalEvidenceWritten}`],
     });
-    if (evidenceOk)
-        await completeGoalIfEligible(goal.goalId);
+    // ★ M0 (规则 ③④): 成功出口也走同一个收尾漏斗 —— 完不完成由飞轮决策 + 完成门判,
+    //   不再在这里直接调 completeGoalIfEligible (那是一条绕过 closeRun 的旧收尾路径)。
+    await wiring.closeTaskRun(run.runId, goal.goalId, card.conclusion || card.status, 'cli');
     mark('report', card.status);
     return {
         ok: card.status === '已完成',

package/dist/agents/task-group.js

@@ -40,6 +40,10 @@ import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import { parseGroupLink, listGroups, groupSend, groupMessages } from './gateway-group.js';
+// 2026-09-25: 隐私红线规则表抽到 task-public-text.ts (手机端与桌面端**同一份**)
+import { PRIVACY_RULES, NODE_IDENTITY_RULES, scanPublicText, requirePublicText, scanNodeIdentity, mask } from './task-public-text.js';
+// 保持对外 API 不变 (老调用方/测试继续 from './task-group.js' 拿这些)
+export { PRIVACY_RULES, NODE_IDENTITY_RULES, scanPublicText, requirePublicText, scanNodeIdentity, mask };
 // ── 常量 ────────────────────────────────────────────────────────────────────
 /** 消息标记 (一行一条; 解析只认这一行) */
 export const TRAIL_TAG = '[bolloon-task]';
@@ -55,56 +59,9 @@ export const TRAIL_KIND_LABEL = {
     final: '终审结论',
 };
 export const VERDICTS = ['accept', 'reject', 'unknown'];
-/**
- * 群消息**禁止出现**的形态 (顺序即报告顺序)。宁可多拦 (拒发 + 说清哪条规则), 也不放行一条带标识符的消息。
- *
- * 实现纪律 (2026-09-23 踩过的坑, 不可回退):
- * · **不要用 `\b` 当边界** —— 消息里的 token 会把空白折成 `_`, 而 `_` 也是 \w, 于是 `判据见_0x1111…`
- *   这种"粘在 `_`/汉字后面"的标识符 `\b` 判不出来, 会直接漏进群。一律改成对标识符自身字母表的
- *   lookahead/lookbehind (`(?<![0-9a-fA-FxX])`, `(?![0-9a-fA-F])`), 粘在 `_`/中文/符号后面也照样命中。
- * · ipv6 规则要**避开 ISO 时间戳** (`09:50:12.345Z` 只有两个冒号): 只认 3 组以上 `x:y:z:w` 或含 `::` 的压缩形态。
- * · 内容哈希 (sha256 64 位裸 hex) **不在**禁列 —— 交付就是要贴哈希 (它不是密钥, 也没有 0x 前缀)。
- */
-export const PRIVACY_RULES = [
-    { rule: 'wallet-address', why: '以太坊/EVM 钱包地址', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{40}(?![0-9a-fA-F])/ },
-    { rule: 'private-key-hex', why: '32 字节私钥形态 (0x + 64 hex)', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{64}(?![0-9a-fA-F])/ },
-    { rule: 'hex-0x-blob', why: '0x 开头的十六进制块 (签名/哈希/密钥都长这样, 群里一律不放原文)', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{8,}(?![0-9a-fA-F])/ },
-    { rule: 'did', why: '去中心化身份 DID', re: /did:[a-z0-9]+:[A-Za-z0-9._:%-]{3,}/i },
-    { rule: 'peer-id', why: 'libp2p peerId (12D3Koo…/Qm…)', re: /12D3Koo[A-Za-z0-9]{8,}|Qm[1-9A-HJ-NP-Za-km-z]{30,}/ },
-    { rule: 'multiaddr', why: 'libp2p multiaddr 或 store 地址 (/ip4 /tcp /p2p /orbitdb …)', re: /\/(ip4|ip6|dns|dns4|dns6|tcp|udp|ws|wss|quic|p2p|p2p-circuit|ipfs|orbitdb)(?![A-Za-z0-9])/i },
-    { rule: 'orbitdb-link', why: 'OrbitDB 链接 (群邀请链接本身也不进群消息)', re: /orbitdb:\/\//i },
-    { rule: 'ipv4', why: 'IPv4 地址', re: /(?<!\d)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(?!\d)/ },
-    { rule: 'ipv6', why: 'IPv6 地址 (不含 ISO 时间戳)', re: /(?<![0-9A-Za-z])(?:[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}(?![0-9A-Za-z])|(?<![0-9A-Za-z:])(?:[0-9a-fA-F]{1,4}:){3,}[0-9a-fA-F]{1,4}(?![0-9A-Za-z])/ },
-    { rule: 'pem', why: 'PEM 材料 (私钥/证书)', re: /-----BEGIN [A-Z ]*(PRIVATE KEY|CERTIFICATE)/ },
-    { rule: 'secret-words', why: '私钥/助记词/密钥字样 (正文里提到即停, 人不该把密钥写进群)', re: /(private\s*key|seed\s*phrase|mnemonic|私钥|助记词|密钥材料)/i },
-    { rule: 'url', why: 'http(s) 端点 (端点会带 host/IP 与用途指纹)', re: /https?:\/\/\S+/i },
-    { rule: 'email', why: '邮箱地址', re: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/ },
-];
-function mask(s) {
-    const t = String(s || '');
-    return t.length <= 4 ? '****' : `${t.slice(0, 4)}…`;
-}
-/** 扫一遍文本, 返回命中的隐私规则 (空数组 = 可以发) */
-export function scanPublicText(text) {
-    const t = String(text ?? '');
-    const out = [];
-    const seen = new Set();
-    for (const r of PRIVACY_RULES) {
-        const m = r.re.exec(t);
-        if (!m)
-            continue;
-        if (seen.has(r.rule))
-            continue;
-        seen.add(r.rule);
-        out.push({ rule: r.rule, why: r.why, masked: mask(String(m[0])), chars: String(m[0]).length });
-    }
-    return out;
-}
-/** 发送前唯一闸门: 命中任何规则 → 拒绝发送 (返回 violations 供 CLI 如实报出) */
-export function requirePublicText(text) {
-    const v = scanPublicText(text);
-    return v.length === 0 ? { ok: true } : { ok: false, violations: v };
-}
+// ── 隐私守卫 ────────────────────────────────────────────────────────────────
+// 规则表与扫描函数本身在 `task-public-text.ts` (单一来源, 手机/桌面共用);
+// 本文件只负责**发送前调用它** (见 sendTrailMessage) 与在群管理输出上再过一遍 (scanNodeIdentity)。
 // ── 发送者标记 (稳定假名, 原始 DID 不入群) ──────────────────────────────────
 const sha256Hex = (s) => crypto.createHash('sha256').update(s, 'utf8').digest('hex');
 /** DID → 稳定假名 `agent-<8位>` (同一个人每次都是同一个标记, 但看不出是谁) */
@@ -147,7 +104,7 @@ export async function resolveSenderTag(explicit) {
     return {
         ok: false, code: 'INVALID_ARGUMENT',
         message: '没有本机身份 (~/.bolloon/identity.json) 也没有 --from → 给不出诚实的发送者标记 (拒, 不假造一个)',
-        detail: { identityFile: '~/.bolloon/identity.json', accepted: ['--from 委托方', 'bolloon setup'] },
+        detail: { identityFile: '~/.bolloon/identity.json', accepted: ['--from 委托方', 'bolloon identity init', 'bolloon setup'] },
     };
 }
 /** 与 gateway-group 内部 `groupIdOf` 同款派生 (它没导出; 这里只作地址比不中时的兜底) */

package/dist/agents/task-public-text.js

@@ -0,0 +1,89 @@
+/**
+ * task-public-text.ts — **公开文本的隐私红线 (单一来源)** (2026-09-25)
+ *
+ * 为什么要单独一个文件: 同一条红线要同时把住**两个入口** ——
+ *   · 桌面/CLI: 群消息发送前 (`task-group.ts` → `requirePublicText`)
+ *   · 手机 WebView: 手机侧发公告/接单/入群前 (mobile-tasks.ts → 同一函数)
+ * 两边各抄一份规则 = 迟早漂移 (一边加了规则另一边没加, 于是手机成了绕过红线的后门)。
+ * 所以规则表放在这里, 双方都 import 这一份; 本文件**不 import 任何 node: 模块**,
+ * 因此既能进 Node, 也能进浏览器 bundle。
+ *
+ * 群消息**禁止出现**的形态 (顺序即报告顺序)。宁可多拦 (拒发 + 说清哪条规则),
+ * 也不放行一条带标识符的消息。
+ *
+ * 实现纪律 (2026-09-23 踩过的坑, 不可回退):
+ * · **不要用 `\b` 当边界** —— 消息里的 token 会把空白折成 `_`, 而 `_` 也是 \w, 于是 `判据见_0x1111…`
+ *   这种"粘在 `_`/汉字后面"的标识符 `\b` 判不出来, 会直接漏进群。一律改成对标识符自身字母表的
+ *   lookahead/lookbehind (`(?<![0-9a-fA-FxX])`, `(?![0-9a-fA-F])`), 粘在 `_`/中文/符号后面也照样命中。
+ * · ipv6 规则要**避开 ISO 时间戳** (`09:50:12.345Z` 只有两个冒号): 只认 3 组以上 `x:y:z:w` 或含 `::` 的压缩形态。
+ * · 内容哈希 (sha256 64 位裸 hex) **不在**禁列 —— 交付就是要贴哈希 (它不是密钥, 也没有 0x 前缀)。
+ */
+export const PRIVACY_RULES = [
+    { rule: 'wallet-address', why: '以太坊/EVM 钱包地址', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{40}(?![0-9a-fA-F])/ },
+    { rule: 'private-key-hex', why: '32 字节私钥形态 (0x + 64 hex)', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{64}(?![0-9a-fA-F])/ },
+    { rule: 'hex-0x-blob', why: '0x 开头的十六进制块 (签名/哈希/密钥都长这样, 群里一律不放原文)', re: /(?<![0-9a-fA-FxX])0x[0-9a-fA-F]{8,}(?![0-9a-fA-F])/ },
+    { rule: 'did', why: '去中心化身份 DID', re: /did:[a-z0-9]+:[A-Za-z0-9._:%-]{3,}/i },
+    { rule: 'peer-id', why: 'libp2p peerId (12D3Koo…/Qm…)', re: /12D3Koo[A-Za-z0-9]{8,}|Qm[1-9A-HJ-NP-Za-km-z]{30,}/ },
+    { rule: 'multiaddr', why: 'libp2p multiaddr 或 store 地址 (/ip4 /tcp /p2p /orbitdb …)', re: /\/(ip4|ip6|dns|dns4|dns6|tcp|udp|ws|wss|quic|p2p|p2p-circuit|ipfs|orbitdb)(?![A-Za-z0-9])/i },
+    { rule: 'orbitdb-link', why: 'OrbitDB 链接 (群邀请链接本身也不进群消息)', re: /orbitdb:\/\//i },
+    { rule: 'ipv4', why: 'IPv4 地址', re: /(?<!\d)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(?!\d)/ },
+    { rule: 'ipv6', why: 'IPv6 地址 (不含 ISO 时间戳)', re: /(?<![0-9A-Za-z])(?:[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}(?![0-9A-Za-z])|(?<![0-9A-Za-z:])(?:[0-9a-fA-F]{1,4}:){3,}[0-9a-fA-F]{1,4}(?![0-9A-Za-z])/ },
+    { rule: 'pem', why: 'PEM 材料 (私钥/证书)', re: /-----BEGIN [A-Z ]*(PRIVATE KEY|CERTIFICATE)/ },
+    { rule: 'secret-words', why: '私钥/助记词/密钥字样 (正文里提到即停, 人不该把密钥写进群)', re: /(private\s*key|seed\s*phrase|mnemonic|私钥|助记词|密钥材料)/i },
+    { rule: 'url', why: 'http(s) 端点 (端点会带 host/IP 与用途指纹)', re: /https?:\/\/\S+/i },
+    { rule: 'email', why: '邮箱地址', re: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/ },
+];
+/** 标识符打码 (只留前 4 字符) */
+export function mask(s) {
+    const t = String(s || '');
+    return t.length <= 4 ? '****' : `${t.slice(0, 4)}…`;
+}
+/** 扫一遍文本, 返回命中的隐私规则 (空数组 = 可以发) */
+export function scanPublicText(text) {
+    const t = String(text ?? '');
+    const out = [];
+    const seen = new Set();
+    for (const r of PRIVACY_RULES) {
+        const m = r.re.exec(t);
+        if (!m)
+            continue;
+        if (seen.has(r.rule))
+            continue;
+        seen.add(r.rule);
+        out.push({ rule: r.rule, why: r.why, masked: mask(String(m[0])), chars: String(m[0]).length });
+    }
+    return out;
+}
+/** 发送前唯一闸门: 命中任何规则 → 拒绝发送 (返回 violations 供 CLI/手机如实报出) */
+export function requirePublicText(text) {
+    const v = scanPublicText(text);
+    return v.length === 0 ? { ok: true } : { ok: false, violations: v };
+}
+/**
+ * **节点身份**口径 (群管理命令 `task group create|join|list|link|leave` 的输出用, 2026-09-24):
+ * 与群消息同一张规则表, 但**去掉 orbitdb 那一档** ——
+ *   · `orbitdb-link` 整条去掉: 邀请链接是群唯一能让别人入群的东西, 必须能打印出来;
+ *   · `multiaddr` 规则里的 `orbitdb` 选项去掉 (只留节点地址 /ip4 /ip6 /dns /tcp /p2p …):
+ *     群 store 地址 (`/orbitdb/zdpu…`) 是**群自己的公开标识**, 不是节点地址。
+ * 仍然全拦: 原始 DID · 钱包地址 · peerId · 节点 multiaddr · IPv4/IPv6 · 私钥形态 · PEM · URL · 邮箱。
+ *
+ * 用法: 群管理**输出**再过一遍这道闸 (`scanNodeIdentity`)。命中 = 输出里真有节点身份/联系方式泄漏,
+ * 此时**拒输出并如实报**, 不静默脱敏掉再当成没事 (那样人看到的就不是事实了)。
+ */
+export const NODE_IDENTITY_RULES = PRIVACY_RULES
+    .filter((r) => r.rule !== 'orbitdb-link')
+    .map((r) => (r.rule === 'multiaddr'
+    ? { ...r, re: /\/(ip4|ip6|dns|dns4|dns6|tcp|udp|ws|wss|quic|p2p|p2p-circuit|ipfs)(?![A-Za-z0-9])/i }
+    : r));
+/** 扫节点身份泄漏 (空数组 = 输出干净) */
+export function scanNodeIdentity(text) {
+    const t = String(text ?? '');
+    const out = [];
+    for (const r of NODE_IDENTITY_RULES) {
+        const m = r.re.exec(t);
+        if (!m)
+            continue;
+        out.push({ rule: r.rule, why: r.why, masked: mask(String(m[0])), chars: String(m[0]).length });
+    }
+    return out;
+}

package/dist/agents/workflow-pivot-loop.js

@@ -13,6 +13,8 @@
  * - Token budget awareness
  */
 import { detectRepeatingCalls, toolCallArgsHash } from './loop-review.js';
+// 2026-09-26: 回程派发还原 (LLM 回吐的 API 名 → 注册表真名; 净化在 pi-ai.ts 唯一边界)
+import { resolveApiToolName } from '../llm/tool-name.js';
 /**
  * 2026-08-11 (借鉴 Hermes `_canonicalize_tool_call_arguments`): 工具参数规范化 —
  * LLM 返回的 arguments 常带尾随散文/尾逗号/代码围栏, 直接 JSON.parse 失败会丢整个工具调用.
@@ -234,7 +236,8 @@ export class WorkflowPivotLoop {
             const fn = tc?.function;
             if (!fn || !fn.name)
                 continue;
-            const name = fn.name;
+            // 2026-09-26: 回程还原 — 原生 tool_calls 里的名字是净化后的 API 名
+            const name = resolveApiToolName(fn.name);
             if (!this.tools.has(name)) {
                 this.pushContinuationHint(`工具 ${name} 未注册/不存在, 调用已跳过 — 请换用已提供的工具`);
                 continue;
@@ -613,11 +616,12 @@ export class WorkflowPivotLoop {
         while ((match = toolUseRe.exec(content)) !== null) {
             try {
                 const obj = JSON.parse(match[1]);
-                if (obj && obj.name && this.tools.has(obj.name)) {
+                const realName = obj && obj.name ? resolveApiToolName(String(obj.name)) : '';
+                if (obj && realName && this.tools.has(realName)) {
                     const args = this.normalizeArgs(canonicalizeToolCallArguments(obj.arguments));
-                    pending.push({ name: obj.name, args, description: '', parameters: {} });
+                    pending.push({ name: realName, args, description: '', parameters: {} });
                 }
-                else if (obj && obj.name && !this.tools.has(obj.name)) {
+                else if (obj && obj.name && !this.tools.has(realName)) {
                     this.pushContinuationHint(`工具 ${obj.name} 未注册/不存在, 调用已跳过 — 请换用已提供的工具`);
                 }
             }
@@ -634,7 +638,8 @@ export class WorkflowPivotLoop {
             const invokeRe = /<invoke\s+name="(\w+)"\s*>([\s\S]*?)<\/invoke>/g;
             let im;
             while ((im = invokeRe.exec(block)) !== null) {
-                const name = im[1];
+                // 2026-09-26: 回程还原 — LLM 可能回吐的是净化后的 API 名
+                const name = resolveApiToolName(im[1]);
                 if (!this.tools.has(name))
                     continue;
                 // 抓 <parameter name="k">v</parameter> 列表
@@ -642,7 +647,7 @@ export class WorkflowPivotLoop {
                 const paramRe = /<parameter\s+name="(\w+)"\s*>([\s\S]*?)<\/parameter>/g;
                 let pm;
                 while ((pm = paramRe.exec(im[2])) !== null) {
-                    args[pm[1]] = pm[2].trim().replace(/^["']|['"]$/g, '');
+                    args[pm[1]] = pm[2].trim().replace(/^["']|["']$/g, '');
                 }
                 // 避免重复添加
                 if (!pending.some(p => p.name === name)) {
@@ -659,7 +664,8 @@ export class WorkflowPivotLoop {
             const invokeRe = /<invoke\s+name="(\w+)"\s*>([\s\S]*?)<\/invoke>/g;
             let im;
             while ((im = invokeRe.exec(block)) !== null) {
-                const name = im[1];
+                // 2026-09-26: 回程还原 — LLM 可能回吐的是净化后的 API 名
+                const name = resolveApiToolName(im[1]);
                 if (!this.tools.has(name))
                     continue;
                 const args = {};
@@ -676,7 +682,7 @@ export class WorkflowPivotLoop {
         // Pattern 1: Chinese format "调用工具: tool_name(args)"
         const pattern1 = /调用工具[：:]\s*(\w+)\s*\(([^)]*)\)/g;
         while ((match = pattern1.exec(content)) !== null) {
-            const name = match[1];
+            const name = resolveApiToolName(match[1]);
             const argsStr = match[2];
             const args = this.parseArgs(argsStr);
             if (this.tools.has(name)) {
@@ -686,7 +692,7 @@ export class WorkflowPivotLoop {
         // Pattern 2: tool_name(args) format
         const pattern2 = /(\w+)\s*\(\s*([^)]*)\s*\)/g;
         while ((match = pattern2.exec(content)) !== null) {
-            const name = match[1];
+            const name = resolveApiToolName(match[1]);
             const argsStr = match[2];
             // Skip if already matched or doesn't look like a tool call
             if (pending.some(p => p.name === name))
@@ -703,8 +709,9 @@ export class WorkflowPivotLoop {
                 const parsed = JSON.parse(jsonMatch[0]);
                 if (Array.isArray(parsed.tool_calls)) {
                     for (const tc of parsed.tool_calls) {
-                        if (this.tools.has(tc.name)) {
-                            pending.push({ name: tc.name, args: tc.args || {}, description: '', parameters: {} });
+                        const realName = resolveApiToolName(String(tc?.name ?? ''));
+                        if (this.tools.has(realName)) {
+                            pending.push({ name: realName, args: tc.args || {}, description: '', parameters: {} });
                         }
                     }
                 }
@@ -720,7 +727,7 @@ export class WorkflowPivotLoop {
         const singleJsonRe = /\{\s*"name"\s*:\s*"(\w+)"\s*,\s*"(?:arguments|input)"\s*:\s*(\{[\s\S]*?\})\s*\}/g;
         let singleMatch;
         while ((singleMatch = singleJsonRe.exec(content)) !== null) {
-            const name = singleMatch[1];
+            const name = resolveApiToolName(singleMatch[1]);
             if (pending.some(p => p.name === name))
                 continue;
             if (!this.tools.has(name))

package/dist/cli/clipboard.js

@@ -0,0 +1,65 @@
+/**
+ * clipboard.ts — 把文本真写进**系统剪贴板** (2026-09-27)
+ *
+ * ## 为什么需要它
+ *
+ * 面板是 Ink 画的**一屏自绘帧**: 每帧都是 `eraseLines` + 重画。终端里的鼠标框选靠终端自己维护,
+ * 而"每秒重画一帧"会不断打断正在进行的框选 —— 于是"想抄一段回复"变成了撞运气。
+ * 真终端字节证据 (`scripts/verify-cli-panel.ts` 抓的那一份):
+ *   · `ESC[2J ESC[3J ESC[H` (**清屏 + 清回滚缓冲**) 在 30s 内出现 24 次;
+ *   · 每一次都来自 Ink 的 `renderInteractiveFrame` (`shouldClearTerminalForFrame`: 帧高缩了/上一帧是别的形状)。
+ * 这既解释了"选不中", 也解释了"往上滚看不到更早的内容"。
+ *
+ * 所以复制走**两条腿**:
+ *   ① 结构上少打断: 版面固定成"整屏高" + 跟随暂停时**完全不重画** (见 `ink-app.tsx`) → 帧不再乱清;
+ *   ② 一条**不靠鼠标**的显式通路: `/copy` —— 把最近一条/整段回复交给系统剪贴板工具。
+ *     能用 `pbcopy` 就不假装"已经复制到剪贴板了"。
+ */
+import { spawnSync } from 'child_process';
+/** 剪贴板工具按平台挑 (第一个能跑的胜出); 环境变量 `BOLLOON_CLIPBOARD_CMD` 可显式覆盖 (验收门用) */
+export function clipboardCommand(env = process.env) {
+    const override = (env.BOLLOON_CLIPBOARD_CMD ?? '').trim();
+    if (override) {
+        const parts = override.split(/\s+/).filter(Boolean);
+        if (parts.length)
+            return { cmd: parts[0], args: parts.slice(1) };
+    }
+    switch (process.platform) {
+        case 'darwin': return { cmd: 'pbcopy', args: [] };
+        case 'win32': return { cmd: 'clip', args: [] };
+        default:
+            if (env.WAYLAND_DISPLAY)
+                return { cmd: 'wl-copy', args: [] };
+            if (env.DISPLAY)
+                return { cmd: 'xclip', args: ['-selection', 'clipboard'] };
+            return null;
+    }
+}
+/** 剪贴板工具名 (报告/界面里只说工具名, 不打印被复制的内容) */
+export function clipboardToolName(env = process.env) {
+    const c = clipboardCommand(env);
+    return c ? c.cmd : null;
+}
+/**
+ * 真写剪贴板 (同步: 这条命令要立刻给出"成没成", 不能 fire-and-forget)。
+ * 返回值只含**长度与工具名** —— 文本内容绝不回显/落日志 (回复里可能有 key/私密内容)。
+ */
+export function clipboardWrite(text, env = process.env) {
+    const chars = String(text ?? '').length;
+    const c = clipboardCommand(env);
+    if (!c) {
+        return { ok: false, chars, error: '这个平台没有可用的剪贴板命令 (macOS: pbcopy / Windows: clip / Linux: wl-copy 或 xclip)' };
+    }
+    try {
+        const r = spawnSync(c.cmd, c.args, { input: String(text ?? ''), encoding: 'utf8', timeout: 5000 });
+        if (r.error)
+            return { ok: false, chars, tool: c.cmd, error: `调用 ${c.cmd} 失败: ${r.error.message}` };
+        if (r.status !== 0) {
+            return { ok: false, chars, tool: c.cmd, error: `${c.cmd} 退出码 ${r.status}${r.stderr ? `: ${String(r.stderr).slice(0, 120)}` : ''}` };
+        }
+        return { ok: true, chars, tool: c.cmd };
+    }
+    catch (e) {
+        return { ok: false, chars, tool: c.cmd, error: String(e?.message || e).slice(0, 160) };
+    }
+}