@bolloon/bolloon-agent 0.3.38 → 0.3.39

package/dist/pi-ecosystem-colony/index.js

@@ -0,0 +1,365 @@
+/**
+ * Pi Ant Colony Integration for Bolloon
+ *
+ * Multi-agent collaboration system with white-box signal protocol.
+ * Based on oh-pi's ant colony system: COLONY_SIGNAL protocol for agent coordination.
+ *
+ * Signal Protocol:
+ * COLONY_SIGNAL:LAUNCHED → SCOUTING → WORKING → REVIEWING → COMPLETE
+ *
+ * Key features:
+ * - Fully visible signal protocol (no black boxes)
+ * - Per-ant turn limits, cost tracking, concurrent scheduling
+ * - White-box design: no "what is it doing in the background" anxiety
+ */
+import { EventEmitter } from 'events';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Colony state
+const ants = new Map();
+const tasks = new Map();
+const signalHistory = [];
+const STATE_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'colony');
+// Event emitter
+class ColonyEventEmitter extends EventEmitter {
+}
+const colonyEvents = new ColonyEventEmitter();
+/**
+ * Generate a unique ant ID
+ */
+function generateAntId() {
+    return `ant-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * Register a new ant in the colony
+ */
+export function registerAnt(name, role, maxTurns = 10, tokenBudget = 50000) {
+    const id = generateAntId();
+    const ant = {
+        id,
+        name,
+        role,
+        signal: 'LAUNCHED',
+        turnCount: 0,
+        maxTurns,
+        tokenBudget,
+        tokensUsed: 0,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    ants.set(id, ant);
+    emitSignal(id, 'LAUNCHED');
+    console.log(`[Colony] Registered ant: ${name} (${role})`);
+    return ant;
+}
+/**
+ * Emit a signal transition
+ */
+function emitSignal(antId, newSignal, details) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    const event = {
+        antId,
+        antName: ant.name,
+        fromSignal: ant.signal,
+        toSignal: newSignal,
+        timestamp: new Date().toISOString(),
+        details,
+    };
+    signalHistory.push(event);
+    if (signalHistory.length > 100) {
+        signalHistory.shift();
+    }
+    ant.signal = newSignal;
+    ant.updatedAt = new Date().toISOString();
+    ants.set(antId, ant);
+    colonyEvents.emit('signal', event);
+    console.log(`[Colony] ${ant.name}: ${event.fromSignal} → ${event.toSignal}${details ? ` (${details})` : ''}`);
+}
+/**
+ * Transition ant to SCOUTING
+ */
+export function antScouting(antId, task) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    ant.task = task;
+    ants.set(antId, ant);
+    emitSignal(antId, 'SCOUTING', `Task: ${task.substring(0, 50)}...`);
+}
+/**
+ * Transition ant to WORKING
+ */
+export function antWorking(antId) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    emitSignal(antId, 'WORKING');
+}
+/**
+ * Transition ant to REVIEWING
+ */
+export function antReviewing(antId) {
+    emitSignal(antId, 'REVIEWING');
+}
+/**
+ * Complete ant work
+ */
+export function antComplete(antId, result) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    ant.result = result;
+    ants.set(antId, ant);
+    emitSignal(antId, 'COMPLETE', `Result: ${result.substring(0, 50)}...`);
+}
+/**
+ * Fail ant work
+ */
+export function antFail(antId, error) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    ant.result = error;
+    ants.set(antId, ant);
+    emitSignal(antId, 'FAILED', error);
+}
+/**
+ * Abort ant work
+ */
+export function antAbort(antId, reason) {
+    emitSignal(antId, 'ABORTED', reason);
+}
+/**
+ * Increment turn count
+ */
+export function antTick(antId, tokensUsed = 0) {
+    const ant = ants.get(antId);
+    if (!ant)
+        return;
+    ant.turnCount++;
+    ant.tokensUsed += tokensUsed;
+    ant.updatedAt = new Date().toISOString();
+    ants.set(antId, ant);
+    // Check if exceeded limits
+    if (ant.turnCount >= ant.maxTurns) {
+        antAbort(antId, 'Max turns exceeded');
+    }
+    else if (ant.tokensUsed >= ant.tokenBudget) {
+        antAbort(antId, 'Token budget exceeded');
+    }
+}
+/**
+ * Create a colony task
+ */
+export function createTask(description) {
+    const id = `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    const task = {
+        id,
+        description,
+        status: 'pending',
+        assignedAnts: [],
+        results: new Map(),
+        createdAt: new Date().toISOString(),
+    };
+    tasks.set(id, task);
+    console.log(`[Colony] Created task: ${id} - ${description.substring(0, 50)}...`);
+    return task;
+}
+/**
+ * Dispatch task to ants
+ */
+export function dispatchTask(taskId, antIds) {
+    const task = tasks.get(taskId);
+    if (!task)
+        return;
+    task.status = 'dispatched';
+    task.assignedAnts = antIds;
+    tasks.set(taskId, task);
+    for (const antId of antIds) {
+        const ant = ants.get(antId);
+        if (ant) {
+            antScouting(antId, task.description);
+        }
+    }
+    console.log(`[Colony] Dispatched task ${taskId} to ${antIds.length} ants`);
+}
+/**
+ * Record ant result for a task
+ */
+export function recordResult(taskId, antId, result) {
+    const task = tasks.get(taskId);
+    if (!task)
+        return;
+    task.results.set(antId, result);
+    // Check if all ants completed
+    if (task.results.size === task.assignedAnts.length) {
+        task.status = 'completed';
+        task.completedAt = new Date().toISOString();
+        for (const id of task.assignedAnts) {
+            antReviewing(id);
+        }
+    }
+    tasks.set(taskId, task);
+}
+/**
+ * Get ant by ID
+ */
+export function getAnt(antId) {
+    return ants.get(antId);
+}
+/**
+ * List all ants
+ */
+export function listAnts() {
+    return Array.from(ants.values());
+}
+/**
+ * List ants by role
+ */
+export function listAntsByRole(role) {
+    return Array.from(ants.values()).filter((a) => a.role === role);
+}
+/**
+ * Get ants by signal state
+ */
+export function listAntsBySignal(signal) {
+    return Array.from(ants.values()).filter((a) => a.signal === signal);
+}
+/**
+ * Get active ants (not complete/failed/aborted)
+ */
+export function getActiveAnts() {
+    return Array.from(ants.values()).filter((a) => !['COMPLETE', 'FAILED', 'ABORTED'].includes(a.signal));
+}
+/**
+ * Get task by ID
+ */
+export function getTask(taskId) {
+    return tasks.get(taskId);
+}
+/**
+ * List all tasks
+ */
+export function listTasks() {
+    return Array.from(tasks.values());
+}
+/**
+ * Get signal history
+ */
+export function getSignalHistory() {
+    return [...signalHistory];
+}
+/**
+ * Get colony status
+ */
+export function getColonyStatus() {
+    const antList = Array.from(ants.values());
+    const taskList = Array.from(tasks.values());
+    const signalDistribution = {
+        LAUNCHED: 0,
+        SCOUTING: 0,
+        WORKING: 0,
+        REVIEWING: 0,
+        COMPLETE: 0,
+        FAILED: 0,
+        ABORTED: 0,
+    };
+    for (const ant of antList) {
+        signalDistribution[ant.signal]++;
+    }
+    return {
+        antCount: antList.length,
+        activeAnts: antList.filter((a) => !['COMPLETE', 'FAILED', 'ABORTED'].includes(a.signal)).length,
+        taskCount: taskList.length,
+        activeTasks: taskList.filter((t) => t.status === 'in_progress' || t.status === 'dispatched').length,
+        signalDistribution,
+    };
+}
+/**
+ * Subscribe to colony events
+ */
+export function onColonyEvent(event, callback) {
+    colonyEvents.on(event, callback);
+}
+/**
+ * Unsubscribe from colony events
+ */
+export function offColonyEvent(event, callback) {
+    colonyEvents.off(event, callback);
+}
+/**
+ * Get formatted colony dump for debugging
+ */
+export function getColonyDump() {
+    const status = getColonyStatus();
+    const active = getActiveAnts();
+    let dump = '# Colony Status\n\n';
+    dump += `Ants: ${status.antCount} total, ${status.activeAnts} active\n`;
+    dump += `Tasks: ${status.taskCount} total, ${status.activeTasks} active\n\n`;
+    dump += '## Signal Distribution\n';
+    for (const [signal, count] of Object.entries(status.signalDistribution)) {
+        if (count > 0) {
+            dump += `- ${signal}: ${count}\n`;
+        }
+    }
+    dump += '\n## Active Ants\n';
+    for (const ant of active) {
+        dump += `- ${ant.name} (${ant.role}): ${ant.signal} [${ant.turnCount}/${ant.maxTurns} turns, ${ant.tokensUsed}/${ant.tokenBudget} tokens]\n`;
+        if (ant.task) {
+            dump += `  Task: ${ant.task.substring(0, 60)}...\n`;
+        }
+    }
+    dump += '\n## Recent Signals\n';
+    const recent = signalHistory.slice(-10);
+    for (const event of recent.reverse()) {
+        dump += `- ${event.timestamp}: ${event.antName}: ${event.fromSignal} → ${event.toSignal}\n`;
+    }
+    return dump;
+}
+/**
+ * Persist colony state
+ */
+export async function persistColony() {
+    try {
+        await fs.mkdir(STATE_DIR, { recursive: true });
+        const state = {
+            ants: Array.from(ants.values()),
+            tasks: Array.from(tasks.entries()).map(([id, t]) => ({
+                ...t,
+                results: Array.from(t.results.entries()),
+            })),
+            signalHistory: signalHistory.slice(-50),
+            persistedAt: new Date().toISOString(),
+        };
+        await fs.writeFile(path.join(STATE_DIR, 'colony.json'), JSON.stringify(state, null, 2));
+        console.log('[Colony] Persisted state');
+    }
+    catch (e) {
+        console.warn('[Colony] Failed to persist:', e);
+    }
+}
+/**
+ * Load colony state
+ */
+export async function loadColony() {
+    try {
+        const data = await fs.readFile(path.join(STATE_DIR, 'colony.json'), 'utf-8');
+        const state = JSON.parse(data);
+        ants.clear();
+        for (const a of state.ants) {
+            ants.set(a.id, a);
+        }
+        tasks.clear();
+        for (const t of state.tasks) {
+            tasks.set(t.id, { ...t, results: new Map(t.results) });
+        }
+        signalHistory.length = 0;
+        signalHistory.push(...state.signalHistory);
+        console.log(`[Colony] Loaded ${ants.size} ants, ${tasks.size} tasks`);
+    }
+    catch {
+        // No persisted state
+    }
+}

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/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}`);