@bolloon/bolloon-agent 0.2.12 → 0.2.13

package/dist/network/peer-resource-bridge.js

@@ -0,0 +1,216 @@
+/**
+ * peer-resource-bridge.ts — 4 类资源 (groups/function/exportment/science) 的
+ *   本地读 + 远端落盘的统一封装.
+ *
+ * 设计目的 (2026-07-05):
+ *   peer-fs.ts 已经有完整路径 helpers (writeGroup/writeFunction/...) + reader (listPeerResources).
+ *   server.ts 三处要调 (两个 manifest.exchange.reply 落盘 + 一个 manifest.exchange 发送),
+ *   每处手写 4 个 await 又啰嗦又容易漏. 这里抽出来.
+ *
+ *   本地读: ~/.bolloon/local-resources/<category>/<id>.md frontmatter
+ *   远端落: peerFs.writeGroup/Function/Exportment/Science (atomic, 人类可读 md)
+ *
+ *   frontmatter 字段就是类型本身的字段 (id/name/description/...),
+ *   description 从 frontmatter 后面的第一个段落拿.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import * as peerFs from '../network/peer-fs.js';
+const HOME = process.env.BOLLOON_HOME || path.join(os.homedir(), '.bolloon');
+export const LOCAL_RESOURCES_ROOT = path.join(HOME, 'local-resources');
+const EMPTY = { groups: [], functions: [], exportments: [], sciences: [] };
+/**
+ * 简单 frontmatter 解析: 只支持 key: value / key: [..] (本文件自产自销, 不引第三方).
+ */
+function parseFrontmatter(text) {
+    const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m)
+        return { fields: {}, body: text };
+    const fields = {};
+    for (const line of m[1].split('\n')) {
+        const kv = line.match(/^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/);
+        if (!kv)
+            continue;
+        const key = kv[1];
+        let raw = kv[2].trim();
+        if (raw.startsWith('[') && raw.endsWith(']')) {
+            try {
+                fields[key] = JSON.parse(raw);
+                continue;
+            }
+            catch { }
+        }
+        if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+            try {
+                fields[key] = JSON.parse(raw);
+                continue;
+            }
+            catch { }
+        }
+        fields[key] = raw;
+    }
+    return { fields, body: m[2].trim() };
+}
+/**
+ * 从 ~/.bolloon/local-resources/<category>/<id>.md 读所有本地资源.
+ * 文件不存在 / 目录不存在 → 返回空数组 (不报错, 跟 peer-fs 风格一致).
+ */
+async function readCategoryDir(category) {
+    try {
+        const dir = path.join(LOCAL_RESOURCES_ROOT, category);
+        const entries = await fs.readdir(dir);
+        return entries.filter((e) => e.endsWith('.md')).map((e) => path.join(dir, e));
+    }
+    catch {
+        return [];
+    }
+}
+async function readGroupFile(p) {
+    try {
+        const raw = await fs.readFile(p, 'utf-8');
+        const { fields, body } = parseFrontmatter(raw);
+        if (!fields.id)
+            return null;
+        return {
+            id: String(fields.id),
+            name: String(fields.name || fields.id),
+            description: body || undefined,
+            visibility: fields.visibility,
+            memberCount: typeof fields.memberCount === 'number' ? fields.memberCount : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readFunctionFile(p) {
+    try {
+        const raw = await fs.readFile(p, 'utf-8');
+        const { fields, body } = parseFrontmatter(raw);
+        if (!fields.capability)
+            return null;
+        return {
+            capability: String(fields.capability),
+            description: body || undefined,
+            mediaType: fields.mediaType,
+            endpoint: fields.endpoint ? String(fields.endpoint) : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readExportmentFile(p) {
+    try {
+        const raw = await fs.readFile(p, 'utf-8');
+        const { fields, body } = parseFrontmatter(raw);
+        if (!fields.name)
+            return null;
+        return {
+            name: String(fields.name),
+            description: body || undefined,
+            genre: fields.genre ? String(fields.genre) : undefined,
+            minPlayers: typeof fields.minPlayers === 'number' ? fields.minPlayers : undefined,
+            maxPlayers: typeof fields.maxPlayers === 'number' ? fields.maxPlayers : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readScienceFile(p) {
+    try {
+        const raw = await fs.readFile(p, 'utf-8');
+        const { fields, body } = parseFrontmatter(raw);
+        if (!fields.id)
+            return null;
+        return {
+            id: String(fields.id),
+            title: String(fields.title || fields.id),
+            description: body || undefined,
+            status: fields.status,
+            tags: Array.isArray(fields.tags) ? fields.tags.map(String) : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 读本机所有 4 类资源. 任何失败 → 该类别返回空 (不阻塞其他类别).
+ */
+export async function loadLocalResources() {
+    const out = { ...EMPTY };
+    const [gFiles, fFiles, eFiles, sFiles] = await Promise.all([
+        readCategoryDir('groups'),
+        readCategoryDir('functions'),
+        readCategoryDir('exportments'),
+        readCategoryDir('sciences'),
+    ]);
+    for (const f of gFiles) {
+        const v = await readGroupFile(f);
+        if (v)
+            out.groups.push(v);
+    }
+    for (const f of fFiles) {
+        const v = await readFunctionFile(f);
+        if (v)
+            out.functions.push(v);
+    }
+    for (const f of eFiles) {
+        const v = await readExportmentFile(f);
+        if (v)
+            out.exportments.push(v);
+    }
+    for (const f of sFiles) {
+        const v = await readScienceFile(f);
+        if (v)
+            out.sciences.push(v);
+    }
+    return out;
+}
+/**
+ * 把 manifest 里的 4 类资源落盘到 peerFs 对应目录.
+ * 静默容错: 单条失败不影响其他.
+ */
+export async function writeRemoteResources(publicKey, m) {
+    let groups = 0, functions = 0, exportments = 0, sciences = 0;
+    if (Array.isArray(m.groups)) {
+        for (const g of m.groups) {
+            try {
+                await peerFs.writeGroup(publicKey, g);
+                groups++;
+            }
+            catch { }
+        }
+    }
+    if (Array.isArray(m.functions)) {
+        for (const f of m.functions) {
+            try {
+                await peerFs.writeFunction(publicKey, f);
+                functions++;
+            }
+            catch { }
+        }
+    }
+    if (Array.isArray(m.exportments)) {
+        for (const e of m.exportments) {
+            try {
+                await peerFs.writeExportment(publicKey, e);
+                exportments++;
+            }
+            catch { }
+        }
+    }
+    if (Array.isArray(m.sciences)) {
+        for (const s of m.sciences) {
+            try {
+                await peerFs.writeScience(publicKey, s);
+                sciences++;
+            }
+            catch { }
+        }
+    }
+    return { groups, functions, exportments, sciences };
+}

package/dist/pi-ecosystem-judgment/causal-judge.js

@@ -81,21 +81,21 @@ function getLLM() {
     }
     return cachedModel;
 }
-const CORRELATION_PROMPT = `你是"判断力关联分析器"。给定两条 judgment:
-A: {a}
-B: {b}
-
-它们经常在同一对话里被同时注入 (共现 {co} 次).
-判断 A 与 B 的因果关系:
-- "A→B": A 引发 B (A 概念在 B 之前)
-- "B→A": B 引发 A
-- "common_cause": 共同原因 (e.g. 都是某场景触发)
-- "unclear": 关系不明确
-
-输出严格 JSON:
-{
-  "direction": "A→B" | "B→A" | "common_cause" | "unclear",
-  "explanation": "≤100 字解释, 含 1 个具体例"
+const CORRELATION_PROMPT = `你是"判断力关联分析器"。给定两条 judgment:
+A: {a}
+B: {b}
+
+它们经常在同一对话里被同时注入 (共现 {co} 次).
+判断 A 与 B 的因果关系:
+- "A→B": A 引发 B (A 概念在 B 之前)
+- "B→A": B 引发 A
+- "common_cause": 共同原因 (e.g. 都是某场景触发)
+- "unclear": 关系不明确
+
+输出严格 JSON:
+{
+  "direction": "A→B" | "B→A" | "common_cause" | "unclear",
+  "explanation": "≤100 字解释, 含 1 个具体例"
 }`;
 async function explainPair(judgmentA, judgmentB, coOccurrence) {
     const fallback = { direction: 'unclear', explanation: '(LLM 不可用, 仅显示统计)' };
@@ -213,21 +213,21 @@ export async function runCorrelationAnalysis(opts = {}) {
     }
     return out;
 }
-const INTERVENTION_PROMPT = `你是"判断力干预分析器"。判断力库有一条 judgment, 用户想评估它的边际贡献.
-给定:
-- judgment: {judgment}
-- 上次用过的场景 (user 输入 + AI 回复): {scenario}
-- 同时存在的相邻 judgment (供参考): {peers}
-
-模拟反事实推理: 如果库**没有**这条 judgment, AI 在同一场景下回答会怎么变?
-
-输出严格 JSON:
-{
-  "causalEffect": 0.0-1.0,  // 0 = 无影响, 1 = 行为完全变
-  "reasoning": "2-3 步推理, 含 1 个具体例",
-  "confidence": 0.0-1.0
-}
-
+const INTERVENTION_PROMPT = `你是"判断力干预分析器"。判断力库有一条 judgment, 用户想评估它的边际贡献.
+给定:
+- judgment: {judgment}
+- 上次用过的场景 (user 输入 + AI 回复): {scenario}
+- 同时存在的相邻 judgment (供参考): {peers}
+
+模拟反事实推理: 如果库**没有**这条 judgment, AI 在同一场景下回答会怎么变?
+
+输出严格 JSON:
+{
+  "causalEffect": 0.0-1.0,  // 0 = 无影响, 1 = 行为完全变
+  "reasoning": "2-3 步推理, 含 1 个具体例",
+  "confidence": 0.0-1.0
+}
+
 注意: causalEffect < 0 也合法 (如"没有这条 AI 反而更好" — 库污染)`;
 export async function runIntervention(judgmentId, opts = {}) {
     const fallback = {
@@ -273,27 +273,27 @@ export async function runIntervention(judgmentId, opts = {}) {
         return fallback;
     }
 }
-const COUNTERFACTUAL_PROMPT = `你是"判断力反事实审计员"。某次 AI 回复违反了注入的 judgment. 判断是库设计问题还是 LLM 偶然违规.
-
-事件:
-- 用户: {userInput}
-- AI 回复: {aiReply}
-- 违反原则: {principles}
-
-构造 3 个反事实 scenario:
-1. 删去最相关那条 judgment
-2. 把那条 judgment 改成反向 (例如"必须"→"避免")
-3. 删去整个 channel 的 judgment 库 (空库)
-
-每个 scenario 模拟 AI 在该库下的回答, 判断还会不会违规.
-
-输出严格 JSON:
-{
-  "scenarios": [
-    { "modification": "...", "outcomeCompliant": true/false, "explanation": "≤100 字" }
-  ],
-  "verdict": "库设计合理" | "建议调库" | "需更多数据",
-  "recomendaciones": "≤200 字, ≤3 条建议"
+const COUNTERFACTUAL_PROMPT = `你是"判断力反事实审计员"。某次 AI 回复违反了注入的 judgment. 判断是库设计问题还是 LLM 偶然违规.
+
+事件:
+- 用户: {userInput}
+- AI 回复: {aiReply}
+- 违反原则: {principles}
+
+构造 3 个反事实 scenario:
+1. 删去最相关那条 judgment
+2. 把那条 judgment 改成反向 (例如"必须"→"避免")
+3. 删去整个 channel 的 judgment 库 (空库)
+
+每个 scenario 模拟 AI 在该库下的回答, 判断还会不会违规.
+
+输出严格 JSON:
+{
+  "scenarios": [
+    { "modification": "...", "outcomeCompliant": true/false, "explanation": "≤100 字" }
+  ],
+  "verdict": "库设计合理" | "建议调库" | "需更多数据",
+  "recomendaciones": "≤200 字, ≤3 条建议"
 }`;
 export async function runCounterfactualAudit(opts) {
     const fallback = {

package/dist/pi-ecosystem-judgment/cleanup.js

@@ -0,0 +1,126 @@
+/**
+ * Judgment Cleanup — 检测并清理测试/灌水数据
+ *
+ * 垃圾来源:
+ *   1. 早期 test 文件直接调 storeHumanJudgment() 写 test fixture
+ *   2. 用户在 UI 「记录」时随手输的测试文本
+ *   3. D-hook (AI 自动蒸馏) 在 LLM 抽风时存了无意义内容
+ *
+ * 设计原则:
+ *   - 启发式检测, 不依赖外部 LLM (避免循环依赖)
+ *   - 删除 = 软删除 (status='rejected'), 保留审计追溯
+ *   - 写入时拦截 (storeHumanJudgment) + 读取时过滤 (getRelevantValues) 双保险
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * 命中任一即视为垃圾
+ * 注: 都是精确短语, 不会误伤含 "测试" 但有实质内容的判断力
+ */
+export const JUNK_DECISION_PATTERNS = [
+    /^loadAll\s*测试[你您\s:：/_-]*$/i,
+    /^Bolloon\s*bootstrap\s*测试[你您原则]*$/i,
+    /^[涨升]?\s*(rising|stale|cache|unused|健康|稳定|rising|上升|下降)\s*原则$/i,
+    /^(测试|test|example|示例)\s*$/i,
+    /^[测试tT]+$/,
+    /^(foo|bar|baz|hello world)\s*$/i,
+];
+/**
+ * 综合启发式: 内容是否像测试灌水?
+ */
+export function isJunkJudgment(j) {
+    if (!j || typeof j !== 'object')
+        return true;
+    const decision = String(j.decision ?? '').trim();
+    if (!decision)
+        return true; // 完全空 = 必定垃圾
+    // 启发式 1: 决策文本命中已知垃圾 pattern
+    if (JUNK_DECISION_PATTERNS.some((re) => re.test(decision)))
+        return true;
+    // 启发式 2: 短决策 + 无 values + 无 reasons (实质内容缺失)
+    const hasValues = Array.isArray(j.values_derived) && j.values_derived.length > 0;
+    const hasReasons = Array.isArray(j.reasons) && j.reasons.length > 0 &&
+        j.reasons.some((r) => r && String(r).trim().length > 0);
+    if (!hasValues && !hasReasons && decision.length < 12)
+        return true;
+    // 启发式 3: data corruption — 无 timestamp, 无 domain, decision 短
+    const hasTs = !!j.timestamp;
+    const domain = j.context?.domain;
+    if (!hasTs && (!domain || domain === 'general') && decision.length < 12)
+        return true;
+    // 启发式 4: decision 全是 whitespace / 标点 / 重复字符
+    if (/^[.\s,。、，\-_=:;!?]{0,8}$/.test(decision))
+        return true;
+    if (/^(.)\1{3,}$/.test(decision))
+        return true; // "aaaa"
+    return false;
+}
+/**
+ * 把判断力分桶: kept (可保留) + removed (应清理)
+ */
+export function classifyJudgments(judgments, opts = {}) {
+    const kept = [];
+    const removed = [];
+    const softDelete = opts.softDelete !== false; // 默认软删除
+    for (const j of judgments) {
+        if (isJunkJudgment(j)) {
+            // 软删除: 标记 status='rejected' 而非真正移除, 保留审计追溯
+            if (softDelete) {
+                removed.push({ ...j, status: 'rejected' });
+            }
+            else {
+                removed.push(j);
+            }
+        }
+        else {
+            kept.push(j);
+        }
+    }
+    return { kept, removed };
+}
+const VALUE_STORE_DIR = path.join(os.homedir(), '.bolloon', 'human-values');
+const JUDGMENTS_FILE = path.join(VALUE_STORE_DIR, 'judgments.json');
+async function ensureDir() {
+    await fs.mkdir(VALUE_STORE_DIR, { recursive: true });
+}
+async function readJudgmentsFile() {
+    await ensureDir();
+    try {
+        const raw = await fs.readFile(JUDGMENTS_FILE, 'utf-8');
+        const arr = JSON.parse(raw);
+        return Array.isArray(arr) ? arr : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 干跑 (推荐先跑这个看会清除多少):
+ *   返回报告, 不写盘
+ */
+export async function dryCleanup() {
+    const judgments = await readJudgmentsFile();
+    const { kept, removed } = classifyJudgments(judgments, { softDelete: false });
+    return {
+        totalBefore: judgments.length,
+        totalAfter: kept.length,
+        removed: removed.length,
+        sample: removed.slice(0, 10).map((j) => ({ id: j.id, decision: j.decision })),
+    };
+}
+/**
+ * 实际清理: 软删除 + 写回磁盘
+ * 保留 status='rejected' 的记录在盘上 (审计追溯)
+ */
+export async function runCleanup() {
+    const judgments = await readJudgmentsFile();
+    const { kept, removed } = classifyJudgments(judgments, { softDelete: true });
+    const finalized = [...kept, ...removed];
+    await fs.writeFile(JUDGMENTS_FILE, JSON.stringify(finalized, null, 2), 'utf-8');
+    return {
+        totalBefore: judgments.length,
+        totalAfter: kept.length,
+        removed: removed.length,
+    };
+}

package/dist/pi-ecosystem-judgment/distill-prompt.js

@@ -4,39 +4,39 @@
  * - 演化对齐: 判定新判断力与已有判断力的关系 (merge/contradict/unrelated)
  */
 import { getModel } from '../llm/pi-ai.js';
-const DISTILL_SYSTEM_PROMPT = `你是一个"判断力蒸馏器"。从给定的对话片段中,提取出**一条**可以长期复用的判断力原则。
-
-要求:
-- 长度 30-80 字(中文字符),软目标 50 字
-- 用陈述句,不要"我觉得/我想要"这种主观前缀
-- 要有可操作性,能被未来的自己/AI 引用
-- 如果对话里没有值得提炼的判断力,返回 {"value": null}
-
-输出格式(严格 JSON,无其他文字):
-{
-  "value": "<30-80 字的判断力>" | null,
-  "category": "rule" | "preference" | "trajectory" | "reward",
-  "confidence": 0.0-1.0,
-  "evidence": "<原文中支持这句话的关键句,不超过 30 字>"
+const DISTILL_SYSTEM_PROMPT = `你是一个"判断力蒸馏器"。从给定的对话片段中,提取出**一条**可以长期复用的判断力原则。
+
+要求:
+- 长度 30-80 字(中文字符),软目标 50 字
+- 用陈述句,不要"我觉得/我想要"这种主观前缀
+- 要有可操作性,能被未来的自己/AI 引用
+- 如果对话里没有值得提炼的判断力,返回 {"value": null}
+
+输出格式(严格 JSON,无其他文字):
+{
+  "value": "<30-80 字的判断力>" | null,
+  "category": "rule" | "preference" | "trajectory" | "reward",
+  "confidence": 0.0-1.0,
+  "evidence": "<原文中支持这句话的关键句,不超过 30 字>"
 }`;
-const EVOLVE_SYSTEM_PROMPT = `你是"判断力演化对齐器"。对比一条新判断力与已有判断力,判定关系。
-
-新判断力:
-{new_value}
-
-已有判断力列表(最多 10 条):
-{existing_list}
-
-对每条已有判断力,判定:
-- "merge": 新判断力是这条的更新版/具体版/纠正版 → 旧条应被 superseded
-- "contradict": 新判断力与这条方向相反(例如"保守"vs"激进") → 旧条应被 superseded
-- "unrelated": 两者主题不同,各自保留
-
-输出严格 JSON:
-{
-  "relations": [
-    {"id": "...", "relation": "merge" | "contradict" | "unrelated", "reason": "≤20 字"}
-  ]
+const EVOLVE_SYSTEM_PROMPT = `你是"判断力演化对齐器"。对比一条新判断力与已有判断力,判定关系。
+
+新判断力:
+{new_value}
+
+已有判断力列表(最多 10 条):
+{existing_list}
+
+对每条已有判断力,判定:
+- "merge": 新判断力是这条的更新版/具体版/纠正版 → 旧条应被 superseded
+- "contradict": 新判断力与这条方向相反(例如"保守"vs"激进") → 旧条应被 superseded
+- "unrelated": 两者主题不同,各自保留
+
+输出严格 JSON:
+{
+  "relations": [
+    {"id": "...", "relation": "merge" | "contradict" | "unrelated", "reason": "≤20 字"}
+  ]
 }`;
 let cachedModel = null;
 function getDistillModel() {
@@ -56,13 +56,13 @@ export async function detectIfWorthStoring(turns) {
     if (!model)
         return fallback;
     const conversation = formatTurns(turns);
-    const prompt = `请判断以下对话是否包含"值得长期保留的判断力"(用户的偏好/规则/原则/价值观)。
-如果包含,返回 {"worth": true, "reason": "≤20 字理由"}
-如果不包含,返回 {"worth": false, "reason": "≤20 字理由"}
-
-对话:
-${conversation}
-
+    const prompt = `请判断以下对话是否包含"值得长期保留的判断力"(用户的偏好/规则/原则/价值观)。
+如果包含,返回 {"worth": true, "reason": "≤20 字理由"}
+如果不包含,返回 {"worth": false, "reason": "≤20 字理由"}
+
+对话:
+${conversation}
+
 输出严格 JSON:`;
     try {
         const res = await withRetry(() => model.chat(prompt, '判断力检测专家'));
@@ -84,9 +84,9 @@ export async function distillFromConversation(turns) {
     if (!model)
         return fallback;
     const conversation = formatTurns(turns);
-    const userPrompt = `对话上下文(最多 10 轮):
-${conversation}
-
+    const userPrompt = `对话上下文(最多 10 轮):
+${conversation}
+
 输出:`;
     try {
         const res = await withRetry(() => model.chat(userPrompt, DISTILL_SYSTEM_PROMPT));

package/dist/pi-ecosystem-judgment/distillation.js

@@ -143,20 +143,20 @@ async function llmDistill(rawInput, trigger, context, conversationHistory) {
     const historyText = conversationHistory
         ? conversationHistory.slice(-5).join('\n')
         : 'No history';
-    const prompt = `从以下人类输入中提取判断力原理。
-
-输入类型: ${trigger}
-输入内容: ${rawInput}
-上下文: ${context}
-对话历史:
-${historyText}
-
-请提取：
-1. type: rule(明确规则) | preference(偏好) | trajectory(行为轨迹) | reward(奖励信号)
-2. content: 凝练后的原理（简洁，1-2句话）
-3. confidence: 0.0-1.0 的置信度
-4. evidence: 支持证据（如有）
-
+    const prompt = `从以下人类输入中提取判断力原理。
+
+输入类型: ${trigger}
+输入内容: ${rawInput}
+上下文: ${context}
+对话历史:
+${historyText}
+
+请提取：
+1. type: rule(明确规则) | preference(偏好) | trajectory(行为轨迹) | reward(奖励信号)
+2. content: 凝练后的原理（简洁，1-2句话）
+3. confidence: 0.0-1.0 的置信度
+4. evidence: 支持证据（如有）
+
 直接输出JSON格式，不需要解释。`;
     try {
         const response = await llmModel.chat(`对话: ${historyText}\n\n输入: ${rawInput}`, `你是判断力提取专家。从人类输入中提取判断力原理。输入类型: ${trigger}`);