@bolloon/bolloon-agent 0.1.34 → 0.1.35

package/dist/pi-ecosystem-judgment/human-value-store.js

@@ -15,6 +15,7 @@
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { createHash } from 'crypto';
 const VALUE_STORE_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'human-values');
 const JUDGMENTS_FILE = path.join(VALUE_STORE_DIR, 'judgments.json');
 // In-memory cache
@@ -49,14 +50,64 @@ export async function initializeValueStore() {
         throw error;
     }
 }
+// ============================================================
+// 阶段 2: Causal-judge 4 字段 migration
+// ============================================================
+/** TTL 默认 90 天 (用户可在 createUI 显式覆盖) */
+export const DEFAULT_TTL_DAYS = 90;
+/** 已 migration 标记 (避免每次 loadAllJudgments 都重写盘) */
+let migratedOnce = false;
+/**
+ * 给老数据补 4 字段默认值 (in-place).
+ * - expiresAt: createdAt + 90 天
+ * - appliesTo: undefined (适用所有)
+ * - conflictWith: []
+ * - causalChain: undefined
+ *
+ * 返回 true 表示这次实际有 migration (写盘时持久化), false 表示无变化
+ */
+export function migrateJudgmentInPlace(j) {
+    let changed = false;
+    if (j.expiresAt === undefined) {
+        const base = new Date(j.timestamp || Date.now());
+        base.setDate(base.getDate() + DEFAULT_TTL_DAYS);
+        j.expiresAt = base.toISOString();
+        changed = true;
+    }
+    if (j.conflictWith === undefined) {
+        j.conflictWith = [];
+        changed = true;
+    }
+    // appliesTo / causalChain 留空不补 (语义性, 由 causal-judge 自动填)
+    return changed;
+}
+/**
+ * 不可变版本: 返回新对象, 不 mutate 原 j. 供测试/谨慎场景用.
+ */
+export function migrateJudgmentImmutable(j) {
+    const next = { ...j };
+    migrateJudgmentInPlace(next);
+    return next;
+}
 /**
  * 存储人类判断
  */
 export async function storeHumanJudgment(judgment) {
+    const now = new Date().toISOString();
+    // 阶段 2: 4 字段默认值补全 (新 judgment)
+    if (!judgment.expiresAt) {
+        const expireDate = new Date();
+        expireDate.setDate(expireDate.getDate() + DEFAULT_TTL_DAYS);
+        judgment.expiresAt = expireDate.toISOString();
+    }
+    if (!Array.isArray(judgment.conflictWith)) {
+        judgment.conflictWith = [];
+    }
+    // 留空: appliesTo / causalChain 由后续 causal-judge 自动填
     const fullJudgment = {
         ...judgment,
         id: generateId(),
-        timestamp: new Date().toISOString()
+        timestamp: now
     };
     // 加载现有判断
     const judgments = await loadAllJudgments();
@@ -148,6 +199,10 @@ export async function updateJudgment(id, patch) {
         ...(patch.values_derived !== undefined ? { values_derived: patch.values_derived } : {}),
         ...(patch.context !== undefined ? { context: { ...cur.context, ...patch.context } } : {}),
         ...(patch.outcome !== undefined ? { outcome: { ...cur.outcome, ...patch.outcome } } : {}),
+        ...(patch.status !== undefined ? { status: patch.status } : {}),
+        ...(patch.supersededBy !== undefined ? { supersededBy: patch.supersededBy } : {}),
+        ...(patch.evolutionReason !== undefined ? { evolutionReason: patch.evolutionReason } : {}),
+        ...(patch.evolvedAt !== undefined ? { evolvedAt: patch.evolvedAt } : {}),
     };
     judgments[idx] = next;
     await saveJudgments(judgments);
@@ -155,6 +210,96 @@ export async function updateJudgment(id, patch) {
     valueProfileCache.clear();
     return next;
 }
+/**
+ * 按 status 过滤查询 (用于判断力库的 active/superseded tab)
+ * status='all' 或不传 → 返回所有
+ */
+export async function listJudgmentsByStatus(status) {
+    const judgments = await loadAllJudgments();
+    if (!status || status === 'all')
+        return judgments;
+    return judgments.filter((j) => (j.status ?? 'active') === status);
+}
+/**
+ * 内容 hash 用于去重窗口 (24h 滑窗内撞 hash 视为重复)
+ * 归一化: 去标点 + 折叠空白 + lowercase
+ * 64-bit 截断: 1 万条库碰撞率 < 1e-13, 够用
+ */
+export function hashDecision(decision) {
+    const normalized = decision
+        .toLowerCase()
+        .replace(/[\s,.，。、！？!?""''()（）:：;；\-—_]/g, '')
+        .trim();
+    return createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+}
+/**
+ * 在 withinMs 时间内查找与 decision hash 相同的判断力
+ * - 默认扫全库 (100 条库 < 1ms, 不建索引)
+ * - 可按 channelId 隔离 (判断力的 context.domain 是 'channel:xxx' 格式)
+ * - 当前实现只做精确 hash 匹配, 不做相似度评分; 撞 hash 即视为重复
+ */
+export async function findRecentSimilarDecisions(decision, withinMs, options) {
+    const judgments = await loadAllJudgments();
+    const targetHash = hashDecision(decision);
+    const cutoff = Date.now() - withinMs;
+    const statusFilter = options?.status ?? 'all';
+    const wantChannel = options?.channelId ? `channel:${options.channelId}` : null;
+    const out = [];
+    for (const j of judgments) {
+        if (statusFilter !== 'all' && (j.status ?? 'active') !== statusFilter)
+            continue;
+        if (new Date(j.timestamp).getTime() < cutoff)
+            continue;
+        if (wantChannel) {
+            const jChannel = j.context?.domain;
+            if (jChannel !== wantChannel)
+                continue;
+        }
+        if (hashDecision(j.decision) === targetHash) {
+            out.push({ id: j.id, decision: j.decision, timestamp: j.timestamp, similarity: 1.0 });
+        }
+    }
+    return out;
+}
+/**
+ * 批量更新 (用于演化对齐后批量标 superseded)
+ * 写完文件 + 清缓存
+ * 返回成功更新的条数
+ */
+export async function batchUpdateJudgments(updates) {
+    const judgments = await loadAllJudgments();
+    const notFound = [];
+    let updated = 0;
+    const next = judgments.map((cur) => {
+        const u = updates.find((x) => x.id === cur.id);
+        if (!u)
+            return cur;
+        updated++;
+        return { ...cur, ...u.patch };
+    });
+    for (const u of updates) {
+        if (!judgments.some((j) => j.id === u.id))
+            notFound.push(u.id);
+    }
+    if (updated > 0) {
+        await saveJudgments(next);
+        valueProfileCache.clear();
+    }
+    return { updated, notFound };
+}
+/**
+ * 更新单条 judgment (给"标记 rejected"等用)
+ * id 不变; 不能改 id, timestamp
+ * 允许改的字段: decision, decision_type, reasons, values_derived, context, outcome, status, supersededBy, evolutionReason, evolvedAt
+ */
+export async function updateJudgmentStatus(id, status, extra) {
+    return updateJudgment(id, {
+        status,
+        ...(extra?.supersededBy !== undefined ? { supersededBy: extra.supersededBy } : {}),
+        ...(extra?.evolutionReason !== undefined ? { evolutionReason: extra.evolutionReason } : {}),
+        ...(extra ? { evolvedAt: new Date().toISOString() } : {}),
+    });
+}
 /**
  * 删除一个判断.
  */
@@ -176,12 +321,42 @@ export async function loadAllJudgments() {
         await initializeValueStore();
     }
     if (judgmentCache.length > 0) {
+        // 早返回路径也要确保每条都有 status (防御性, 防止 saveJudgments 路径异常)
+        const needs = judgmentCache.some((j) => j.status === undefined);
+        if (needs) {
+            judgmentCache = judgmentCache.map((j) => j.status === undefined ? { ...j, status: 'active' } : j);
+        }
+        // 阶段 2: 4 字段 migration (in-place, 仅一次)
+        if (!migratedOnce) {
+            let anyChanged = false;
+            judgmentCache.forEach((j) => {
+                if (migrateJudgmentInPlace(j))
+                    anyChanged = true;
+            });
+            if (anyChanged) {
+                await saveJudgments(judgmentCache).catch(() => { });
+            }
+            migratedOnce = true;
+        }
         return [...judgmentCache];
     }
     try {
         const content = await fs.readFile(JUDGMENTS_FILE, 'utf-8');
-        judgmentCache = JSON.parse(content);
-        return judgmentCache;
+        const parsed = JSON.parse(content);
+        judgmentCache = parsed.map((j) => (j.status === undefined ? { ...j, status: 'active' } : j));
+        // 阶段 2: 4 字段 migration (in-place, 仅一次)
+        if (!migratedOnce) {
+            let anyChanged = false;
+            judgmentCache.forEach((j) => {
+                if (migrateJudgmentInPlace(j))
+                    anyChanged = true;
+            });
+            if (anyChanged) {
+                await saveJudgments(judgmentCache).catch(() => { });
+            }
+            migratedOnce = true;
+        }
+        return [...judgmentCache];
     }
     catch {
         judgmentCache = [];
@@ -190,49 +365,127 @@ export async function loadAllJudgments() {
 }
 /**
  * 获取相关价值观
- * 将 context 拆分为关键词，任意一个匹配即可
+ * 两路召回 (P2 升级):
+ * 1. 关键词匹配 (精确, 高权重)
+ * 2. bigram 软相似度 (措辞改写也能命中, 低权重)
+ * - 关键词完全匹配 → weight 不衰减
+ * - 软相似 > 0.4 → weight * 0.7 (留作辅助, 不冲掉精确命中)
  */
-export async function getRelevantValues(context, domain) {
+export async function getRelevantValues(context, domain, currentTool) {
     const judgments = await loadAllJudgments();
     const keywords = context.split(/[\s,，、]+/).filter(k => k.length >= 2);
     const contextLower = context.toLowerCase();
-    const relevant = judgments.filter(j => {
+    const relevant = [];
+    for (const j of judgments) {
         if (domain && j.context.domain !== domain)
-            return false;
+            continue;
+        // 阶段 2: appliesTo 路由 — 不匹配当前 tool 类别的 judgment 直接跳过
+        // appliesTo 为空 / undefined = 适用所有 (默认)
+        if (currentTool && Array.isArray(j.appliesTo) && j.appliesTo.length > 0) {
+            if (!j.appliesTo.includes(currentTool))
+                continue;
+        }
+        let matched = false;
+        let soft = 0;
         if (keywords.length === 0) {
-            return j.decision.toLowerCase().includes(contextLower) ||
-                j.reasons.some(r => r.toLowerCase().includes(contextLower));
+            if (j.decision.toLowerCase().includes(contextLower) ||
+                j.reasons.some(r => r.toLowerCase().includes(contextLower)) ||
+                j.values_derived.some(v => v.value.toLowerCase().includes(contextLower))) {
+                matched = true;
+            }
         }
-        const decisionLower = j.decision.toLowerCase();
-        const reasonsLower = j.reasons.map(r => r.toLowerCase());
-        return keywords.some(kw => {
-            const kwLower = kw.toLowerCase();
-            return decisionLower.includes(kwLower) ||
-                reasonsLower.some(r => r.includes(kwLower));
-        });
-    });
+        else {
+            const decisionLower = j.decision.toLowerCase();
+            const reasonsLower = j.reasons.map(r => r.toLowerCase());
+            // values_derived[i].value 也是索引一部分 (如 'security-first', 'privacy-first')
+            const valueTokens = j.values_derived.map(v => v.value.toLowerCase());
+            for (const kw of keywords) {
+                const kwLower = kw.toLowerCase();
+                if (decisionLower.includes(kwLower) ||
+                    reasonsLower.some(r => r.includes(kwLower)) ||
+                    valueTokens.some(vt => vt.includes(kwLower))) {
+                    matched = true;
+                }
+                else {
+                    // P2: 软相似度召回 — 关键词没命中, 但 bigram 相似度阈值
+                    // - 长句 (>8 字符): 阈值 0.4 (合理召回, 不易误触)
+                    // - 短句 (≤8 字符): 阈值 0.15 (bigram 模式天然偏低, 放宽避免漏召)
+                    const threshold = kw.length > 8 ? 0.4 : 0.15;
+                    const simA = softBigramSimilarity(kw, j.decision);
+                    const simReason = Math.max(0, ...j.reasons.map(r => softBigramSimilarity(kw, r)));
+                    const simValue = Math.max(0, ...valueTokens.map(vt => softBigramSimilarity(kw, vt)));
+                    const best = Math.max(simA, simReason, simValue);
+                    if (best > threshold)
+                        soft = Math.max(soft, best);
+                }
+            }
+        }
+        if (matched)
+            relevant.push({ j, softWeight: 1.0 });
+        else if (soft > 0)
+            relevant.push({ j, softWeight: soft });
+    }
     const valueMap = new Map();
-    for (const j of relevant) {
+    for (const { j, softWeight } of relevant) {
         for (const v of j.values_derived) {
             const key = `${v.category}:${v.value}`;
             const existing = valueMap.get(key);
             if (existing) {
                 existing.count++;
                 existing.tag.weight = Math.min(1, existing.tag.weight + 0.1);
+                existing.softFactor = Math.max(existing.softFactor, softWeight);
             }
             else {
-                valueMap.set(key, { tag: { ...v }, count: 1 });
+                valueMap.set(key, {
+                    tag: { ...v },
+                    count: 1,
+                    softFactor: softWeight,
+                });
             }
         }
     }
     return Array.from(valueMap.values())
-        .map(({ tag, count }) => ({
+        .map(({ tag, count, softFactor }) => ({
         ...tag,
-        weight: tag.weight * Math.min(1, count / 3)
+        // 软命中: 额外乘 0.7 衰减, 避免冲掉精确命中的排序
+        weight: tag.weight * Math.min(1, count / 3) * (softFactor >= 0.999 ? 1.0 : 0.7),
     }))
         .sort((a, b) => b.weight - a.weight)
         .slice(0, 10);
 }
+/**
+ * P2 软相似度: 用于"关键词未命中但措辞相近"的兜底召回
+ * - 与 evolve-judgment.ts 的 jaccardSimilarity 算法一致 (避免循环依赖, inline 一份)
+ * - 短句 (<8 字符) 走 bigram, 长句走单字 set
+ */
+function softBigramSimilarity(a, b) {
+    if (!a || !b)
+        return 0;
+    const normalize = (s) => s.toLowerCase().replace(/[\s,.，。、！？!?""''()（）:：;；\-—_]/g, '').trim();
+    const textA = normalize(a);
+    const textB = normalize(b);
+    if (textA.length === 0 || textB.length === 0)
+        return 0;
+    const grams = (s) => {
+        if (s.length < 8) {
+            const out = new Set();
+            for (let i = 0; i < s.length - 1; i++)
+                out.add(s.slice(i, i + 2));
+            for (const c of s)
+                out.add(c);
+            return out;
+        }
+        return new Set(s);
+    };
+    const setA = grams(textA);
+    const setB = grams(textB);
+    let inter = 0;
+    for (const c of setA)
+        if (setB.has(c))
+            inter++;
+    const union = setA.size + setB.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
 /**
  * 获取价值画像
  */
@@ -277,7 +530,15 @@ async function saveJudgments(judgments) {
     await fs.mkdir(VALUE_STORE_DIR, { recursive: true });
     await fs.writeFile(JUDGMENTS_FILE, JSON.stringify(judgments, null, 2), 'utf-8');
     // 让 loadAllJudgments 下次重新读盘, 避免缓存与磁盘脱节
-    judgmentCache = judgments;
+    // 同时在写盘时也补 status 默认值, 防止 loadAllJudgments 走早返回路径时绕过迁移
+    // 关键: 用浅拷贝 + spread 避免 mutate 入参 (storeHumanJudgment 返回的 fullJudgment 也会被改)
+    judgmentCache = judgments.map((j) => {
+        const next = { ...j };
+        if (next.status === undefined)
+            next.status = 'active';
+        migrateJudgmentInPlace(next);
+        return next;
+    });
 }
 function buildValueProfile(agentId, judgments) {
     const profile = {

package/dist/pi-ecosystem-judgment/injection-gate.js

@@ -0,0 +1,166 @@
+/**
+ * Judgment Injection Gate — LLM 调用前的"门"
+ *
+ * 作用: 在每次主对话 LLM chat() 调起前, 自动从判断力库检索 Top N
+ *       相关原则, 拼到 system prompt 尾部.
+ *
+ * 不做的事 (留作下个迭代):
+ * - 不拦 channel rename / 其他旁路 LLM 调用
+ * - 不在 AI 回复后做"违反检测" (那是 P3 持续监控门)
+ * - 不做 embedding 检索 (P2 替换 getRelevantValues 即可)
+ *
+ * 性能: 单次调用 < 5ms (关键词匹配 + 全表扫 100 条库)
+ * 失败: 静默 fallback (空字符串), 主对话不阻塞
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import { getRelevantValues, loadAllJudgments, } from './human-value-store.js';
+export const DEFAULT_INJECTION_CONFIG = {
+    topN: 3,
+    mode: 'standard',
+    skip: false,
+};
+/**
+ * 注入门主函数: 给定用户输入, 返回要追加到 system prompt 的文本 + 用到的判断力 id
+ *
+ * 静默: 任意步骤失败返回空字符串, 不 throw (主对话不阻塞)
+ */
+export async function injectJudgmentGate(userInput, ctx = {}, options = {}) {
+    const cfg = { ...DEFAULT_INJECTION_CONFIG, ...options };
+    if (cfg.skip || !userInput || userInput.trim().length === 0) {
+        return { systemAddition: '', usedIds: [], matchedCount: 0 };
+    }
+    try {
+        // 1. 拉相关价值观 (已带 weight 排序, Top 10)
+        const values = await getRelevantValues(userInput, ctx.domain);
+        if (values.length === 0) {
+            return { systemAddition: '', usedIds: [], matchedCount: 0 };
+        }
+        // 2. 选 Top N (按 weight desc)
+        const top = values.slice(0, cfg.topN);
+        // 3. 从顶层权重出发, 反查对应的 judgment id (供回溯记录)
+        //    同一 category+value 可能来自多条 judgment, 取最近一条 active
+        const usedIds = await resolveJudgmentIds(top);
+        // 4. 拼注入文本
+        const systemAddition = formatInjection(top, cfg.mode, usedIds.length);
+        return {
+            systemAddition,
+            usedIds,
+            matchedCount: values.length,
+        };
+    }
+    catch (err) {
+        console.warn('[injection-gate] failed (silent fallback):', err);
+        return { systemAddition: '', usedIds: [], matchedCount: 0 };
+    }
+}
+/**
+ * 反查 judgment id: 给定 [category, value], 在 active 库中找最近一条
+ * decision 包含该 value 描述的
+ */
+async function resolveJudgmentIds(values) {
+    if (values.length === 0)
+        return [];
+    try {
+        const all = await loadAllJudgments();
+        const active = all.filter((j) => (j.status ?? 'active') === 'active');
+        const ids = [];
+        const seen = new Set();
+        for (const v of values) {
+            // 找拥有 [category=v.category, value=v.value] 的最近一条 active judgment
+            // 不依赖 decision 文本包含 v.value (那是弱约束)
+            const hit = active.find((j) => j.values_derived.some((vd) => vd.category === v.category && vd.value === v.value));
+            if (hit && !seen.has(hit.id)) {
+                ids.push(hit.id);
+                seen.add(hit.id);
+            }
+        }
+        return ids;
+    }
+    catch {
+        return [];
+    }
+}
+function formatInjection(values, mode, resolvedCount) {
+    if (values.length === 0)
+        return '';
+    const header = mode === 'concise'
+        ? '\n# 用户判断力原则 (自动注入, 按相关度)\n'
+        : '\n# 用户的判断力原则 (自动注入, 按相关度排序)\n- 适用时主动遵守; 冲突时在回复中说明\n';
+    const lines = values.map((v, i) => {
+        if (mode === 'concise') {
+            return `${i + 1}. [${v.category}] ${v.value}`;
+        }
+        return `${i + 1}. [${v.category} · weight=${v.weight.toFixed(2)}] ${v.value}`;
+    });
+    const footer = resolvedCount > 0
+        ? `\n# (本轮注入了 ${resolvedCount} 条具体判断力, 已记录以便回溯)\n`
+        : '\n';
+    return header + lines.join('\n') + footer;
+}
+// ============================================================
+// 使用记录 (回溯): AI 实际"用了"哪些判断力
+// ============================================================
+const USAGE_LOG = (os.homedir() || '/tmp') + '/.bolloon/human-values/usage.jsonl';
+export async function recordJudgmentUsage(usedIds, meta) {
+    if (usedIds.length === 0)
+        return;
+    try {
+        const entry = {
+            ts: new Date().toISOString(),
+            channelId: meta.channelId ?? null,
+            userInputPreview: (meta.userInput ?? '').substring(0, 80),
+            usedIds,
+        };
+        await fs.appendFile(USAGE_LOG, JSON.stringify(entry) + '\n', 'utf-8');
+    }
+    catch (err) {
+        console.warn('[injection-gate] recordJudgmentUsage failed:', err);
+    }
+}
+/**
+ * 给定 channelId, 取最近 N 条 usage 记录 (UI 显示用)
+ */
+export async function getRecentUsage(channelId, limit = 20) {
+    try {
+        const content = await fs.readFile(USAGE_LOG, 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        const parsed = lines
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
+        const filtered = channelId
+            ? parsed.filter((p) => p.channelId === channelId)
+            : parsed;
+        return filtered.slice(-limit).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================
+// 便捷包装: 调 LLM + 注入门 + 记录回溯 (调用方接入用)
+// ============================================================
+/**
+ * 一步完成: 注入门 → 调 LLM → 记录 usage
+ * 调用方传入 LLM 实例 (duck-typed: { chat(message, systemPrompt) })
+ *
+ * - 默认 topN=3, mode='standard' (P1 防 prompt 膨胀已内置)
+ * - 任意步骤失败静默, 返回原 systemPrompt + 原始 chat 结果
+ */
+export async function chatWithJudgmentGate(llm, userInput, baseSystemPrompt, ctx = {}, options = {}) {
+    const gate = await injectJudgmentGate(userInput, ctx, options);
+    const systemPrompt = baseSystemPrompt + gate.systemAddition;
+    const reply = await llm.chat(userInput, systemPrompt);
+    // 异步记录使用 (不等)
+    if (gate.usedIds.length > 0) {
+        recordJudgmentUsage(gate.usedIds, { channelId: ctx.channelId, userInput }).catch((err) => console.warn('[injection-gate] recordJudgmentUsage async failed:', err));
+    }
+    return { reply: reply.reply, usedIds: gate.usedIds, matchedCount: gate.matchedCount };
+}