@bolloon/bolloon-agent 0.4.5 → 0.4.6

package/dist/orbitdb/task-store.js

@@ -0,0 +1,112 @@
+/**
+ * task-store.ts — Task 队列的 OrbitDB 主存储 (2026-08-12, Task6)
+ *
+ * 把 hermes kanban 用 OrbitDB 实现: 任务队列以 OrbitDB keyvalue store 为主存储,
+ * 支持跨设备/去中心化同步 (与 did-catalog-replication 同模式, 共享同一 helia 节点).
+ *
+ * 设计:
+ *   - store 名: `bolloon-tasks-<did短名>` (确定性, 跨设备同名 → 同一复制流)
+ *   - 存整个任务数组到单键 `tasks` (兼容 server-storage 现有 loadTaskQueue/saveTaskQueue)
+ *   - 懒初始化 + 幂等: 首次 warm 时打开 store; 失败静默 → 回退本地文件 (增强层, 不阻塞)
+ *   - 生产由 server 启动时 warmTaskOrbitStore() 预热; 测试环境 (临时 HOME) 不预热 → 走本地
+ *
+ * 失败静默: OrbitDB 不可用 (离线/首次/测试) 时任务照常走本地文件, 不阻塞主路径.
+ */
+import * as path from 'path';
+import * as os from 'os';
+import { getCIDDatabase } from './cid-database.js';
+const homeRoot = () => process.env.HOME || os.homedir() || '/tmp';
+export const TASK_ORBIT_STORE_KEY = 'tasks';
+/** store 名: 按 did 短名确定性命名 */
+export function taskStoreName(did) {
+    const short = String(did || 'local').replace(/[^a-zA-Z0-9-]/g, '_').slice(0, 40) || 'local';
+    return `bolloon-tasks-${short}`;
+}
+/** 真实实现 (OrbitDB). 单例: 同一进程共享 CID 数据库单例. */
+export class OrbitDBTaskStore {
+    did;
+    db;
+    _store = null;
+    ready = false;
+    storeName;
+    storeAddress = '';
+    constructor(did, db = getCIDDatabase()) {
+        this.did = did;
+        this.db = db;
+        this.storeName = taskStoreName(did);
+    }
+    async warm() {
+        if (this.ready && this._store)
+            return true;
+        try {
+            this._store = await this.db.openStore(this.storeName, 'keyvalue');
+            this.storeAddress = this._store.address;
+            this.ready = true;
+            return true;
+        }
+        catch (err) {
+            // OrbitDB 不可用 (离线/首次/测试环境) → 静默回退本地
+            try {
+                console.warn(`[task-store] OrbitDB 任务存储不可用, 回退本地: ${err?.message?.slice(0, 120)}`);
+            }
+            catch { /* 忽略 */ }
+            this.ready = false;
+            return false;
+        }
+    }
+    async loadTasks() {
+        if (!this.ready || !this._store)
+            return null;
+        try {
+            const v = await this._store.get(TASK_ORBIT_STORE_KEY);
+            if (v == null)
+                return null;
+            if (Array.isArray(v))
+                return v;
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveTasks(tasks) {
+        if (!this.ready || !this._store)
+            return false;
+        try {
+            await this._store.put(TASK_ORBIT_STORE_KEY, tasks);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async close() {
+        this._store = null;
+        this.ready = false;
+    }
+}
+let _instance = null;
+let _warmPromise = null;
+/** 获取任务 OrbitDB 存储单例 (首次调用时 warm). did 为 '' 时用 'local'. */
+export function getTaskOrbitStore(did = '') {
+    if (!_instance)
+        _instance = new OrbitDBTaskStore(did || 'local');
+    return _instance;
+}
+/** 预热任务 OrbitDB 存储 (server 启动时调用, 幂等). 返回是否就绪. */
+export function warmTaskOrbitStore(did = '') {
+    if (!_warmPromise) {
+        const store = getTaskOrbitStore(did);
+        _warmPromise = store.warm().then((ok) => ok).catch(() => false);
+    }
+    return _warmPromise;
+}
+/** 重置单例 (测试用) */
+export function resetTaskOrbitStore() {
+    _instance = null;
+    _warmPromise = null;
+}
+/** 用 did 短名构造 task store 名 (供 server 组装 store name 展示) */
+export function taskStorePath(did, home = homeRoot()) {
+    return path.join(home, '.bolloon', 'orbitdb', 'stores', taskStoreName(did));
+}

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 = {