@bolloon/bolloon-agent 0.1.34 → 0.1.36

package/dist/llm/tool-manifest/web.js

@@ -0,0 +1,51 @@
+export const web_search = {
+    id: 'web_search',
+    name: 'web_search',
+    oneLine: '搜索 Web (返回前 10 条结果).',
+    description: '当需要当前信息或信息可能自知识截止以来已发生变化时使用. 1-6 词查询最佳. 默认改写; 引用应是个罕见的例外.',
+    whenToUse: [
+        '当前状态 (谁担任某职位、什么政策生效)',
+        '时效性信息 (股价、新闻)',
+        '不识别的实体 (默认搜索)',
+    ],
+    whenNotToUse: [
+        '永恒信息/成熟技术事实 (直接答)',
+        '已故人物 (不会变)',
+    ],
+    parameters: [
+        { name: 'query', type: 'string', required: true, description: '搜索查询 (1-6 词最佳)' },
+    ],
+    callExample: `[TOOL:web_search]
+[P:query]S&P 500 current price
+[ENDTOOL]`,
+    layerId: 'tool.web_search',
+};
+export const web_fetch = {
+    id: 'web_fetch',
+    name: 'web_fetch',
+    oneLine: '获取指定 URL 网页的内容.',
+    description: '此函数只能获取用户直接提供的或由 web_search 和 web_fetch 工具的结果中返回的 EXACT URL. 此工具无法访问需要身份验证的内容, 例如私有 Google Docs 或登录墙后的页面. URL 必须包含协议.',
+    whenToUse: [
+        'web_search 摘要不够, 需要读完整文章',
+        '用户提供 URL 让你读',
+    ],
+    whenNotToUse: [
+        '需要身份验证的页面',
+        'web_search 已经足够时',
+    ],
+    parameters: [
+        { name: 'url', type: 'string', required: true, description: '完整 URL (含协议, https://...)', format: 'uri' },
+        { name: 'allowed_domains', type: 'array', required: false, description: '仅允许的域名白名单 (如 ["example.com","*.github.com"])', items: { name: 'd', type: 'string', required: true, description: '域名' } },
+        { name: 'blocked_domains', type: 'array', required: false, description: '黑名单域名', items: { name: 'd', type: 'string', required: true, description: '域名' } },
+        { name: 'html_extraction_method', type: 'string', required: false, description: 'HTML 提取方法 (e.g. "text"/"markdown")' },
+        { name: 'is_zdr', type: 'boolean', required: false, description: '是否 Zero Data Retention 请求 (true 时不记录 URL)' },
+        { name: 'text_content_token_limit', type: 'integer', required: false, description: 'token 限制', minimum: 0 },
+        { name: 'web_fetch_pdf_extract_text', type: 'boolean', required: false, description: '是否提取 PDF 文本' },
+        { name: 'web_fetch_rate_limit_key', type: 'string', required: false, description: '速率限制键' },
+        { name: 'web_fetch_rate_limit_dark_launch', type: 'boolean', required: false, description: '速率限制暗启动模式' },
+    ],
+    callExample: `[TOOL:web_fetch]
+[P:url]https://example.com/article
+[ENDTOOL]`,
+    layerId: 'tool.manifest',
+};

package/dist/network/p2p-direct.js

@@ -64,6 +64,29 @@ export class P2PDirect extends EventEmitter {
             conn.on('data', (chunk) => {
                 const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 console.log(`[P2PDirect:${this.name}] 收到数据 from ${remotePubKeyHex.substring(0, 12)}... (${buf.length} bytes)`);
+                // P-Action 3: untrusted-input scanner (默认 silence-on-fail + log-only)
+                // 包装层 跨机器 @-mention 代发 (已 WORKING) 不能 block-on-suspicion
+                try {
+                    // 动态 import 避免循环依赖 + 启动时加载
+                    // (lazy require to keep cold-start fast)
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const { scanInput, writeScanAudit, shouldHardBlock } = require('../security/input-scanner.js');
+                    const result = scanInput(buf, { source: 'p2p' });
+                    if (shouldHardBlock(result)) {
+                        console.warn(`[P2PDirect:${this.name}] 阻断恶意消息 from ${remotePubKeyHex.substring(0, 12)}... (verdict=${result.verdict}, threats=${result.threats.length})`);
+                        writeScanAudit(result, { fromPublicKey: remotePubKeyHex, blocked: true }).catch(() => { });
+                        return; // 不 emit('data'), 跨机中转不传播
+                    }
+                    if (result.verdict !== 'pass') {
+                        // log-only: 仍然 emit('data'), 但写 audit 留痕
+                        writeScanAudit(result, { fromPublicKey: remotePubKeyHex, blocked: false }).catch(() => { });
+                        console.log(`[P2PDirect:${this.name}] 输入扫描 verdict=${result.verdict} (${result.threats.length} threats) from ${remotePubKeyHex.substring(0, 12)}... (audit-only)`);
+                    }
+                }
+                catch (err) {
+                    // scanner 自身挂掉 → 静默, 不阻断
+                    console.warn(`[P2PDirect:${this.name}] input scanner failed (silent, fail-safe):`, err);
+                }
                 this.emit('data', {
                     data: buf,
                     fromPublicKey: remotePubKeyHex,

package/dist/network/source-intent-broadcaster.js

@@ -0,0 +1,203 @@
+/**
+ * source-intent-broadcaster.ts — 包装 P2PDirect, 收发 SourceIntentMsg
+ *
+ * 用法:
+ *   const p2p = new P2PDirect({ name: 'bolloon', role: 'source-agent' });
+ *   await p2p.start();
+ *   const sb = new SourceIntentBroadcaster(p2p, { agent: 'agent-A@mac1' });
+ *   await sb.start();
+ *
+ *   // 我方要改 src/foo.ts 行 42-50
+ *   const conflict = await sb.reserve({ taskId, file: 'src/foo.ts', lines: [42, 50] });
+ *   if (conflict) {
+ *     // 对方已 reserve, 选: 让出 / 改别的 / 强制
+ *   } else {
+ *     sb.writeFileAndCommit(...);
+ *     await sb.broadcastCommitIntent({ taskId, file, lines, sha, diffHash });
+ *   }
+ *
+ * 主题: 复用现有 'bolloon-agent-harness' topic (P2PDirect 已 join),
+ *       上层加 'source-intent:' 前缀避免和别的协议混.
+ */
+import { EventEmitter } from 'events';
+import { ReserveLock, } from './source-intent.js';
+export class SourceIntentBroadcaster extends EventEmitter {
+    p2p;
+    agent;
+    topic;
+    waitMs;
+    lock = new ReserveLock();
+    started = false;
+    dataHandler = null;
+    constructor(p2p, opts) {
+        super();
+        this.p2p = p2p;
+        this.agent = opts.agent;
+        this.topic = opts.topic || 'bolloon-agent-harness';
+        this.waitMs = opts.waitMs ?? 200;
+    }
+    async start() {
+        if (this.started)
+            return;
+        // 确保 p2p 已 join topic
+        await this.p2p.joinTopic(this.topic);
+        this.dataHandler = (data, from) => {
+            try {
+                const text = data.toString('utf8');
+                // 协议前缀 'source-intent:'
+                if (!text.startsWith('source-intent:'))
+                    return;
+                const json = text.slice('source-intent:'.length);
+                const msg = JSON.parse(json);
+                this.onMessage(msg, from);
+            }
+            catch (err) {
+                // 静默忽略非本协议消息
+            }
+        };
+        this.p2p.on('data', this.dataHandler);
+        this.started = true;
+    }
+    stop() {
+        if (!this.started)
+            return;
+        if (this.dataHandler)
+            this.p2p.off('data', this.dataHandler);
+        this.started = false;
+    }
+    /**
+     * 申请 reserve (file, lines).
+     * 返回 {ok:true} → 成功 (没有重叠)
+     * 返回 {ok:false, existing} → 本地 lock 已有重叠, LLM 决定让出 / 改方向 / 强制
+     */
+    async reserve(args) {
+        const now = Date.now();
+        const msg = {
+            type: 'reserve',
+            taskId: args.taskId,
+            agent: this.agent,
+            file: args.file,
+            lines: args.lines,
+            expiresAt: now + ReserveLock.TTL_MS,
+            ts: now,
+        };
+        // 1. 先查本地 lock: 本端/远端任何 reserve 重叠都立即冲突 (避免 [5,15] 漏检 [1,10])
+        const existing = this.lock.isReserved(args.file, args.lines);
+        if (existing) {
+            return { ok: false, existing: { agent: existing.agent, lines: existing.lines } };
+        }
+        // 2. 写本地 lock
+        this.lock.add({
+            taskId: msg.taskId,
+            agent: msg.agent,
+            file: msg.file,
+            lines: msg.lines,
+            expiresAt: msg.expiresAt,
+            ts: msg.ts,
+        });
+        // 3. 广播
+        this.broadcastMsg(msg);
+        // 4. 等待 waitMs 看远端是否 ack 同一区间
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.off('remoteConflict', onRemote);
+                resolve({ ok: true });
+            }, this.waitMs);
+            const onRemote = (existing) => {
+                clearTimeout(timer);
+                resolve({ ok: false, existing });
+            };
+            this.once('remoteConflict', onRemote);
+        });
+    }
+    /** 释放我方 reserve */
+    release(args) {
+        const msg = {
+            type: 'release',
+            taskId: args.taskId,
+            agent: this.agent,
+            file: args.file,
+            lines: args.lines,
+            ts: Date.now(),
+        };
+        this.lock.release(args.file, args.lines);
+        this.broadcastMsg(msg);
+    }
+    /** commit 后广播, 供对方做轻量审计 (diffHash 验真伪) */
+    async broadcastCommitIntent(args) {
+        const msg = {
+            type: 'commit-intent',
+            taskId: args.taskId,
+            agent: this.agent,
+            file: args.file,
+            lines: args.lines,
+            sha: args.sha,
+            diffHash: args.diffHash,
+            ts: Date.now(),
+        };
+        this.broadcastMsg(msg);
+    }
+    /** 取所有 live reserves (给 pi-ai 注入到 LLM 系统 prompt) */
+    liveReserves() {
+        return this.lock.live();
+    }
+    // ---- 内部 ----
+    broadcastMsg(msg) {
+        const text = 'source-intent:' + JSON.stringify(msg);
+        this.p2p.broadcast(Buffer.from(text, 'utf8'));
+    }
+    onMessage(msg, from) {
+        // 忽略自己发出的消息 (P2PDirect 自身会发到自己的 loopback)
+        if (msg.agent === this.agent)
+            return;
+        switch (msg.type) {
+            case 'reserve': {
+                // 检查本地是否已 reserve 重叠区间
+                const existing = this.lock.isReserved(msg.file, msg.lines);
+                if (existing) {
+                    // 我方有重叠, 对方也 reserve → 触发 conflict
+                    this.emit('remoteConflict', { agent: msg.agent, lines: msg.lines });
+                    // 自己也回一个 ack 让对方知道我方已 reserve
+                    const ack = {
+                        type: 'ack',
+                        taskId: existing.taskId,
+                        agent: this.agent,
+                        file: existing.file,
+                        lines: existing.lines,
+                        ts: Date.now(),
+                    };
+                    this.broadcastMsg(ack);
+                }
+                // 记入 lock (远端的 reserve 我方也要避开, LLM 看 prompt 知道)
+                this.lock.add({
+                    taskId: msg.taskId,
+                    agent: msg.agent,
+                    file: msg.file,
+                    lines: msg.lines,
+                    expiresAt: msg.expiresAt,
+                    ts: msg.ts,
+                });
+                this.emit('remoteReserve', msg);
+                break;
+            }
+            case 'ack': {
+                // 远端 ack 我方已 reserve 同一区间 → 立即触发 conflict
+                const local = this.lock.isReserved(msg.file, msg.lines);
+                if (local) {
+                    this.emit('remoteConflict', { agent: msg.agent, lines: msg.lines });
+                }
+                break;
+            }
+            case 'release': {
+                this.lock.release(msg.file, msg.lines);
+                this.emit('remoteRelease', msg);
+                break;
+            }
+            case 'commit-intent': {
+                this.lock.release(msg.file, msg.lines);
+                this.emit('remoteCommit', msg);
+                break;
+            }
+        }
+    }
+}

package/dist/network/source-intent.js

@@ -0,0 +1,100 @@
+/**
+ * source-intent.ts — 行级 P2P 协作: 类型 + reserve.lock
+ *
+ * 为什么: 两台机上的智能体要协作维护同一份源码仓库, 粗粒度 task 协调不够
+ * (同一文件不同行会冲突). 用行级 reserve 让 LLM 在改前先广播"我要改 X 行",
+ * 对方看到重叠可让出/改方向/强制 merge.
+ *
+ * 数据流 (P2P RPC 消息, 走现有 P2PDirect.broadcast):
+ *   reserve  →  我方申请改 file:[start,end]
+ *   ack      →  对方也在这区间, 互相知道, 等 commit-intent 时看谁先到
+ *   release  →  我方放弃 (LLM 决定改别的行)
+ *   commit-intent → 我方 commit 后广播, 附 diffHash, 对方用 diffHash 验真伪
+ *
+ * 兜底:
+ *   - TTL 5min, reserve 不 release 就过期
+ *   - 200ms 等待 + 检冲突, 极端 race 双方都收到 conflict, LLM 自己重选
+ *   - diffHash 不去判语义, 行级 merge 后 lefthook 失败 → revert
+ */
+import { EventEmitter } from 'events';
+/**
+ * 检测两个 LineRange 是否重叠.
+ * 规则: 任一区间的一端落在对方区间内 → 重叠.
+ * 不重叠示例: [1,5] vs [6,10] (边界相邻不算重叠).
+ */
+export function rangesOverlap(a, b) {
+    return a[0] <= b[1] && b[0] <= a[1];
+}
+/**
+ * ReserveLock — 本地内存表, 记录"我方 + 远端"所有 live reserves.
+ *
+ * 事件:
+ *   'added'    新增 reserve (我方或远端)
+ *   'removed'  reserve 被释放 / 过期
+ *   'conflict' 检测到重叠 (a,b)
+ */
+export class ReserveLock extends EventEmitter {
+    /** key = `${file}:${start}-${end}` */
+    byKey = new Map();
+    /** TTL: 5 min, 兜底防止对方死掉/网络断后 reserve 永远不释放 */
+    static TTL_MS = 5 * 60 * 1000;
+    /** 清理过期 reserve, 触发 'removed' 事件 */
+    sweep(now = Date.now()) {
+        for (const [k, r] of this.byKey) {
+            if (r.expiresAt <= now) {
+                this.byKey.delete(k);
+                this.emit('removed', r);
+            }
+        }
+    }
+    /** 我方/远端 reserve, 仅清自己区间后写入 (不清全表, 避免过期 reserve 干扰 add 测试) */
+    add(r) {
+        const key = keyOf(r.file, r.lines);
+        const prev = this.byKey.get(key);
+        this.byKey.set(key, r);
+        if (prev) {
+            // 同一区间已被对方 reserve, 我方再 reserve → 触发冲突
+            this.emit('conflict', { a: prev, b: r });
+        }
+        else {
+            this.emit('added', r);
+        }
+    }
+    /** 释放指定 reserve (我方 LLM 决定让出时调用) */
+    release(file, lines) {
+        const key = keyOf(file, lines);
+        const r = this.byKey.get(key);
+        if (!r)
+            return null;
+        this.byKey.delete(key);
+        this.emit('removed', r);
+        return r;
+    }
+    /** 查询某 (file, lines) 是否已被 reserve (含我方) */
+    isReserved(file, lines, now = Date.now()) {
+        this.sweep(now);
+        for (const r of this.byKey.values()) {
+            if (r.file === file && rangesOverlap(r.lines, lines)) {
+                return r;
+            }
+        }
+        return null;
+    }
+    /** 取所有 live reserves (给 pi-ai 注入到系统 prompt) */
+    live(now = Date.now()) {
+        this.sweep(now);
+        return [...this.byKey.values()];
+    }
+    /** 调试: dump 全部 */
+    dump() {
+        return [...this.byKey.values()];
+    }
+}
+function keyOf(file, lines) {
+    return `${file}:${lines[0]}-${lines[1]}`;
+}
+/** 算 diffHash (git diff 的 sha256 前 16 字符) */
+export function diffHashOf(diffText) {
+    const crypto = require('crypto');
+    return crypto.createHash('sha256').update(diffText, 'utf8').digest('hex').slice(0, 16);
+}

package/dist/pi-ecosystem-judgment/adaptive-scan.js

@@ -0,0 +1,279 @@
+/**
+ * Adaptive Scan — 类 B 自迭代入口
+ *
+ * 扫描 ~/.bolloon/human-values/usage.jsonl + judgments.json,
+ * 生成"自适应建议" (只读, 不改库). 用户在 UI 接受/拒绝后
+ * 才会真正生效, 写入 evolution.jsonl 留作审计.
+ *
+ * 设计原则 (类 B 边界):
+ * - 不自动改库 (避免 AI 越权)
+ * - 所有建议可逆 (接受/拒绝都行, 接受后写 evolution.jsonl 留痕)
+ * - 失败静默 (主对话不阻塞)
+ * - 单次扫描纯本地 + 内存计算, 无 LLM 调用 (避免 LLM 幻觉污染)
+ *
+ * 触发时机:
+ * - 用户主动: UI "📊 自适应" tab 点 "重新扫描"
+ * - 被动: 每天首次进入判断力 modal 时自动跑一次 (缓存 24h)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { loadAllJudgments } from './human-value-store.js';
+// 用 getter 函数而非模块顶层 const: process.env.HOME 在测试 beforeAll 才设,
+// 模块顶层求值时还是真 home. 运行时求值才能正确响应测试 fixture.
+function getUsageLogPath() {
+    return (os.homedir() || process.env.HOME || '/tmp') + '/.bolloon/human-values/usage.jsonl';
+}
+function getEvolutionLogPath() {
+    return (os.homedir() || process.env.HOME || '/tmp') + '/.bolloon/human-values/evolution.jsonl';
+}
+/**
+ * P-Action 1: next-action hint (4 仓库都强调的错误信息 = 修复指令 思想)
+ * - deusyu: "Lint error messages should embed fix instructions, turning them into
+ *   a self-correction loop the agent can execute."
+ * - walkinglabs lecture 10: "POST /api/reset-password returned 500. Check that
+ *   the email service config exists..." 而非 "Test failed"
+ * - 马书 Capybara v8 4-class behavior mitigation
+ * - china-qijizhifeng Agent Debugger LLM 分析
+ *
+ * 在 adaptive-scan 启发式产出 hint, 不调 LLM (保持类 B 失败静默 + 无 LLM 不变量)
+ */
+export function suggestionHint(kind, action, metrics) {
+    switch (kind) {
+        case 'stale':
+            return action === 'deprecate'
+                ? `此判断力 30+ 天未使用 (last ${metrics.daysSinceLastUse}d ago, total ${metrics.totalUsage}×). 建议: 接受废弃前, 跑一次 'npm run judgments:search "<topic>"' 确认是否真的不再相关; 若仍相关, 用 boost + active 标签标记, 不要 deprecate.`
+                : `Stale judgment 建议: review 后 决定 boost / deprecate. 7d 用量 ${metrics.usage7d}× 30d 用量 ${metrics.usage30d}×.`;
+        case 'rising':
+            return `🔥 30 天内用量翻倍 (7d=${metrics.usage7d}×, 30d=${metrics.usage30d}×). 建议: 接受 boost 提升该 judgment 的注入优先级; 同时检查 conflicts.jsonl 看是否与其他判断力冲突.`;
+        case 'unused':
+            return `此判断力从未被注入 (total ${metrics.totalUsage}× = 0). 建议: (1) 跑 'npm run judgments:debug <id>' 确认检测钩子是否正常工作; (2) 若是 false positive, 接受 reject; (3) 若需要激活, 接受 review + 触发 D 路径蒸馏.`;
+        case 'causal_conflict':
+            return `检测到与另一判断力因果冲突. 建议: 接受 review 后, 优先保留因果强度 (causal power) 高的那条; 或在 persona.json 加一条 human override. 详细因果矩阵: '~/.bolloon/human-values/causal-matrix.json'.`;
+        case 'low_causal_power':
+            return `此判断力的因果强度持续低 (causal power < 0.3). 建议: 接受 review 后考虑 deprecate; 跑 'npm run causal:audit <id>' 看是哪条 related event 拉低了分数.`;
+        default:
+            return `建议 review: ${action} 这条 judgment. 7d 用量 ${metrics.usage7d}× 30d 用量 ${metrics.usage30d}×.`;
+    }
+}
+const DAY_MS = 24 * 60 * 60 * 1000;
+async function readUsageLog() {
+    try {
+        const content = await fs.readFile(getUsageLogPath(), 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        return lines
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => Boolean(e) && Array.isArray(e?.usedIds));
+    }
+    catch {
+        return [];
+    }
+}
+function countByJudgment(entries) {
+    const now = Date.now();
+    const cutoff7d = now - 7 * DAY_MS;
+    const cutoff30d = now - 30 * DAY_MS;
+    const map = new Map();
+    for (const e of entries) {
+        const ts = new Date(e.ts).getTime();
+        for (const id of e.usedIds) {
+            const cur = map.get(id) || { total: 0, last7d: 0, last30d: 0, lastUseTs: null };
+            cur.total++;
+            if (ts >= cutoff7d)
+                cur.last7d++;
+            if (ts >= cutoff30d)
+                cur.last30d++;
+            if (cur.lastUseTs === null || ts > cur.lastUseTs)
+                cur.lastUseTs = ts;
+            map.set(id, cur);
+        }
+    }
+    return map;
+}
+/**
+ * 主扫描函数: 纯本地计算, 无 LLM
+ */
+export async function runAdaptiveScan() {
+    const now = new Date();
+    const nowTs = now.getTime();
+    const [judgments, entries] = await Promise.all([
+        loadAllJudgments(),
+        readUsageLog(),
+    ]);
+    const usage = countByJudgment(entries);
+    const suggestions = [];
+    for (const j of judgments) {
+        if ((j.status ?? 'active') !== 'active')
+            continue;
+        const id = j.id;
+        const u = usage.get(id) || { total: 0, last7d: 0, last30d: 0, lastUseTs: null };
+        const daysSinceLastUse = u.lastUseTs === null
+            ? Math.floor((nowTs - new Date(j.timestamp).getTime()) / DAY_MS)
+            : Math.floor((nowTs - u.lastUseTs) / DAY_MS);
+        const metrics = {
+            usage7d: u.last7d,
+            usage30d: u.last30d,
+            daysSinceLastUse,
+            totalUsage: u.total,
+        };
+        // rising: 7 天频率 > 30 天均值的 1.5 倍, 且至少用过 2 次 (避免噪声)
+        if (u.last30d > 0 && u.last7d >= 2) {
+            const dailyAvg30 = u.last30d / 30;
+            const dailyRate7 = u.last7d / 7;
+            if (dailyRate7 > dailyAvg30 * 1.5) {
+                suggestions.push({
+                    key: `rising:${id}`,
+                    kind: 'rising',
+                    judgmentId: id,
+                    decision: j.decision,
+                    reason: `7 天使用率 (${dailyRate7.toFixed(2)}/d) 是 30 天均值的 ${(dailyRate7 / dailyAvg30).toFixed(1)} 倍`,
+                    action: 'boost',
+                    hint: suggestionHint('rising', 'boost', metrics),
+                    metrics,
+                    scannedAt: now.toISOString(),
+                });
+                continue; // 不再归入 unused/stale
+            }
+        }
+        // stale: 90 天未使用 + 总使用 < 3 (低频 + 长期不用)
+        if (u.total < 3 && daysSinceLastUse >= 90) {
+            suggestions.push({
+                key: `stale:${id}`,
+                kind: 'stale',
+                judgmentId: id,
+                decision: j.decision,
+                reason: `已 ${daysSinceLastUse} 天未使用, 总使用仅 ${u.total} 次`,
+                action: 'deprecate',
+                hint: suggestionHint('stale', 'deprecate', metrics),
+                metrics,
+                scannedAt: now.toISOString(),
+            });
+            continue;
+        }
+        // unused: 30 天未使用 + 总使用 < 5 (中频但近期没在用)
+        if (u.total < 5 && daysSinceLastUse >= 30) {
+            suggestions.push({
+                key: `unused:${id}`,
+                kind: 'unused',
+                judgmentId: id,
+                decision: j.decision,
+                reason: `已 ${daysSinceLastUse} 天未使用, 总使用 ${u.total} 次 (可能不再相关)`,
+                action: 'review',
+                hint: suggestionHint('unused', 'review', metrics),
+                metrics,
+                scannedAt: now.toISOString(),
+            });
+        }
+    }
+    // 按 action 重要性排序: rising > stale > unused
+    const order = { rising: 0, stale: 1, unused: 2, causal_conflict: 3, low_causal_power: 4 };
+    // 阶段 2: causal_conflict — judgment 库内自动检测冲突对
+    const { runConflictDetection } = await import('./causal-judge.js');
+    const conflictResult = await runConflictDetection();
+    for (const a of judgments) {
+        if ((a.status ?? 'active') !== 'active')
+            continue;
+        if (!Array.isArray(a.conflictWith) || a.conflictWith.length === 0)
+            continue;
+        // 列出每对冲突 (limit 每个 judgment 最多 3 对, 避免 UI 刷屏)
+        const conflicts = a.conflictWith.slice(0, 3);
+        for (const otherId of conflicts) {
+            const other = judgments.find((j) => j.id === otherId);
+            if (!other)
+                continue;
+            const c = await import('./causal-judge.js');
+            const det = c.detectConflict(a, other);
+            suggestions.push({
+                key: `causal_conflict:${a.id}:${other.id}`,
+                kind: 'causal_conflict',
+                judgmentId: a.id,
+                decision: `${a.decision} ↔ ${other.decision}`,
+                reason: det.isConflict ? det.reason : '库内已标冲突, 需 LLM 复核',
+                action: 'review',
+                hint: suggestionHint('causal_conflict', 'review', { usage7d: 0, usage30d: 0, daysSinceLastUse: 0, totalUsage: 0 }),
+                metrics: { usage7d: 0, usage30d: 0, daysSinceLastUse: 0, totalUsage: 0 },
+                scannedAt: now.toISOString(),
+            });
+        }
+    }
+    // 静默 conflictResult.detected 计数 (已通过 import 触发了)
+    void conflictResult;
+    // 阶段 2: low_causal_power — 留空 (依赖 do-calculus 跑过后的低边际贡献记录)
+    // 当前不主动跑 (cost 高), 仅在 UI 手动触发后, 类 B 下次扫描时捡起来
+    // 此处不实现, 留作下个迭代
+    suggestions.sort((a, b) => order[a.kind] - order[b.kind]);
+    return {
+        scannedAt: now.toISOString(),
+        judgmentsTotal: judgments.length,
+        usageEntriesScanned: entries.length,
+        suggestions,
+    };
+}
+export async function logEvolution(entry) {
+    try {
+        // P-Action 3: 摄入点扫描 (只跳 prompt-injection, 不扫 PII — judgment 决策文本含人话是合法的)
+        const { scanInput, writeScanAudit, shouldHardBlock } = await import('../security/input-scanner.js');
+        const fieldsToScan = [
+            entry.suggestion?.decision ?? '',
+            entry.suggestion?.reason ?? '',
+        ].join('\n');
+        const result = scanInput(fieldsToScan, { source: 'judgment', scanPii: false });
+        if (shouldHardBlock(result)) {
+            console.warn(`[adaptive-scan] logEvolution 阻断恶意 entry: verdict=${result.verdict}, threats=${result.threats.length}`);
+            writeScanAudit(result, { evolutionKey: entry.suggestion?.key, blocked: true }).catch(() => { });
+            return; // 不写磁盘
+        }
+        if (result.verdict !== 'pass') {
+            writeScanAudit(result, { evolutionKey: entry.suggestion?.key, blocked: false }).catch(() => { });
+        }
+        await fs.mkdir(path.dirname(getEvolutionLogPath()), { recursive: true });
+        await fs.appendFile(getEvolutionLogPath(), JSON.stringify(entry) + '\n', 'utf-8');
+    }
+    catch (err) {
+        console.warn('[adaptive-scan] logEvolution failed:', err);
+    }
+}
+export async function readEvolutionLog(limit = 50) {
+    try {
+        const content = await fs.readFile(getEvolutionLogPath(), 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        return lines
+            .slice(-limit)
+            .reverse()
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => Boolean(e));
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================
+// 缓存: 避免每次打开 modal 都扫一次
+// ============================================================
+let lastScan = null;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+export async function getCachedScan(force = false) {
+    if (!force && lastScan && Date.now() - lastScan.at < CACHE_TTL_MS) {
+        return lastScan.result;
+    }
+    const result = await runAdaptiveScan();
+    lastScan = { at: Date.now(), result };
+    return result;
+}
+export function clearAdaptiveScanCache() {
+    lastScan = null;
+}