@bolloon/bolloon-agent 0.1.34 → 0.1.35

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

@@ -0,0 +1,226 @@
+/**
+ * Distill & Evolve Prompts
+ * - 蒸馏: 从对话片段提取 1 条 30-80 字的判断力
+ * - 演化对齐: 判定新判断力与已有判断力的关系 (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 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() {
+    if (cachedModel)
+        return cachedModel;
+    try {
+        cachedModel = getModel();
+    }
+    catch {
+        cachedModel = null;
+    }
+    return cachedModel;
+}
+export async function detectIfWorthStoring(turns) {
+    const fallback = { worth: false, reason: 'llm-unavailable' };
+    const model = getDistillModel();
+    if (!model)
+        return fallback;
+    const conversation = formatTurns(turns);
+    const prompt = `请判断以下对话是否包含"值得长期保留的判断力"(用户的偏好/规则/原则/价值观)。
+如果包含,返回 {"worth": true, "reason": "≤20 字理由"}
+如果不包含,返回 {"worth": false, "reason": "≤20 字理由"}
+
+对话:
+${conversation}
+
+输出严格 JSON:`;
+    try {
+        const res = await withRetry(() => model.chat(prompt, '判断力检测专家'));
+        return parseDetectResponse(res.reply, fallback);
+    }
+    catch (err) {
+        console.warn('[distill-prompt] detectIfWorthStoring failed:', err);
+        return fallback;
+    }
+}
+export async function distillFromConversation(turns) {
+    const fallback = {
+        value: null,
+        category: 'preference',
+        confidence: 0,
+        evidence: null,
+    };
+    const model = getDistillModel();
+    if (!model)
+        return fallback;
+    const conversation = formatTurns(turns);
+    const userPrompt = `对话上下文(最多 10 轮):
+${conversation}
+
+输出:`;
+    try {
+        const res = await withRetry(() => model.chat(userPrompt, DISTILL_SYSTEM_PROMPT));
+        return parseDistillResponse(res.reply, fallback);
+    }
+    catch (err) {
+        console.warn('[distill-prompt] distillFromConversation failed:', err);
+        return fallback;
+    }
+}
+export async function evolveWithLLM(newValue, existing) {
+    const fallback = { relations: [] };
+    const model = getDistillModel();
+    if (!model)
+        return fallback;
+    if (existing.length === 0)
+        return fallback;
+    const existingList = existing
+        .map((e, i) => `${i + 1}. [id="${e.id}"] ${e.value}`)
+        .join('\n');
+    const systemPrompt = EVOLVE_SYSTEM_PROMPT
+        .replace('{new_value}', newValue)
+        .replace('{existing_list}', existingList);
+    const userPrompt = '请输出 JSON:';
+    try {
+        const res = await withRetry(() => model.chat(userPrompt, systemPrompt));
+        return parseEvolveResponse(res.reply, existing, fallback);
+    }
+    catch (err) {
+        console.warn('[distill-prompt] evolveWithLLM failed:', err);
+        return fallback;
+    }
+}
+function formatTurns(turns) {
+    return turns
+        .slice(-10)
+        .map((t) => {
+        const role = t.role === 'human' ? '用户' : 'AI';
+        return `${role}: ${t.content}`;
+    })
+        .join('\n');
+}
+async function withRetry(fn, maxRetries = 2) {
+    let lastErr;
+    for (let i = 0; i <= maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < maxRetries) {
+                await new Promise((r) => setTimeout(r, 500 * Math.pow(2, i)));
+            }
+        }
+    }
+    throw lastErr;
+}
+function extractJson(text) {
+    const codeBlock = text.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+    if (codeBlock) {
+        try {
+            return JSON.parse(codeBlock[1]);
+        }
+        catch { /* fall through */ }
+    }
+    const first = text.indexOf('{');
+    const last = text.lastIndexOf('}');
+    if (first >= 0 && last > first) {
+        try {
+            return JSON.parse(text.substring(first, last + 1));
+        }
+        catch { /* fall through */ }
+    }
+    return null;
+}
+function parseDistillResponse(reply, fallback) {
+    const json = extractJson(reply);
+    if (!json || typeof json !== 'object')
+        return fallback;
+    const obj = json;
+    let value = typeof obj.value === 'string' ? obj.value.trim() : null;
+    if (value === null || value === '')
+        return { ...fallback, value: null };
+    if (value.length > 80)
+        value = value.substring(0, 80);
+    // < 20 字直接拒 (5 个中文字以下基本是噪声)
+    if (value.length < 20)
+        return { ...fallback, value: null };
+    // 20-30 字区间: 尝试补句号, 仍 < 20 才拒
+    if (value.length < 30 && !/[。.!！?？]$/.test(value)) {
+        value = value + '。';
+        if (value.length < 20)
+            return { ...fallback, value: null };
+    }
+    const category = ['rule', 'preference', 'trajectory', 'reward'].includes(String(obj.category))
+        ? obj.category
+        : 'preference';
+    const confidence = Math.max(0, Math.min(1, Number(obj.confidence) || 0.7));
+    const evidence = typeof obj.evidence === 'string' && obj.evidence.trim()
+        ? obj.evidence.trim().substring(0, 30)
+        : null;
+    return { value, category, confidence, evidence };
+}
+function parseDetectResponse(reply, fallback) {
+    const json = extractJson(reply);
+    if (!json || typeof json !== 'object')
+        return fallback;
+    const obj = json;
+    const worth = Boolean(obj.worth);
+    const reason = typeof obj.reason === 'string' ? obj.reason.substring(0, 20) : '';
+    return { worth, reason };
+}
+function parseEvolveResponse(reply, existing, fallback) {
+    const json = extractJson(reply);
+    if (!json || typeof json !== 'object')
+        return fallback;
+    const obj = json;
+    const relations = obj.relations;
+    if (!Array.isArray(relations))
+        return fallback;
+    const existingIds = new Set(existing.map((e) => e.id));
+    const validRelations = [];
+    for (const r of relations) {
+        if (!r || typeof r !== 'object')
+            continue;
+        const item = r;
+        const id = typeof item.id === 'string' ? item.id : '';
+        if (!existingIds.has(id))
+            continue;
+        const relation = item.relation;
+        if (relation !== 'merge' && relation !== 'contradict' && relation !== 'unrelated')
+            continue;
+        const reason = typeof item.reason === 'string' ? item.reason.substring(0, 20) : '';
+        validRelations.push({ id, relation, reason });
+    }
+    return { relations: validRelations };
+}

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

@@ -0,0 +1,170 @@
+/**
+ * 演化对齐 (Evolution Alignment)
+ *
+ * 算法流程:
+ * 1. 取所有 status='active' 的判断力
+ * 2. 算 Jaccard 字符级相似度:
+ *    - > 0.85: 直接 merge (不调 LLM)
+ *    - < 0.3: 视为 unrelated (不调 LLM)
+ *    - 0.3-0.85: 收集进 LLM 候选,按相似度 Top 10 送 LLM
+ * 3. LLM 判定 merge/contradict/unrelated
+ * 4. 应用结果: 旧条 status='superseded', supersededBy=newJudgment.id, evolutionReason, evolvedAt
+ *
+ * 防抖: 同 channel 1 分钟内重复调用直接 return
+ */
+import { batchUpdateJudgments, listJudgmentsByStatus, } from './human-value-store.js';
+import { evolveWithLLM } from './distill-prompt.js';
+const debounceMap = new Map();
+const DEBOUNCE_MS = 60_000;
+export async function evolveNewJudgment(newJudgment, options = {}) {
+    const maxLLMCompare = options.maxLLMCompare ?? 10;
+    const highTh = options.jaccardHighThreshold ?? 0.85;
+    const lowTh = options.jaccardLowThreshold ?? 0.3;
+    const channelId = newJudgment.context?.channelId;
+    if (!options.skipDebounce && channelId) {
+        const last = debounceMap.get(channelId) || 0;
+        if (Date.now() - last < DEBOUNCE_MS) {
+            return {
+                newJudgment,
+                merged: [],
+                contradicted: [],
+                unrelated: 0,
+                llmCompared: 0,
+            };
+        }
+        debounceMap.set(channelId, Date.now());
+    }
+    const allActive = await listJudgmentsByStatus('active');
+    const candidates = allActive.filter((j) => j.id !== newJudgment.id);
+    const newValue = newJudgment.decision;
+    const merged = [];
+    const llmCandidates = [];
+    let unrelatedCount = 0;
+    for (const old of candidates) {
+        const j = jaccardSimilarity(newValue, old.decision);
+        if (j > highTh) {
+            merged.push(old);
+        }
+        else if (j >= lowTh) {
+            llmCandidates.push({ id: old.id, value: old.decision, jaccard: j });
+        }
+        else {
+            unrelatedCount++;
+        }
+    }
+    llmCandidates.sort((a, b) => b.jaccard - a.jaccard);
+    const llmBatch = llmCandidates.slice(0, maxLLMCompare);
+    let contradicted = [];
+    if (llmBatch.length > 0) {
+        try {
+            const llmResult = await evolveWithLLM(newValue, llmBatch.map((c) => ({ id: c.id, value: c.value })));
+            const contradictedIds = new Set();
+            for (const rel of llmResult.relations) {
+                if (rel.relation === 'contradict') {
+                    contradictedIds.add(rel.id);
+                }
+                if (rel.relation === 'merge' || rel.relation === 'contradict') {
+                    const old = candidates.find((c) => c.id === rel.id);
+                    if (old && !merged.find((m) => m.id === rel.id)) {
+                        merged.push(old);
+                    }
+                }
+            }
+            const now = new Date().toISOString();
+            const toSupersede = [];
+            for (const old of merged) {
+                const reason = contradictedIds.has(old.id) ? 'contradicted' : 'merged';
+                toSupersede.push({
+                    ...old,
+                    status: 'superseded',
+                    supersededBy: newJudgment.id,
+                    evolutionReason: reason,
+                    evolvedAt: now,
+                });
+            }
+            contradicted = candidates.filter((c) => contradictedIds.has(c.id));
+            if (toSupersede.length > 0) {
+                await batchUpdateJudgments(toSupersede.map((j) => ({
+                    id: j.id,
+                    patch: {
+                        status: 'superseded',
+                        supersededBy: newJudgment.id,
+                        evolutionReason: j.evolutionReason,
+                        evolvedAt: j.evolvedAt,
+                    },
+                })));
+            }
+        }
+        catch (err) {
+            console.warn('[evolve-judgment] LLM evolve failed, keep high-jaccard merges only:', err);
+            const now = new Date().toISOString();
+            if (merged.length > 0) {
+                await batchUpdateJudgments(merged.map((j) => ({
+                    id: j.id,
+                    patch: {
+                        status: 'superseded',
+                        supersededBy: newJudgment.id,
+                        evolutionReason: 'merged',
+                        evolvedAt: now,
+                    },
+                })));
+            }
+        }
+    }
+    else if (merged.length > 0) {
+        const now = new Date().toISOString();
+        await batchUpdateJudgments(merged.map((j) => ({
+            id: j.id,
+            patch: {
+                status: 'superseded',
+                supersededBy: newJudgment.id,
+                evolutionReason: 'merged',
+                evolvedAt: now,
+            },
+        })));
+    }
+    return {
+        newJudgment,
+        merged,
+        contradicted,
+        unrelated: unrelatedCount,
+        llmCompared: llmBatch.length,
+    };
+}
+export function jaccardSimilarity(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;
+    // 短句 (< 8 字符): 字符级 bigram, 防止"先校验再写"vs"写入前先校验"全 0
+    // 长句: 单字 set, 避免 bigram 集合爆炸
+    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;
+}
+export function clearEvolveDebounce() {
+    debounceMap.clear();
+}

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

@@ -0,0 +1,21 @@
+/**
+ * 判断力自动入库 + AI 演化 统一入口
+ *
+ * 把新模块 (distill-prompt, evolve-judgment, detect-hook) 集中导出
+ * 给 server.ts 和前端调用方一个稳定的入口
+ *
+ * 旧的 human-value-store.ts (JSON 存储) 和 index.ts (YAML 存储) 不动
+ */
+export { detectIfWorthStoring, distillFromConversation, evolveWithLLM, } from './distill-prompt.js';
+export { evolveNewJudgment, jaccardSimilarity, clearEvolveDebounce, } from './evolve-judgment.js';
+export { detectAndDistillFromChannel, distillAndStoreFromChannel, throttleDHook, clearDHookThrottle, } from './detect-hook.js';
+export { injectJudgmentGate, recordJudgmentUsage, getRecentUsage, chatWithJudgmentGate, DEFAULT_INJECTION_CONFIG, } from './injection-gate.js';
+export { checkCompliance, monitorAfterReply, logViolation, getRecentViolations, } from './monitor-gate.js';
+export { runAdaptiveScan, getCachedScan, clearAdaptiveScanCache, logEvolution, readEvolutionLog, } from './adaptive-scan.js';
+// Causal-judge 引擎 (阶段 2)
+export { runCorrelationAnalysis, runIntervention, runCounterfactualAudit, logCounterfactualAudit, readCounterfactualLog, runConflictDetection, detectConflict, } from './causal-judge.js';
+// Bootstrap 入口 (re-export 给 index.ts / server.ts 用)
+export { bootstrapBolloon, } from '../bootstrap/bootstrap.js';
+export { onSessionStart, onStop, onPreToolUse, clearSessionStartCache, } from '../bootstrap/lifecycle-hooks.js';
+export { collectBolloonContext, getCachedBolloonContext, clearBolloonContextCache, } from '../bootstrap/context-collector.js';
+export { formatContextForSystemPrompt, } from '../bootstrap/project-context.js';