@bolloon/bolloon-agent 0.1.36 → 0.1.37

package/dist/bollharness-integration/pi-ecosystem-goals/index.d.ts

@@ -1,136 +0,0 @@
-/**
- * Pi Goals Integration for Bolloon
- *
- * Provides persistent goal tracking and workflow orchestration.
- * Based on pi-goals philosophy: goal-oriented agent workflows with budget enforcement.
- *
- * Key features:
- * - Persistent goal state across sessions
- * - Goal queue with FIFO execution
- * - Budget enforcement (max time/tokens, min work thresholds)
- * - Workflow templates with {{args}} placeholders
- * - Churn monitoring to detect drift/stalling
- */
-export interface Goal {
-    id: string;
-    objective: string;
-    status: GoalStatus;
-    createdAt: string;
-    startedAt?: string;
-    completedAt?: string;
-    budget?: GoalBudget;
-    result?: string;
-    error?: string;
-    summary?: string;
-    metadata?: Record<string, unknown>;
-}
-export type GoalStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'paused' | 'cutoff';
-export interface GoalBudget {
-    maxTimeMs: number;
-    maxTokens: number;
-    minWorkMs?: number;
-    minTokens?: number;
-}
-export interface GoalQueue {
-    goals: Goal[];
-    currentIndex: number;
-}
-export interface WorkflowTemplate {
-    name: string;
-    description?: string;
-    goals: string[];
-    args?: Record<string, {
-        description?: string;
-        default?: string;
-    }>;
-    gate?: string;
-}
-export interface ChurnEvent {
-    goalId: string;
-    type: 'drift' | 'stall' | 'repeat';
-    message: string;
-    timestamp: string;
-}
-/**
- * Create a new goal
- */
-export declare function createGoal(objective: string, budget?: GoalBudget, metadata?: Record<string, unknown>): Promise<Goal>;
-/**
- * Create a queue of goals
- */
-export declare function createGoalQueue(objectives: string[], budgets?: GoalBudget[]): Promise<Goal[]>;
-/**
- * Get current goal
- */
-export declare function getCurrentGoal(): Goal | undefined;
-/**
- * Start current goal
- */
-export declare function startCurrentGoal(): Promise<Goal | undefined>;
-/**
- * Complete current goal with result
- */
-export declare function completeCurrentGoal(result?: string): Promise<Goal | undefined>;
-/**
- * Fail current goal
- */
-export declare function failCurrentGoal(error: string): Promise<Goal | undefined>;
-/**
- * Cutoff current goal (exceeded budget)
- */
-export declare function cutoffCurrentGoal(reason: string): Promise<Goal | undefined>;
-/**
- * Pause current goal
- */
-export declare function pauseCurrentGoal(): Promise<Goal | undefined>;
-/**
- * Check budget for a goal
- */
-export declare function checkBudget(goal: Goal, elapsedMs?: number, tokensUsed?: number): {
-    exceeded: boolean;
-    reason?: string;
-};
-/**
- * Get churn events for current goal
- */
-export declare function getChurnForGoal(goalId: string): ChurnEvent[];
-/**
- * Get goal statistics
- */
-export declare function getGoalStats(): {
-    total: number;
-    pending: number;
-    inProgress: number;
-    completed: number;
-    failed: number;
-    paused: number;
-    cutoff: number;
-};
-/**
- * Get queue summary
- */
-export declare function getQueueSummary(): string;
-/**
- * Load goals from disk
- */
-export declare function loadGoals(): Promise<void>;
-/**
- * Clear all goals
- */
-export declare function clearGoals(): Promise<void>;
-/**
- * Remove completed goals and compact queue
- */
-export declare function compactQueue(): Promise<void>;
-/**
- * Load workflow templates
- */
-export declare function loadTemplates(): Promise<WorkflowTemplate[]>;
-/**
- * Create goals from a template
- */
-export declare function createFromTemplate(templateName: string, args: Record<string, string>): Promise<Goal[]>;
-/**
- * Continue working on current goal (anti-stall)
- */
-export declare function nudgeCurrentGoal(): Promise<Goal | undefined>;

package/dist/bollharness-integration/pi-ecosystem-judgment/decision.d.ts

@@ -1,117 +0,0 @@
-/**
- * Decision Request & Authorization Flow
- *
- * Handles decision requests when agent confidence is below threshold.
- * Supports consulting internal agents (colony/subagents) and external agents (P2P).
- *
- * Flow:
- * Agent Decision Need
- *     ↓
- * Query ValueFunction → Calculate Confidence
- *     ↓
- * Confidence > Threshold → Execute
- *     ↓ (No)
- * DecisionRequest → [Human | Internal Agents | External Agents]
- *     ↓
- * Authorization / Collaboration
- *     ↓
- * Execute & Archive Judgment
- */
-import { Judgment } from './index.js';
-export type DecisionLevel = 'autonomous' | 'consult_internal' | 'consult_external' | 'require_human';
-export type ConsultationTarget = 'human' | 'colony_ant' | 'subagent' | 'p2p_agent';
-export type DecisionStatus = 'pending' | 'authorized' | 'rejected' | 'executed' | 'failed';
-export interface DecisionRequest {
-    id: string;
-    description: string;
-    context: string;
-    confidence: number;
-    threshold: number;
-    level: DecisionLevel;
-    targets: ConsultationTarget[];
-    status: DecisionStatus;
-    agentId: string;
-    createdAt: string;
-    respondedAt?: string;
-    response?: DecisionResponse;
-    judgment?: Judgment;
-}
-export interface DecisionResponse {
-    authorized: boolean;
-    content: string;
-    modifier?: string;
-    delegate?: ConsultationTarget;
-    by: ConsultationTarget;
-    timestamp: string;
-}
-export interface AgentConsultationResult {
-    target: ConsultationTarget;
-    agentId: string;
-    response: string;
-    confidence: number;
-}
-/**
- * Set default confidence threshold
- */
-export declare function setConfidenceThreshold(threshold: number): void;
-/**
- * Get default confidence threshold
- */
-export declare function getConfidenceThreshold(): number;
-/**
- * Set default decision level
- */
-export declare function setDefaultDecisionLevel(level: DecisionLevel): void;
-/**
- * Get default decision level
- */
-export declare function getDefaultDecisionLevel(): DecisionLevel;
-/**
- * Evaluate a decision need and determine appropriate level
- */
-export declare function evaluateDecision(description: string, context: string, agentId: string, threshold?: number): Promise<DecisionRequest>;
-/**
- * Submit a decision response
- */
-export declare function submitDecisionResponse(requestId: string, response: DecisionResponse): Promise<DecisionRequest | null>;
-/**
- * Check if input is a decision response
- */
-export declare function isDecisionResponse(input: string): boolean;
-/**
- * Parse decision response from natural language
- */
-export declare function parseDecisionResponse(input: string): Partial<DecisionResponse>;
-/**
- * Query internal agents (colony ants and subagents)
- */
-export declare function queryInternalAgents(request: DecisionRequest): Promise<AgentConsultationResult[]>;
-/**
- * Process human feedback and distill to judgment
- */
-export declare function processHumanFeedback(requestId: string, input: string): Promise<DecisionRequest | null>;
-/**
- * Get pending decision requests
- */
-export declare function getPendingDecisions(): DecisionRequest[];
-/**
- * Get decision request by ID
- */
-export declare function getDecisionRequest(id: string): DecisionRequest | undefined;
-/**
- * Get decision statistics
- */
-export declare function getDecisionStats(): {
-    pending: number;
-    authorized: number;
-    rejected: number;
-    total: number;
-};
-/**
- * Subscribe to decision events
- */
-export declare function onDecisionEvent(event: 'decisionCreated' | 'decisionResponded' | 'decisionExecuted', callback: (request: DecisionRequest) => void): void;
-/**
- * Unsubscribe from decision events
- */
-export declare function offDecisionEvent(event: 'decisionCreated' | 'decisionResponded' | 'decisionExecuted', callback: (request: DecisionRequest) => void): void;

package/dist/bollharness-integration/pi-ecosystem-judgment/distillation.d.ts

@@ -1,78 +0,0 @@
-/**
- * Judgment Distillation Module
- *
- * Real-time LLM-based distillation of human input into Judgment principles.
- *
- * Flow:
- * Human Input → Trigger Detection → LLM Extraction → Judgment
- *                    ↓
- *            Confidence + Evidence
- */
-import { Judgment, DistillationTrigger, DistillationRequest } from './index.js';
-export interface DistillationResult {
-    success: boolean;
-    judgment?: Judgment;
-    error?: string;
-    trigger: DistillationTrigger;
-}
-export interface FeedbackSignal {
-    judgmentId: string;
-    type: 'approve' | 'reject' | 'correct';
-    correction?: {
-        original: string;
-        corrected: string;
-        reason?: string;
-    };
-}
-export interface TrajectoryEntry {
-    timestamp: string;
-    action: string;
-    outcome: string;
-    approved: boolean;
-}
-/**
- * Initialize the distillation system
- */
-export declare function initializeDistillation(): Promise<void>;
-/**
- * Detect trigger type from human input
- */
-export declare function detectTrigger(input: string): DistillationTrigger | null;
-/**
- * Check if input indicates a judgment correction
- */
-export declare function detectCorrection(input: string): {
-    original: string;
-    corrected: string;
-} | null;
-/**
- * Add to trajectory buffer
- */
-export declare function addToTrajectory(agentId: string, action: string, outcome: string, approved: boolean): void;
-/**
- * Detect trajectory pattern (repeated similar actions)
- */
-export declare function detectTrajectoryPattern(agentId: string): TrajectoryEntry[] | null;
-/**
- * Distill human input to judgment using LLM
- */
-export declare function distillInput(request: DistillationRequest): Promise<DistillationResult>;
-/**
- * Process feedback signal
- */
-export declare function processFeedback(signal: FeedbackSignal): Promise<void>;
-/**
- * Check if human input contains judgment signal
- */
-export declare function isJudgmentSignal(input: string): boolean;
-/**
- * Get trajectory buffer statistics
- */
-export declare function getTrajectoryStats(): Record<string, {
-    count: number;
-    approvalRate: number;
-}>;
-/**
- * Clear trajectory buffer for agent
- */
-export declare function clearTrajectory(agentId?: string): void;

package/dist/bollharness-integration/pi-ecosystem-judgment/index.d.ts

@@ -1,139 +0,0 @@
-/**
- * Pi Judgment Integration for Bolloon
- *
- * Core module for capturing, distilling, and applying human judgment.
- *
- * Architecture:
- * Human Input → Distillation Trigger → LLM Extraction → Judgment YAML
- *                              ↓
- *                      ValueFunction
- *                              ↓
- *                    Runtime Decision
- *
- * Storage: Hybrid mode
- * - High-frequency rules: Embedded in context-fragments/*.md YAML frontmatter
- * - Long-term preferences: .bolloon/judgments/*.yaml
- */
-export type JudgmentType = 'rule' | 'preference' | 'trajectory' | 'reward';
-export type JudgmentSource = 'human' | 'agent' | 'collaboration';
-export type DistillationTrigger = 'explicit' | 'implicit' | 'trajectory';
-export interface Judgment {
-    id: string;
-    type: JudgmentType;
-    content: string;
-    source: JudgmentSource;
-    confidence: number;
-    context?: string;
-    createdAt: string;
-    updatedAt: string;
-    evidence?: JudgmentEvidence;
-    metadata?: Record<string, unknown>;
-}
-export interface JudgmentEvidence {
-    trajectory?: TrajectoryPoint[];
-    preference_pair?: PreferencePair[];
-    correction?: Correction;
-}
-export interface TrajectoryPoint {
-    timestamp: string;
-    action: string;
-    outcome: string;
-    approved: boolean;
-}
-export interface PreferencePair {
-    query: string;
-    chosen: string;
-    rejected: string;
-    context?: string;
-}
-export interface Correction {
-    original: string;
-    corrected: string;
-    reason?: string;
-    timestamp: string;
-}
-export interface JudgmentFile {
-    judgments: Judgment[];
-    filePath: string;
-    lastModified: string;
-}
-export interface DistillationRequest {
-    rawInput: string;
-    trigger: DistillationTrigger;
-    context: string;
-    conversationHistory?: string[];
-    agentPrediction?: string;
-}
-export interface ValueFunction {
-    judgments: Judgment[];
-    contextWeights: Record<string, number>;
-    lastUpdated: string;
-}
-/**
- * Load all judgments from YAML files
- */
-export declare function loadJudgments(): Promise<Map<string, Judgment[]>>;
-/**
- * Create a new judgment
- */
-export declare function createJudgment(params: {
-    type: JudgmentType;
-    content: string;
-    source: JudgmentSource;
-    confidence: number;
-    context?: string;
-    evidence?: JudgmentEvidence;
-}): Promise<Judgment>;
-/**
- * Update judgment confidence based on feedback
- */
-export declare function updateJudgmentConfidence(id: string, delta: number, feedbackType: 'approve' | 'reject' | 'correct'): Promise<Judgment | null>;
-/**
- * Get all judgments
- */
-export declare function getAllJudgments(): Promise<Judgment[]>;
-/**
- * Get judgments by type
- */
-export declare function getJudgmentsByType(type: JudgmentType): Promise<Judgment[]>;
-/**
- * Get judgments relevant to a context
- */
-export declare function getJudgmentsForContext(context: string): Promise<Judgment[]>;
-/**
- * Calculate confidence score for a decision
- */
-export declare function calculateConfidence(judgments: Judgment[]): number;
-/**
- * Build ValueFunction from judgments
- */
-export declare function buildValueFunction(context?: string): Promise<ValueFunction>;
-/**
- * Get cached ValueFunction
- */
-export declare function getValueFunction(context?: string): Promise<ValueFunction>;
-/**
- * Extract judgments from context fragment YAML frontmatter
- */
-export declare function extractFromFragment(fragmentPath: string): Promise<Judgment[]>;
-/**
- * Load judgments from all context fragments
- */
-export declare function loadFragmentJudgments(): Promise<Judgment[]>;
-/**
- * Get combined judgments (file + fragments)
- */
-export declare function getCombinedJudgments(): Promise<Judgment[]>;
-/**
- * Get judgment statistics
- */
-export declare function getJudgmentStats(): Promise<{
-    total: number;
-    byType: Record<JudgmentType, number>;
-    bySource: Record<JudgmentSource, number>;
-    averageConfidence: number;
-}>;
-/**
- * Clear judgment cache
- */
-export declare function clearCache(): void;

package/dist/bollharness-integration/pi-ecosystem-mcp/index.d.ts

@@ -1,127 +0,0 @@
-/**
- * Pi MCP Adapter Integration for Bolloon
- *
- * Bridges MCP (Model Context Protocol) servers with Bolloon's tool system.
- * Based on the pi-mcp-adapter philosophy: on-demand tool loading with minimal token overhead.
- *
- * Key differences from Claude Code MCP:
- * - White-box design: every schema, parameter, and return value is visible
- * - Minimal primitives: only read, write, edit, bash under the hood
- * - No schema validation black boxes - interfaces are simple by design
- */
-export interface McpServerConfig {
-    name: string;
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-}
-export interface McpTool {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    serverName: string;
-}
-export interface McpRequest {
-    jsonrpc: '2.0';
-    id: string | number;
-    method: string;
-    params?: Record<string, unknown>;
-}
-export interface McpResponse {
-    jsonrpc: '2.0';
-    id: string | number;
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-}
-export interface McpToolCall {
-    name: string;
-    arguments: Record<string, unknown>;
-}
-/**
- * Discover MCP servers from standard config locations
- */
-export declare function discoverMcpServers(): Promise<McpServerConfig[]>;
-/**
- * Initialize the MCP adapter
- */
-export declare function initializeMcpAdapter(): Promise<void>;
-/**
- * Register an MCP server configuration
- */
-export declare function registerServer(config: McpServerConfig): void;
-/**
- * Register an MCP tool
- */
-export declare function registerTool(tool: McpTool): void;
-/**
- * List all available MCP tools
- */
-export declare function listTools(): McpTool[];
-/**
- * Check if a tool exists
- */
-export declare function hasTool(name: string): boolean;
-/**
- * Get a specific tool
- */
-export declare function getTool(name: string): McpTool | undefined;
-/**
- * Get tool call log for debugging
- */
-export declare function getToolCallLog(): Array<{
-    timestamp: string;
-    tool: string;
-    args: unknown;
-    result: unknown;
-}>;
-/**
- * Clear tool call log
- */
-export declare function clearToolCallLog(): void;
-/**
- * Execute an MCP tool via JSON-RPC protocol
- */
-export declare function executeTool(name: string, args: Record<string, unknown>): Promise<{
-    success: boolean;
-    content?: unknown[];
-    error?: string;
-}>;
-/**
- * Start an MCP server process
- */
-export declare function startServer(serverName: string): Promise<boolean>;
-/**
- * Stop an MCP server
- */
-export declare function stopServer(serverName: string): void;
-/**
- * Discover tools from a server using MCP protocol
- */
-export declare function discoverTools(serverName: string): Promise<McpTool[]>;
-/**
- * Create a Tavily search tool (common MCP integration)
- */
-export declare function createTavilyTool(apiKey: string): McpTool;
-/**
- * Create an Amap maps tool
- */
-export declare function createAmapTool(apiKey: string): McpTool;
-/**
- * Get adapter status
- */
-export declare function getAdapterStatus(): {
-    initialized: boolean;
-    serverCount: number;
-    toolCount: number;
-    servers: string[];
-    runningServers: string[];
-};
-/**
- * Event subscription
- */
-export declare function on(event: 'initialized' | 'toolRegistered', callback: (...args: unknown[]) => void): void;
-export declare function off(event: 'initialized' | 'toolRegistered', callback: (...args: unknown[]) => void): void;

package/dist/bollharness-integration/pi-ecosystem-subagents/index.d.ts

@@ -1,95 +0,0 @@
-/**
- * Pi Subagents Integration for Bolloon
- *
- * Lightweight subagent implementation based on tmux multi-session.
- * Based on pi-subagents philosophy: simple task delegation and result collection.
- *
- * Key differences from Claude Code subagents:
- * - tmux-based sessions (not black-box background processes)
- * - Simple task委托 and result回收
- * - Full visibility into what each subagent is doing
- * - No complex scheduling - suitable for single task splitting
- */
-export type SubagentStatus = 'created' | 'running' | 'idle' | 'completed' | 'failed' | 'terminated';
-export interface Subagent {
-    id: string;
-    name: string;
-    task: string;
-    status: SubagentStatus;
-    sessionId: string;
-    createdAt: string;
-    startedAt?: string;
-    completedAt?: string;
-    result?: string;
-    error?: string;
-}
-export interface SubagentResult {
-    subagentId: string;
-    success: boolean;
-    result?: string;
-    error?: string;
-    duration?: number;
-}
-export interface SubagentDelegateOptions {
-    name?: string;
-    timeoutMs?: number;
-    onProgress?: (progress: string) => void;
-}
-/**
- * Create a new tmux session for a subagent
- */
-export declare function createSubagent(task: string, options?: SubagentDelegateOptions): Promise<Subagent>;
-/**
- * Start a subagent in a tmux session
- */
-export declare function startSubagent(id: string, command: string, options?: SubagentDelegateOptions): Promise<SubagentResult>;
-/**
- * Delegate a task to a new subagent and start it
- */
-export declare function delegateTask(task: string, command: string, options?: SubagentDelegateOptions): Promise<SubagentResult>;
-/**
- * Send input to a running subagent
- */
-export declare function sendToSubagent(id: string, input: string): Promise<void>;
-/**
- * Get subagent status
- */
-export declare function getSubagent(id: string): Subagent | undefined;
-/**
- * List all subagents
- */
-export declare function listSubagents(): Subagent[];
-/**
- * List running subagents
- */
-export declare function listRunningSubagents(): Subagent[];
-/**
- * Terminate a subagent
- */
-export declare function terminateSubagent(id: string): Promise<void>;
-/**
- * Load subagents from disk
- */
-export declare function loadSubagents(): Promise<void>;
-/**
- * Get subagent statistics
- */
-export declare function getStats(): {
-    total: number;
-    running: number;
-    completed: number;
-    failed: number;
-};
-/**
- * Clean up terminated subagents
- */
-export declare function cleanupSubagents(): Promise<void>;
-/**
- * Execute a task in parallel using multiple subagents
- */
-export declare function parallelDelegate(tasks: string[], commandFactory: (task: string) => string, options?: SubagentDelegateOptions): Promise<SubagentResult[]>;
-/**
- * Split a long-form task across multiple subagents
- * (e.g., writing and researching simultaneously)
- */
-export declare function splitTask(mainTask: string, subtasks: string[], commandFactory: (subtask: string) => string, options?: SubagentDelegateOptions): Promise<Map<string, SubagentResult>>;