@bolloon/bolloon-agent 0.4.33 → 0.5.0

package/dist/agents/skill-readiness.js

@@ -12,7 +12,9 @@
  */
 import * as os from 'os';
 import { SkillsManager } from './skills-manager.js';
-import { readGoal, setContinuation, updateGoal, addEvidence, } from './goal-store.js';
+import { readGoal, updateGoal, addEvidence, } from './goal-store.js';
+// 2026-09-25 (M0 接线冻结, 规则 ②): Goal 状态与 continuation 变更只有一个漏斗
+import { reduceGoalState } from './goal-state-reducer.js';
 import { recordDegradation } from './run-store.js';
 export function parseSkillSpecs(list = []) {
     const required = [];
@@ -109,15 +111,45 @@ export async function ensureGoalSkillsReady(goal, opts = {}) {
 /** 门禁不过 → 写清事实并把 Goal 交给人 (不启动 Run, 不伪造失败) */
 export async function blockGoalOnSkills(goalId, res) {
     const reason = res.reason || '技能未就绪';
-    await setContinuation(goalId, {
-        wakeReason: 'needs_human', autoContinue: false, needsExternal: undefined,
-        skillReadiness: { ok: false, at: new Date().toISOString(), reason, missing: res.missing, drift: res.drift, degradations: res.degradations },
-    });
-    await updateGoal(goalId, { status: 'needs_human' }).catch(() => { });
-    await addEvidence(goalId, [`技能门禁拦截: ${reason}`]).catch(() => { });
+    // 规则 ②: 状态与 continuation 都经 Goal reducer 写 (单一漏斗)
+    await reduceGoalState({
+        goalId,
+        intent: 'skill_gate_block',
+        now: new Date().toISOString(),
+        by: 'skill-readiness',
+        reason,
+        skillReadiness: {
+            ok: false, at: new Date().toISOString(), reason,
+            missing: res.missing, drift: res.drift, degradations: res.degradations,
+        },
+    }).catch(() => null);
     for (const d of res.degradations)
         await recordDegradation({ kind: 'observational', op: 'skill-readiness', message: d }).catch(() => { });
 }
+/**
+ * 只**记事实**、不改状态: 把本地技能就绪检查的结论写进 `continuation.skillReadiness`。
+ *
+ * ★ 2026-09-25 (P5 验收修复): 飞轮裁决 = `delegate` 时本地技能门禁**不适用** (能力由子 Agent 凭合同
+ *   交付), 所以不能调 `blockGoalOnSkills` (那会把 Goal 打成 needs_human)。但"本地缺什么"必须仍然
+ *   可查 —— 原来只有 `blockGoalOnSkills` 写这个字段, 门禁一放行就没有任何记录了。
+ */
+export async function recordSkillReadiness(goalId, res) {
+    // 规则 ②: continuation 也经 Goal reducer 写 (只记事实, 不改状态)
+    await reduceGoalState({
+        goalId,
+        intent: 'skill_gate_record',
+        now: new Date().toISOString(),
+        by: 'skill-readiness',
+        skillReadiness: {
+            ok: res.ok,
+            at: new Date().toISOString(),
+            reason: res.reason,
+            missing: res.missing,
+            drift: res.drift,
+            degradations: res.degradations,
+        },
+    }).catch(() => null);
+}
 /** 人工批准技能升级: 重新冻结快照 (显式动作, 不隐式切换) */
 export async function approveSkillUpgrade(goalId, opts = {}) {
     const goal = await readGoal(goalId);
@@ -126,8 +158,18 @@ export async function approveSkillUpgrade(goalId, opts = {}) {
     const frozen = await freezeGoalSkills(goal, { ...opts, force: true });
     if (!frozen.ok)
         return { ok: false, reason: frozen.reason };
-    await setContinuation(goalId, { skillReadiness: { ok: true, at: new Date().toISOString(), reason: '人工批准技能升级' }, wakeReason: 'active', autoContinue: true });
-    await updateGoal(goalId, { status: 'active' }).catch(() => { });
-    await addEvidence(goalId, [`技能升级已被人工批准: ${(frozen.snapshot || []).map((s) => `${s.name}@${s.version}`).join(', ')}`]).catch(() => { });
+    // ★ 规则 ⑥ (Skill 不许绕过 验证+快照+可回退 通道): 批准是**人**的动作, 但必须留下通道证据 ——
+    //   快照 (skillSnapshot, 上面 freezeGoalSkills 已写) + 版本 + 变更原因 + 可回退 (fromVersion 仍在
+    //   Goal 上)。这里把"谁批的、为什么"连同新版本一起记进 Goal (走唯一漏斗, 规则 ②)。
+    const versions = (frozen.snapshot || []).map((s) => `${s.name}@${s.version}`);
+    const fromVersions = (goal.skillSnapshot || []).map((s) => `${s.name}@${s.version}`);
+    await reduceGoalState({
+        goalId,
+        intent: 'skill_upgrade_approved',
+        now: new Date().toISOString(),
+        by: 'human',
+        skillReadiness: { ok: true, at: new Date().toISOString(), reason: '人工批准技能升级' },
+        reason: `技能升级已被人工批准 (by=human; from=[${fromVersions.join(', ')}] → to=[${versions.join(', ')}]; 可回退: Goal.skillSnapshot 保留新版本快照, 内容哈希在 skills-manager 侧可核验)`,
+    }).catch(() => null);
     return { ok: true, snapshot: frozen.snapshot };
 }

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,15 @@ 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 { 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';
@@ -318,6 +320,9 @@ export async function runTask(opts) {
     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 +559,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/cli/commands/index.js

@@ -35,6 +35,7 @@ export const GROUPS_HELP = `
   bolloon task      list | status | result | retry | run | send|inbox|accept|reject|complete|cancel(未实现)
                     publish|board|claim   (任务对外发布 + 接单: 公告板)
                     announce|trail|post   (群聊通道 C7: 公告入群 / 过程留痕回看 / 交付·初筛·终审痕迹)
+                    group create|join|list|link|leave   (群管理: 建群/自助入群/看群/取链接/退群)
   bolloon wallet    status | policy | set-policy
   bolloon payment   pending | approve | reject
   bolloon trade     list | show | events | reconcile