@bolloon/bolloon-agent 0.1.35 → 0.1.37

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

@@ -1,153 +0,0 @@
-/**
- * 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
- */
-export type ColonySignal = 'LAUNCHED' | 'SCOUTING' | 'WORKING' | 'REVIEWING' | 'COMPLETE' | 'FAILED' | 'ABORTED';
-export type AntRole = 'scout' | 'worker' | 'reviewer' | 'coordinator';
-export interface Ant {
-    id: string;
-    name: string;
-    role: AntRole;
-    signal: ColonySignal;
-    turnCount: number;
-    maxTurns: number;
-    tokenBudget: number;
-    tokensUsed: number;
-    task?: string;
-    result?: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface ColonyTask {
-    id: string;
-    description: string;
-    status: 'pending' | 'dispatched' | 'in_progress' | 'completed' | 'failed';
-    assignedAnts: string[];
-    results: Map<string, string>;
-    createdAt: string;
-    completedAt?: string;
-}
-export interface ColonySignalEvent {
-    antId: string;
-    antName: string;
-    fromSignal: ColonySignal;
-    toSignal: ColonySignal;
-    timestamp: string;
-    details?: string;
-}
-/**
- * Register a new ant in the colony
- */
-export declare function registerAnt(name: string, role: AntRole, maxTurns?: number, tokenBudget?: number): Ant;
-/**
- * Transition ant to SCOUTING
- */
-export declare function antScouting(antId: string, task: string): void;
-/**
- * Transition ant to WORKING
- */
-export declare function antWorking(antId: string): void;
-/**
- * Transition ant to REVIEWING
- */
-export declare function antReviewing(antId: string): void;
-/**
- * Complete ant work
- */
-export declare function antComplete(antId: string, result: string): void;
-/**
- * Fail ant work
- */
-export declare function antFail(antId: string, error: string): void;
-/**
- * Abort ant work
- */
-export declare function antAbort(antId: string, reason: string): void;
-/**
- * Increment turn count
- */
-export declare function antTick(antId: string, tokensUsed?: number): void;
-/**
- * Create a colony task
- */
-export declare function createTask(description: string): ColonyTask;
-/**
- * Dispatch task to ants
- */
-export declare function dispatchTask(taskId: string, antIds: string[]): void;
-/**
- * Record ant result for a task
- */
-export declare function recordResult(taskId: string, antId: string, result: string): void;
-/**
- * Get ant by ID
- */
-export declare function getAnt(antId: string): Ant | undefined;
-/**
- * List all ants
- */
-export declare function listAnts(): Ant[];
-/**
- * List ants by role
- */
-export declare function listAntsByRole(role: AntRole): Ant[];
-/**
- * Get ants by signal state
- */
-export declare function listAntsBySignal(signal: ColonySignal): Ant[];
-/**
- * Get active ants (not complete/failed/aborted)
- */
-export declare function getActiveAnts(): Ant[];
-/**
- * Get task by ID
- */
-export declare function getTask(taskId: string): ColonyTask | undefined;
-/**
- * List all tasks
- */
-export declare function listTasks(): ColonyTask[];
-/**
- * Get signal history
- */
-export declare function getSignalHistory(): ColonySignalEvent[];
-/**
- * Get colony status
- */
-export declare function getColonyStatus(): {
-    antCount: number;
-    activeAnts: number;
-    taskCount: number;
-    activeTasks: number;
-    signalDistribution: Record<ColonySignal, number>;
-};
-/**
- * Subscribe to colony events
- */
-export declare function onColonyEvent(event: 'signal' | 'antRegistered' | 'taskCreated', callback: (...args: unknown[]) => void): void;
-/**
- * Unsubscribe from colony events
- */
-export declare function offColonyEvent(event: 'signal' | 'antRegistered' | 'taskCreated', callback: (...args: unknown[]) => void): void;
-/**
- * Get formatted colony dump for debugging
- */
-export declare function getColonyDump(): string;
-/**
- * Persist colony state
- */
-export declare function persistColony(): Promise<void>;
-/**
- * Load colony state
- */
-export declare function loadColony(): Promise<void>;

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;