@holoscript/framework 6.0.3

package/dist/swarm/index.d.ts

@@ -0,0 +1,2433 @@
+import { ISwarmCoordinator, ISwarmConfig, ISwarmResult, ILeaderElection, IHiveContribution, IHiveSession, ICollectiveIntelligenceService } from '@holoscript/core';
+
+/**
+ * Swarm Coordinator
+ *
+ * Implements ISwarmCoordinator interface for agent-task optimization.
+ * Supports PSO, ACO, and hybrid algorithms.
+ */
+
+interface AgentInfo {
+    id: string;
+    capacity: number;
+    load: number;
+}
+interface TaskInfo {
+    id: string;
+    complexity: number;
+    priority: number;
+}
+/**
+ * Main swarm coordinator for multi-agent task optimization
+ */
+declare class SwarmCoordinator implements ISwarmCoordinator {
+    private psoEngine;
+    private acoEngine;
+    private defaultConfig;
+    constructor(config?: Partial<ISwarmConfig>);
+    /**
+     * Optimize agent-task assignment
+     *
+     * Uses PSO to find optimal task-to-agent mapping that:
+     * - Balances load across agents
+     * - Respects capacity constraints
+     * - Prioritizes high-priority tasks
+     * - Minimizes complexity/load mismatch
+     */
+    optimize(agents: AgentInfo[], tasks: TaskInfo[], config?: Partial<ISwarmConfig>): Promise<ISwarmResult>;
+    /**
+     * Get recommended population size based on problem complexity
+     */
+    getRecommendedPopulation(problemSize: number): number;
+    /**
+     * Create fitness function for task assignment
+     */
+    private createFitnessFunction;
+    /**
+     * Create distance matrix for ACO from agents/tasks
+     */
+    private createDistanceMatrix;
+    /**
+     * Refine PSO solution using ACO local search
+     */
+    private refineWithACO;
+    /**
+     * Format result with improvement percentage
+     */
+    private formatResult;
+    /**
+     * Calculate improvement over baseline
+     */
+    private calculateImprovement;
+}
+
+/**
+ * Particle Swarm Optimization Engine
+ *
+ * Implements PSO algorithm for agent-task assignment optimization.
+ * Each particle represents a potential solution (task-to-agent mapping).
+ */
+interface PSOConfig {
+    populationSize: number;
+    maxIterations: number;
+    convergenceThreshold: number;
+    inertiaWeight: number;
+    cognitiveWeight: number;
+    socialWeight: number;
+    velocityClamp: number;
+}
+interface Particle {
+    position: number[];
+    velocity: number[];
+    personalBest: number[];
+    personalBestFitness: number;
+}
+interface PSOResult {
+    bestSolution: number[];
+    bestFitness: number;
+    converged: boolean;
+    iterations: number;
+    fitnessHistory: number[];
+}
+/**
+ * Particle Swarm Optimization engine for task assignment
+ */
+declare class PSOEngine {
+    private config;
+    constructor(config?: Partial<PSOConfig>);
+    /**
+     * Optimize task assignment using PSO
+     *
+     * @param agentCount Number of available agents
+     * @param taskCount Number of tasks to assign
+     * @param fitnessFunction Function to evaluate solution quality (higher is better)
+     * @returns Optimization result with best assignment
+     */
+    optimize(agentCount: number, taskCount: number, fitnessFunction: (assignment: number[]) => number): Promise<PSOResult>;
+    /**
+     * Initialize the particle swarm with random positions
+     */
+    private initializeSwarm;
+    /**
+     * Update particle velocity based on PSO equations
+     */
+    private updateVelocity;
+    /**
+     * Update particle position
+     */
+    private updatePosition;
+    /**
+     * Convert continuous positions to discrete agent indices
+     */
+    private discretize;
+    /**
+     * Get recommended population size for problem
+     */
+    getRecommendedPopulation(problemSize: number): number;
+}
+
+/**
+ * Ant Colony Optimization Engine
+ *
+ * Implements ACO algorithm for path-finding and task sequencing.
+ * Uses pheromone trails to find optimal ordering of choreography steps.
+ */
+interface ACOConfig {
+    antCount: number;
+    maxIterations: number;
+    convergenceThreshold: number;
+    alpha: number;
+    beta: number;
+    evaporationRate: number;
+    q: number;
+    elitistWeight: number;
+}
+interface ACOResult {
+    bestPath: number[];
+    bestCost: number;
+    converged: boolean;
+    iterations: number;
+    costHistory: number[];
+}
+/**
+ * Ant Colony Optimization engine for path/sequence optimization
+ */
+declare class ACOEngine {
+    private config;
+    constructor(config?: Partial<ACOConfig>);
+    /**
+     * Find optimal path through nodes (e.g., task execution order)
+     *
+     * @param nodes Number of nodes to visit
+     * @param distanceMatrix Distance/cost between nodes [i][j]
+     * @returns Optimization result with best path
+     */
+    optimize(nodes: number, distanceMatrix: number[][]): Promise<ACOResult>;
+    /**
+     * Initialize pheromone matrix with uniform values
+     */
+    private initializePheromones;
+    /**
+     * Compute heuristic values (inverse distance)
+     */
+    private computeHeuristics;
+    /**
+     * Construct a solution path for one ant
+     */
+    private constructSolution;
+    /**
+     * Calculate total path cost
+     */
+    private calculatePathCost;
+    /**
+     * Evaporate pheromones
+     */
+    private evaporatePheromones;
+    /**
+     * Deposit pheromones based on solution quality
+     */
+    private depositPheromones;
+    /**
+     * Elitist reinforcement of best path
+     */
+    private reinforceBestPath;
+    /**
+     * Get recommended ant count for problem
+     */
+    getRecommendedAntCount(nodes: number): number;
+}
+
+/**
+ * Leader Election System
+ *
+ * Implements Raft-inspired leader election for agent clusters.
+ * Provides fault-tolerant leader selection with automatic failover.
+ */
+
+interface LeaderElectionConfig {
+    electionTimeoutMin: number;
+    electionTimeoutMax: number;
+    heartbeatInterval: number;
+    quorumSize?: number;
+}
+type ElectionRole = 'leader' | 'follower' | 'candidate';
+interface ElectionState {
+    term: number;
+    votedFor: string | null;
+    role: ElectionRole;
+    leaderId: string | null;
+    votes: Set<string>;
+}
+/**
+ * Raft-inspired leader election for agent clusters
+ */
+declare class LeaderElection implements ILeaderElection {
+    private nodeId;
+    private clusterMembers;
+    private config;
+    private state;
+    private electionTimer;
+    private heartbeatTimer;
+    private callbacks;
+    private messageHandler;
+    constructor(nodeId: string, clusterMembers: string[], config?: Partial<LeaderElectionConfig>);
+    /**
+     * Start participating in leader election
+     */
+    startElection(): Promise<string>;
+    /**
+     * Get current leader
+     */
+    getLeader(): string | null;
+    /**
+     * Get this node's current role
+     */
+    getRole(): ElectionRole;
+    /**
+     * Subscribe to leader changes
+     */
+    onLeaderChange(callback: (leaderId: string | null) => void): () => void;
+    /**
+     * Handle incoming election message
+     */
+    handleMessage(from: string, message: ElectionMessage): void;
+    /**
+     * Set message handler for sending messages to other nodes
+     */
+    setMessageHandler(handler: (from: string, message: ElectionMessage) => void): void;
+    /**
+     * Simulate receiving vote from another node (for testing/local clusters)
+     */
+    receiveVote(voterId: string): void;
+    /**
+     * Stop participating in election
+     */
+    stop(): void;
+    /**
+     * Transition to candidate role and start election
+     */
+    private becomeCandidate;
+    /**
+     * Transition to leader role
+     */
+    private becomeLeader;
+    /**
+     * Transition to follower role
+     */
+    private becomeFollower;
+    /**
+     * Request votes from all cluster members
+     */
+    private requestVotes;
+    /**
+     * Check if we've won the election
+     */
+    private checkElectionWin;
+    /**
+     * Send heartbeats to all followers
+     */
+    private sendHeartbeats;
+    /**
+     * Handle vote request from candidate
+     */
+    private handleVoteRequest;
+    /**
+     * Handle vote response
+     */
+    private handleVoteResponse;
+    /**
+     * Handle heartbeat from leader
+     */
+    private handleHeartbeat;
+    /**
+     * Reset election timeout
+     */
+    private resetElectionTimer;
+    /**
+     * Get random election timeout in configured range
+     */
+    private getRandomElectionTimeout;
+    /**
+     * Calculate quorum size (majority)
+     */
+    private getQuorumSize;
+    /**
+     * Notify all callbacks of leader change
+     */
+    private notifyLeaderChange;
+}
+type ElectionMessage = VoteRequestMessage | VoteResponseMessage | HeartbeatMessage;
+interface VoteRequestMessage {
+    type: 'request-vote';
+    term: number;
+    candidateId: string;
+}
+interface VoteResponseMessage {
+    type: 'vote-response';
+    term: number;
+    voteGranted: boolean;
+}
+interface HeartbeatMessage {
+    type: 'heartbeat';
+    term: number;
+    leaderId: string;
+}
+
+/**
+ * Voting Round
+ *
+ * Manages voting on contributions in collective intelligence sessions.
+ */
+
+interface Vote {
+    contributionId: string;
+    voterId: string;
+    vote: 'support' | 'oppose';
+    weight: number;
+    timestamp: number;
+}
+interface VotingResult {
+    contributionId: string;
+    supportVotes: number;
+    opposeVotes: number;
+    netScore: number;
+    weightedScore: number;
+    voterIds: string[];
+}
+interface VotingRoundConfig {
+    minVotesRequired: number;
+    superMajorityThreshold: number;
+    allowAbstain: boolean;
+    weightByConfidence: boolean;
+}
+/**
+ * Manages voting on a set of contributions
+ */
+declare class VotingRound {
+    private config;
+    private votes;
+    private contributions;
+    private closed;
+    constructor(config?: Partial<VotingRoundConfig>);
+    /**
+     * Register a contribution for voting
+     */
+    registerContribution(contribution: IHiveContribution): void;
+    /**
+     * Cast a vote on a contribution
+     */
+    castVote(contributionId: string, voterId: string, vote: 'support' | 'oppose', voterConfidence?: number): void;
+    /**
+     * Get current results for a contribution
+     */
+    getResult(contributionId: string): VotingResult | undefined;
+    /**
+     * Get all results, ranked by score
+     */
+    getAllResults(): VotingResult[];
+    /**
+     * Check if a contribution has reached super-majority
+     */
+    hasSuperMajority(contributionId: string): boolean;
+    /**
+     * Get contributions that have reached super-majority
+     */
+    getApprovedContributions(): IHiveContribution[];
+    /**
+     * Get the top-ranked contribution
+     */
+    getWinner(): IHiveContribution | undefined;
+    /**
+     * Close the voting round
+     */
+    close(): void;
+    /**
+     * Check if voting is closed
+     */
+    isClosed(): boolean;
+    /**
+     * Get voting statistics
+     */
+    getStatistics(): {
+        totalContributions: number;
+        totalVotes: number;
+        participationRate: number;
+        hasConsensus: boolean;
+    };
+}
+
+/**
+ * Contribution Synthesizer
+ *
+ * Synthesizes multiple contributions into unified insights.
+ */
+
+interface SynthesisResult {
+    synthesizedContent: string;
+    sourceContributions: string[];
+    synthesisMethod: 'merge' | 'consensus' | 'weighted' | 'hierarchical';
+    confidence: number;
+    metadata: {
+        totalContributions: number;
+        ideaCount: number;
+        critiqueCount: number;
+        consensusCount: number;
+        solutionCount: number;
+        averageConfidence: number;
+        keyThemes: string[];
+    };
+}
+interface SynthesizerConfig {
+    minConfidenceThreshold: number;
+    preferSolutions: boolean;
+    includeCritiques: boolean;
+    maxSourcesPerSynthesis: number;
+}
+/**
+ * Synthesizes contributions from a collective intelligence session
+ */
+declare class ContributionSynthesizer {
+    private config;
+    constructor(config?: Partial<SynthesizerConfig>);
+    /**
+     * Synthesize all contributions in a session
+     */
+    synthesize(session: IHiveSession): SynthesisResult;
+    /**
+     * Synthesize a subset of contributions
+     */
+    synthesizeSubset(contributions: IHiveContribution[]): SynthesisResult;
+    /**
+     * Merge two contributions into one
+     */
+    merge(a: IHiveContribution, b: IHiveContribution): IHiveContribution;
+    /**
+     * Find similar contributions
+     */
+    findSimilar(target: IHiveContribution, candidates: IHiveContribution[], threshold?: number): IHiveContribution[];
+    private createEmptyResult;
+    private groupByType;
+    private determineSynthesisMethod;
+    private performSynthesis;
+    private synthesizeHierarchical;
+    private synthesizeConsensus;
+    private synthesizeWeighted;
+    private synthesizeMerge;
+    private extractKeyThemes;
+    private calculateAverageConfidence;
+    private calculateSimilarity;
+}
+
+/**
+ * Collective Intelligence Service
+ *
+ * Implements ICollectiveIntelligenceService for collaborative
+ * problem-solving through hive sessions.
+ */
+
+interface CollectiveIntelligenceConfig {
+    maxParticipants: number;
+    votingThreshold: number;
+    synthesisMinContributions: number;
+    autoCloseOnResolution: boolean;
+    contributionTimeoutMs: number;
+}
+/**
+ * Collective Intelligence Service
+ *
+ * Enables groups of agents to collaborate on complex problems through
+ * structured sessions with contributions, voting, and synthesis.
+ */
+declare class CollectiveIntelligence implements ICollectiveIntelligenceService {
+    private config;
+    private sessions;
+    private votingRounds;
+    private synthesizer;
+    private contributionIdCounter;
+    constructor(config?: Partial<CollectiveIntelligenceConfig>);
+    /**
+     * Create a new hive session
+     */
+    createSession(topic: string, goal: string, initiator: string): IHiveSession;
+    /**
+     * Join an existing session
+     */
+    join(sessionId: string, agentId: string): void;
+    /**
+     * Leave a session
+     */
+    leave(sessionId: string, agentId: string): void;
+    /**
+     * Contribute to a session
+     */
+    contribute(sessionId: string, contribution: Omit<IHiveContribution, 'id' | 'timestamp'>): IHiveContribution;
+    /**
+     * Vote on a contribution
+     */
+    vote(sessionId: string, contributionId: string, voterId: string, vote: 'support' | 'oppose'): void;
+    /**
+     * Synthesize all contributions
+     */
+    synthesize(sessionId: string): SynthesisResult;
+    /**
+     * Resolve a session with a final decision
+     */
+    resolve(sessionId: string, resolution: string): void;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): IHiveSession | undefined;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): IHiveSession[];
+    /**
+     * Close a session without resolution
+     */
+    closeSession(sessionId: string): void;
+    /**
+     * Get voting results for a session
+     */
+    getVotingResults(sessionId: string): VotingResult[];
+    /**
+     * Get the top-voted contribution
+     */
+    getTopContribution(sessionId: string): IHiveContribution | undefined;
+    /**
+     * Get session statistics
+     */
+    getSessionStats(sessionId: string): {
+        participantCount: number;
+        contributionCount: number;
+        votingStats: ReturnType<VotingRound['getStatistics']>;
+        contributionsByType: Record<IHiveContribution['type'], number>;
+        averageConfidence: number;
+    } | undefined;
+    /**
+     * Auto-resolve if consensus reached
+     */
+    checkForConsensus(sessionId: string): boolean;
+    /**
+     * Get contributions by a specific agent
+     */
+    getAgentContributions(sessionId: string, agentId: string): IHiveContribution[];
+    /**
+     * Find similar contributions in a session
+     */
+    findSimilarContributions(sessionId: string, contributionId: string): IHiveContribution[];
+    private generateSessionId;
+    private generateContributionId;
+}
+
+/**
+ * Quorum Policy
+ *
+ * Enforces minimum size requirements for swarm operations.
+ */
+interface QuorumConfig {
+    minimumSize: number;
+    optimalSize: number;
+    maximumSize: number;
+    requireQuorumForOperations: boolean;
+    quorumPercentage: number;
+}
+type QuorumStatus = 'below-minimum' | 'quorum' | 'optimal' | 'above-maximum';
+interface QuorumState {
+    currentSize: number;
+    status: QuorumStatus;
+    hasQuorum: boolean;
+    canOperate: boolean;
+    requiredForQuorum: number;
+    spotsAvailable: number;
+}
+/**
+ * Manages quorum requirements for a swarm
+ */
+declare class QuorumPolicy {
+    private config;
+    private currentSize;
+    constructor(config?: Partial<QuorumConfig>);
+    private validateConfig;
+    /**
+     * Update the current member count
+     */
+    setMemberCount(count: number): void;
+    /**
+     * Check if a new member can join
+     */
+    canJoin(): boolean;
+    /**
+     * Check if a member can leave without breaking quorum
+     */
+    canLeave(): boolean;
+    /**
+     * Check if the swarm has achieved quorum
+     */
+    hasQuorum(): boolean;
+    /**
+     * Check if the swarm can operate
+     */
+    canOperate(): boolean;
+    /**
+     * Get the current quorum status
+     */
+    getStatus(): QuorumStatus;
+    /**
+     * Get full quorum state
+     */
+    getState(): QuorumState;
+    /**
+     * Check if the swarm should seek more members
+     */
+    shouldRecruit(): boolean;
+    /**
+     * Check if the swarm should consider splitting
+     */
+    shouldSplit(): boolean;
+    /**
+     * Calculate the health score of the swarm (0-1)
+     */
+    getHealthScore(): number;
+    /**
+     * Get the config
+     */
+    getConfig(): QuorumConfig;
+}
+
+/**
+ * Swarm Membership
+ *
+ * Manages agent membership in swarms with join/leave protocol.
+ */
+
+interface MemberInfo {
+    agentId: string;
+    joinedAt: number;
+    role: 'leader' | 'member' | 'observer';
+    status: 'active' | 'inactive' | 'leaving';
+    lastHeartbeat: number;
+    metadata?: Record<string, unknown>;
+}
+interface JoinRequest {
+    agentId: string;
+    requestedRole?: MemberInfo['role'];
+    metadata?: Record<string, unknown>;
+}
+interface LeaveRequest {
+    agentId: string;
+    reason?: string;
+    graceful: boolean;
+}
+interface MembershipEvent {
+    type: 'joined' | 'left' | 'role-changed' | 'status-changed' | 'quorum-lost' | 'quorum-gained';
+    agentId: string;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+interface SwarmMembershipConfig {
+    quorum: Partial<QuorumConfig>;
+    heartbeatTimeoutMs: number;
+    allowObservers: boolean;
+    maxObservers: number;
+    requireApprovalToJoin: boolean;
+}
+type MembershipEventHandler = (event: MembershipEvent) => void;
+/**
+ * Manages membership for a single swarm
+ */
+declare class SwarmMembership {
+    private config;
+    private members;
+    private quorumPolicy;
+    private eventHandlers;
+    private pendingJoins;
+    private leaderId;
+    constructor(config?: Partial<SwarmMembershipConfig>);
+    /**
+     * Request to join the swarm
+     */
+    join(request: JoinRequest): boolean;
+    /**
+     * Approve a pending join request (leader only)
+     */
+    approveJoin(approverId: string, agentId: string): boolean;
+    /**
+     * Leave the swarm
+     */
+    leave(request: LeaveRequest): boolean;
+    /**
+     * Force remove a member (for leadership or timeouts)
+     */
+    removeForcefully(agentId: string, _reason: string): void;
+    /**
+     * Update heartbeat for a member
+     */
+    heartbeat(agentId: string): void;
+    /**
+     * Check for timed-out members
+     */
+    checkTimeouts(): string[];
+    /**
+     * Change a member's role
+     */
+    changeRole(agentId: string, newRole: MemberInfo['role']): boolean;
+    /**
+     * Get member by ID
+     */
+    getMember(agentId: string): MemberInfo | undefined;
+    /**
+     * Get all members
+     */
+    getMembers(): MemberInfo[];
+    /**
+     * Get active members (non-observers)
+     */
+    getActiveMembers(): MemberInfo[];
+    /**
+     * Get the current leader
+     */
+    getLeader(): MemberInfo | undefined;
+    /**
+     * Get quorum state
+     */
+    getQuorumState(): QuorumState;
+    /**
+     * Get member count
+     */
+    getMemberCount(): number;
+    /**
+     * Subscribe to membership events
+     */
+    onEvent(handler: MembershipEventHandler): () => void;
+    /**
+     * Get pending join requests
+     */
+    getPendingJoins(): JoinRequest[];
+    private addMember;
+    private addObserver;
+    private removeMember;
+    private electNewLeader;
+    private getActiveMemberCount;
+    private emit;
+}
+
+/**
+ * Swarm Manager
+ *
+ * Orchestrates swarm formation, disbandment, and lifecycle.
+ */
+
+interface SwarmInfo {
+    id: string;
+    name: string;
+    objective: string;
+    createdAt: number;
+    createdBy: string;
+    status: 'forming' | 'active' | 'disbanding' | 'disbanded';
+    membership: SwarmMembership;
+    metadata?: Record<string, unknown>;
+}
+interface CreateSwarmRequest {
+    name: string;
+    objective: string;
+    createdBy: string;
+    membershipConfig?: Partial<SwarmMembershipConfig>;
+    metadata?: Record<string, unknown>;
+}
+interface DisbandOptions {
+    reason: string;
+    redistributeTasks: boolean;
+    notifyMembers: boolean;
+}
+interface SwarmManagerConfig {
+    maxSwarmsPerAgent: number;
+    defaultMembershipConfig: Partial<SwarmMembershipConfig>;
+    disbandEmptySwarms: boolean;
+    disbandTimeoutMs: number;
+}
+interface SwarmEvent {
+    type: 'swarm-created' | 'swarm-disbanded' | 'member-joined' | 'member-left' | 'status-changed';
+    swarmId: string;
+    agentId?: string;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+type SwarmEventHandler = (event: SwarmEvent) => void;
+/**
+ * Manages the lifecycle of multiple swarms
+ */
+declare class SwarmManager {
+    private config;
+    private swarms;
+    private agentSwarms;
+    private eventHandlers;
+    private disbandTimeouts;
+    constructor(config?: Partial<SwarmManagerConfig>);
+    /**
+     * Create a new swarm
+     */
+    createSwarm(request: CreateSwarmRequest): SwarmInfo;
+    /**
+     * Join an existing swarm
+     */
+    joinSwarm(swarmId: string, agentId: string, asObserver?: boolean): boolean;
+    /**
+     * Leave a swarm
+     */
+    leaveSwarm(swarmId: string, agentId: string, graceful?: boolean): boolean;
+    /**
+     * Disband a swarm
+     */
+    disbandSwarm(swarmId: string, options: DisbandOptions): void;
+    /**
+     * Get a swarm by ID
+     */
+    getSwarm(swarmId: string): SwarmInfo | undefined;
+    /**
+     * Get all swarms
+     */
+    getAllSwarms(): SwarmInfo[];
+    /**
+     * Get active swarms
+     */
+    getActiveSwarms(): SwarmInfo[];
+    /**
+     * Get swarms an agent is member of
+     */
+    getAgentSwarms(agentId: string): SwarmInfo[];
+    /**
+     * Find swarms by objective (simple text match)
+     */
+    findSwarmsByObjective(query: string): SwarmInfo[];
+    /**
+     * Get swarm statistics
+     */
+    getSwarmStats(swarmId: string): {
+        memberCount: number;
+        quorumState: QuorumState;
+        ageMs: number;
+        healthScore: number;
+    } | undefined;
+    /**
+     * Subscribe to swarm events
+     */
+    onEvent(handler: SwarmEventHandler): () => void;
+    /**
+     * Perform maintenance (check heartbeats, timeouts)
+     */
+    performMaintenance(): string[];
+    private handleMembershipEvent;
+    private checkForEmptySwarm;
+    private calculateHealthScore;
+    private trackAgentSwarm;
+    private untrackAgentSwarm;
+    private emit;
+    private generateSwarmId;
+}
+
+/**
+ * Vector3 - 3D vector for spatial calculations
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ */
+/**
+ * 3D Vector class for spatial operations
+ */
+declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    /**
+     * Create from array
+     */
+    static fromArray(arr: number[]): Vector3;
+    /**
+     * Create zero vector
+     */
+    static zero(): Vector3;
+    /**
+     * Create unit vector
+     */
+    static one(): Vector3;
+    /**
+     * Add another vector
+     */
+    add(v: Vector3): Vector3;
+    /**
+     * Subtract another vector
+     */
+    subtract(v: Vector3): Vector3;
+    /**
+     * Multiply by scalar
+     */
+    multiply(scalar: number): Vector3;
+    /**
+     * Divide by scalar
+     */
+    divide(scalar: number): Vector3;
+    /**
+     * Get magnitude (length)
+     */
+    magnitude(): number;
+    /**
+     * Get squared magnitude (faster for comparisons)
+     */
+    magnitudeSquared(): number;
+    /**
+     * Normalize to unit vector
+     */
+    normalize(): Vector3;
+    /**
+     * Dot product
+     */
+    dot(v: Vector3): number;
+    /**
+     * Cross product
+     */
+    cross(v: Vector3): Vector3;
+    /**
+     * Distance to another vector
+     */
+    distanceTo(v: Vector3): number;
+    /**
+     * Squared distance (faster for comparisons)
+     */
+    distanceToSquared(v: Vector3): number;
+    /**
+     * Linear interpolation
+     */
+    lerp(v: Vector3, t: number): Vector3;
+    /**
+     * Clamp magnitude
+     */
+    clampMagnitude(maxLength: number): Vector3;
+    /**
+     * Check equality within epsilon
+     */
+    equals(v: Vector3, epsilon?: number): boolean;
+    /**
+     * Clone vector
+     */
+    clone(): Vector3;
+    /**
+     * Convert to array
+     */
+    toArray(): [number, number, number];
+    /**
+     * String representation
+     */
+    toString(): string;
+}
+
+/**
+ * FlockingBehavior - Boid-based swarm movement
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Implements Craig Reynolds' Boids algorithm:
+ * - Separation: Steer to avoid crowding neighbors
+ * - Alignment: Steer towards average heading of neighbors
+ * - Cohesion: Steer towards average position of neighbors
+ */
+
+/**
+ * Boid agent state
+ */
+interface IBoid {
+    id: string;
+    position: Vector3;
+    velocity: Vector3;
+    acceleration: Vector3;
+    maxSpeed: number;
+    maxForce: number;
+}
+/**
+ * Flocking configuration
+ */
+interface IFlockingConfig {
+    /** Radius for separation behavior */
+    separationRadius: number;
+    /** Radius for alignment behavior */
+    alignmentRadius: number;
+    /** Radius for cohesion behavior */
+    cohesionRadius: number;
+    /** Weight for separation force */
+    separationWeight: number;
+    /** Weight for alignment force */
+    alignmentWeight: number;
+    /** Weight for cohesion force */
+    cohesionWeight: number;
+    /** Maximum speed */
+    maxSpeed: number;
+    /** Maximum steering force */
+    maxForce: number;
+    /** Boundary mode */
+    boundaryMode: 'wrap' | 'bounce' | 'contain';
+    /** World bounds (if boundaryMode is not 'none') */
+    worldBounds?: {
+        min: Vector3;
+        max: Vector3;
+    };
+}
+/**
+ * FlockingBehavior - Manages Boid-based swarm movement
+ */
+declare class FlockingBehavior {
+    private boids;
+    private config;
+    constructor(config?: Partial<IFlockingConfig>);
+    /**
+     * Add a boid to the flock
+     */
+    addBoid(id: string, position: Vector3, velocity?: Vector3): IBoid;
+    /**
+     * Remove a boid from the flock
+     */
+    removeBoid(id: string): boolean;
+    /**
+     * Get a boid by ID
+     */
+    getBoid(id: string): IBoid | undefined;
+    /**
+     * Get all boids
+     */
+    getAllBoids(): IBoid[];
+    /**
+     * Update boid position manually
+     */
+    setBoidPosition(id: string, position: Vector3): void;
+    /**
+     * Update a single boid
+     */
+    updateBoid(boid: IBoid, neighbors: IBoid[]): void;
+    /**
+     * Update all boids in the flock
+     */
+    update(): void;
+    /**
+     * Separation: Steer away from nearby boids
+     */
+    separate(boid: IBoid, neighbors: IBoid[]): Vector3;
+    /**
+     * Alignment: Steer towards average heading of neighbors
+     */
+    align(boid: IBoid, neighbors: IBoid[]): Vector3;
+    /**
+     * Cohesion: Steer towards center of mass of neighbors
+     */
+    cohere(boid: IBoid, neighbors: IBoid[]): Vector3;
+    /**
+     * Seek: Steer towards a target location
+     */
+    seek(boid: IBoid, target: Vector3): Vector3;
+    /**
+     * Flee: Steer away from a target location
+     */
+    flee(boid: IBoid, target: Vector3): Vector3;
+    /**
+     * Arrive: Seek with slowing as approaching target
+     */
+    arrive(boid: IBoid, target: Vector3, slowingRadius: number): Vector3;
+    /**
+     * Find neighbors within radius
+     */
+    findNeighbors(boid: IBoid, radius: number): IBoid[];
+    /**
+     * Handle world boundaries
+     */
+    private handleBoundaries;
+    /**
+     * Wrap position to opposite side
+     */
+    private wrapPosition;
+    /**
+     * Bounce off boundaries
+     */
+    private bouncePosition;
+    /**
+     * Contain within boundaries (clamp)
+     */
+    private containPosition;
+    /**
+     * Apply external force to a boid
+     */
+    applyForce(id: string, force: Vector3): void;
+    /**
+     * Apply force to all boids
+     */
+    applyForceToAll(force: Vector3): void;
+    /**
+     * Get flock center of mass
+     */
+    getFlockCenter(): Vector3;
+    /**
+     * Get average velocity (direction) of flock
+     */
+    getFlockDirection(): Vector3;
+    /**
+     * Get flock spread (radius from center)
+     */
+    getFlockSpread(): number;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<IFlockingConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): IFlockingConfig;
+}
+
+/**
+ * FormationController - Geometric swarm formations
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Manages precise geometric arrangements of swarm agents
+ */
+
+/**
+ * Formation patterns
+ */
+type FormationType = 'line' | 'circle' | 'grid' | 'wedge' | 'diamond' | 'sphere' | 'custom';
+/**
+ * Formation slot - assigned position for an agent
+ */
+interface IFormationSlot {
+    index: number;
+    agentId: string | null;
+    localPosition: Vector3;
+    worldPosition: Vector3;
+    isLeaderSlot: boolean;
+}
+/**
+ * Formation configuration
+ */
+interface IFormationConfig {
+    type: FormationType;
+    spacing: number;
+    orientation: Vector3;
+    scale: number;
+    centerOffset: Vector3;
+    rotationAngle: number;
+}
+/**
+ * FormationController - Manages geometric swarm formations
+ */
+declare class FormationController {
+    private slots;
+    private agentSlots;
+    private center;
+    private config;
+    private slotCount;
+    constructor(config?: Partial<IFormationConfig>);
+    /**
+     * Generate formation slots for given count
+     */
+    generateSlots(count: number): IFormationSlot[];
+    /**
+     * Line formation - agents in a row
+     */
+    private generateLineFormation;
+    /**
+     * Circle formation - agents in a ring
+     */
+    private generateCircleFormation;
+    /**
+     * Grid formation - agents in rows and columns
+     */
+    private generateGridFormation;
+    /**
+     * Wedge formation - V-shaped, leader at point
+     */
+    private generateWedgeFormation;
+    /**
+     * Diamond formation - diamond shape, leader at front point
+     */
+    private generateDiamondFormation;
+    /**
+     * Sphere formation - 3D spherical arrangement
+     */
+    private generateSphereFormation;
+    /**
+     * Set custom formation positions
+     */
+    setCustomFormation(positions: Vector3[]): void;
+    /**
+     * Assign an agent to a slot
+     */
+    assignAgent(agentId: string, slotIndex?: number): number;
+    /**
+     * Remove an agent from its slot
+     */
+    removeAgent(agentId: string): boolean;
+    /**
+     * Get agent's assigned slot
+     */
+    getAgentSlot(agentId: string): IFormationSlot | undefined;
+    /**
+     * Get target position for an agent
+     */
+    getAgentTarget(agentId: string): Vector3 | undefined;
+    /**
+     * Get all slots
+     */
+    getAllSlots(): IFormationSlot[];
+    /**
+     * Get available (unassigned) slots
+     */
+    getAvailableSlots(): IFormationSlot[];
+    /**
+     * Get assigned slots
+     */
+    getAssignedSlots(): IFormationSlot[];
+    /**
+     * Set formation center position
+     */
+    setCenter(position: Vector3): void;
+    /**
+     * Get formation center
+     */
+    getCenter(): Vector3;
+    /**
+     * Set rotation angle
+     */
+    setRotation(angle: number): void;
+    /**
+     * Update world positions based on center and rotation
+     */
+    private updateWorldPositions;
+    /**
+     * Convert local position to world position
+     */
+    private localToWorld;
+    /**
+     * Check if formation is complete (all slots filled)
+     */
+    isComplete(): boolean;
+    /**
+     * Get formation completeness ratio
+     */
+    getCompletenessRatio(): number;
+    /**
+     * Get formation tightness (average distance from target)
+     */
+    getFormationTightness(agentPositions: Map<string, Vector3>): number;
+    /**
+     * Reoptimize slot assignments (minimize total distance)
+     */
+    optimizeAssignments(agentPositions: Map<string, Vector3>): void;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<IFormationConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): IFormationConfig;
+}
+
+/**
+ * ZoneClaiming - Territory awareness for swarm agents
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Manages spatial zones that agents can claim, contest, and defend
+ */
+
+/**
+ * Zone state
+ */
+type ZoneState = 'unclaimed' | 'contested' | 'claimed' | 'defended';
+/**
+ * Zone claim
+ */
+interface IZoneClaim {
+    agentId: string;
+    swarmId?: string;
+    claimedAt: number;
+    strength: number;
+    lastReinforced: number;
+}
+/**
+ * Zone definition
+ */
+interface IZone {
+    id: string;
+    center: Vector3;
+    radius: number;
+    state: ZoneState;
+    claims: IZoneClaim[];
+    owner: string | null;
+    ownerSwarm: string | null;
+    value: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Zone event
+ */
+interface IZoneEvent {
+    type: 'claimed' | 'contested' | 'captured' | 'defended' | 'abandoned';
+    zoneId: string;
+    agentId?: string;
+    swarmId?: string;
+    previousOwner?: string;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+/**
+ * Zone claiming configuration
+ */
+interface IZoneClaimingConfig {
+    /** Minimum strength to claim a zone */
+    claimThreshold: number;
+    /** Strength required to capture contested zone */
+    captureThreshold: number;
+    /** Decay rate per second for claim strength */
+    strengthDecayRate: number;
+    /** Reinforcement rate per second when in zone */
+    reinforceRate: number;
+    /** Bonus for having swarm members in zone */
+    swarmBonus: number;
+    /** Defense bonus for owner */
+    defenseBonus: number;
+}
+type EventHandler$1 = (event: IZoneEvent) => void;
+/**
+ * ZoneClaiming - Manages territory control mechanics
+ */
+declare class ZoneClaiming {
+    private zones;
+    private agentZones;
+    private config;
+    private eventHandlers;
+    constructor(config?: Partial<IZoneClaimingConfig>);
+    /**
+     * Create a new zone
+     */
+    createZone(id: string, center: Vector3, radius: number, options?: {
+        value?: number;
+        metadata?: Record<string, unknown>;
+    }): IZone;
+    /**
+     * Remove a zone
+     */
+    removeZone(zoneId: string): boolean;
+    /**
+     * Get a zone by ID
+     */
+    getZone(zoneId: string): IZone | undefined;
+    /**
+     * Get all zones
+     */
+    getAllZones(): IZone[];
+    /**
+     * Find zones containing a position
+     */
+    findZonesAt(position: Vector3): IZone[];
+    /**
+     * Check if an agent is in a zone
+     */
+    isAgentInZone(agentId: string, zoneId: string, agentPosition: Vector3): boolean;
+    /**
+     * Add or reinforce an agent's claim to a zone
+     */
+    claimZone(agentId: string, zoneId: string, options?: {
+        swarmId?: string;
+        strength?: number;
+    }): IZoneClaim | null;
+    /**
+     * Release an agent's claim to a zone
+     */
+    releaseClaim(agentId: string, zoneId: string): boolean;
+    /**
+     * Update zone state based on claims
+     */
+    private updateZoneState;
+    /**
+     * Apply decay to all claims
+     */
+    applyDecay(deltaTimeSeconds: number): void;
+    /**
+     * Get zones owned by an agent/swarm
+     */
+    getOwnedZones(ownerId: string): IZone[];
+    /**
+     * Get zones an agent has claims in
+     */
+    getAgentClaims(agentId: string): IZone[];
+    /**
+     * Get claim strength of an agent in a zone
+     */
+    getClaimStrength(agentId: string, zoneId: string): number;
+    /**
+     * Get total swarm strength in a zone
+     */
+    getSwarmStrength(swarmId: string, zoneId: string): number;
+    /**
+     * Get contested zones
+     */
+    getContestedZones(): IZone[];
+    /**
+     * Get unclaimed zones
+     */
+    getUnclaimedZones(): IZone[];
+    /**
+     * Get zones by state
+     */
+    getZonesByState(state: ZoneState): IZone[];
+    /**
+     * Calculate total value of owned zones
+     */
+    getTotalValue(ownerId: string): number;
+    /**
+     * Subscribe to zone events
+     */
+    onEvent(handler: EventHandler$1): () => void;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Get zone statistics
+     */
+    getStatistics(): {
+        total: number;
+        unclaimed: number;
+        contested: number;
+        claimed: number;
+        defended: number;
+        totalValue: number;
+        claimedValue: number;
+    };
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<IZoneClaimingConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): IZoneClaimingConfig;
+}
+
+/**
+ * SwarmEventBus - Central event coordination for swarm communication
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Decoupled pub/sub messaging between swarm components
+ */
+/**
+ * Event priority levels
+ */
+type EventPriority = 'low' | 'normal' | 'high' | 'critical';
+/**
+ * Swarm event interface
+ */
+interface ISwarmEvent {
+    id: string;
+    type: string;
+    source: string;
+    target?: string | string[];
+    payload: unknown;
+    timestamp: number;
+    priority: EventPriority;
+    ttl?: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Event subscription
+ */
+interface IEventSubscription {
+    id: string;
+    pattern: string | RegExp;
+    handler: EventHandler;
+    priority: EventPriority;
+    once: boolean;
+}
+/**
+ * Event handler function type
+ */
+type EventHandler = (event: ISwarmEvent) => void | Promise<void>;
+/**
+ * Event bus configuration
+ */
+interface IEventBusConfig {
+    /** Maximum events in queue */
+    maxQueueSize: number;
+    /** Default TTL for events */
+    defaultTTL: number;
+    /** Enable async event processing */
+    asyncProcessing: boolean;
+    /** Max concurrent async handlers */
+    maxConcurrent: number;
+    /** Dead letter queue enabled */
+    enableDeadLetter: boolean;
+}
+/**
+ * Event bus statistics
+ */
+interface IEventBusStats {
+    eventsPublished: number;
+    eventsDelivered: number;
+    eventsDropped: number;
+    subscriptions: number;
+    pendingEvents: number;
+    deadLetterCount: number;
+}
+/**
+ * SwarmEventBus - Central pub/sub event bus for swarm communication
+ */
+declare class SwarmEventBus {
+    private subscriptions;
+    private eventQueue;
+    private deadLetterQueue;
+    private processing;
+    private config;
+    private stats;
+    private nextId;
+    constructor(config?: Partial<IEventBusConfig>);
+    /**
+     * Publish an event to the bus
+     */
+    publish(type: string, source: string, payload: unknown, options?: {
+        target?: string | string[];
+        priority?: EventPriority;
+        ttl?: number;
+        metadata?: Record<string, unknown>;
+    }): string;
+    /**
+     * Insert event maintaining priority order
+     */
+    private insertByPriority;
+    /**
+     * Subscribe to events matching a pattern
+     */
+    subscribe(pattern: string | RegExp, handler: EventHandler, options?: {
+        priority?: EventPriority;
+        once?: boolean;
+    }): string;
+    /**
+     * Subscribe to an event type once
+     */
+    once(pattern: string | RegExp, handler: EventHandler): string;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribe(subscriptionId: string): boolean;
+    /**
+     * Clear all subscriptions
+     */
+    clearSubscriptions(): void;
+    /**
+     * Process the event queue (public for testing)
+     */
+    processQueue(): Promise<void>;
+    /**
+     * Deliver event to matching subscribers
+     */
+    private deliverEvent;
+    /**
+     * Check if event type matches pattern
+     */
+    private matchesPattern;
+    /**
+     * Emit synchronously (bypass queue)
+     */
+    emit(type: string, source: string, payload: unknown, options?: {
+        target?: string | string[];
+        priority?: EventPriority;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /**
+     * Get pending events in queue
+     */
+    getPendingEvents(): ISwarmEvent[];
+    /**
+     * Get dead letter queue
+     */
+    getDeadLetterQueue(): ISwarmEvent[];
+    /**
+     * Clear dead letter queue
+     */
+    clearDeadLetterQueue(): ISwarmEvent[];
+    /**
+     * Replay dead letter events
+     */
+    replayDeadLetters(): number;
+    /**
+     * Get event bus statistics
+     */
+    getStats(): IEventBusStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get configuration
+     */
+    getConfig(): IEventBusConfig;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<IEventBusConfig>): void;
+}
+
+/**
+ * BroadcastChannel - Named messaging channels for swarm groups
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Provides named channels for targeted group communication
+ */
+/**
+ * Channel message
+ */
+interface IChannelMessage {
+    id: string;
+    channelId: string;
+    senderId: string;
+    content: unknown;
+    timestamp: number;
+    replyTo?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Channel subscriber info
+ */
+interface IChannelSubscriber {
+    id: string;
+    agentId: string;
+    joinedAt: number;
+    role: 'publisher' | 'subscriber' | 'both';
+    lastActivity: number;
+}
+/**
+ * Channel configuration
+ */
+interface IChannelConfig {
+    /** Maximum subscribers per channel */
+    maxSubscribers: number;
+    /** Message history size */
+    historySize: number;
+    /** Allow replays */
+    allowReplay: boolean;
+    /** Require acknowledgment */
+    requireAck: boolean;
+    /** Message TTL in milliseconds */
+    messageTTL: number;
+}
+/**
+ * Message handler type
+ */
+type MessageHandler = (message: IChannelMessage) => void | Promise<void>;
+/**
+ * BroadcastChannel - Named channel for group messaging
+ */
+declare class BroadcastChannel {
+    readonly id: string;
+    readonly name: string;
+    readonly createdAt: number;
+    private subscribers;
+    private handlers;
+    private history;
+    private config;
+    private nextMsgId;
+    private pendingAcks;
+    constructor(id: string, name: string, config?: Partial<IChannelConfig>);
+    /**
+     * Subscribe an agent to the channel
+     */
+    subscribe(agentId: string, handler: MessageHandler, options?: {
+        role?: 'publisher' | 'subscriber' | 'both';
+    }): string;
+    /**
+     * Unsubscribe from the channel
+     */
+    unsubscribe(subscriberId: string): boolean;
+    /**
+     * Broadcast a message to all subscribers
+     */
+    broadcast(senderId: string, content: unknown, options?: {
+        replyTo?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Send a direct message to specific subscriber
+     */
+    sendDirect(senderId: string, targetAgentId: string, content: unknown, options?: {
+        replyTo?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<string | null>;
+    /**
+     * Acknowledge a message
+     */
+    acknowledge(messageId: string, agentId: string): boolean;
+    /**
+     * Check if message is fully acknowledged
+     */
+    isFullyAcknowledged(messageId: string): boolean;
+    /**
+     * Get pending acknowledgments for a message
+     */
+    getPendingAcks(messageId: string): string[];
+    /**
+     * Add message to history
+     */
+    private addToHistory;
+    /**
+     * Get message history
+     */
+    getHistory(options?: {
+        limit?: number;
+        since?: number;
+        senderId?: string;
+    }): IChannelMessage[];
+    /**
+     * Replay history to a subscriber
+     */
+    replayHistory(subscriberId: string, options?: {
+        since?: number;
+        limit?: number;
+    }): Promise<number>;
+    /**
+     * Get all subscribers
+     */
+    getSubscribers(): IChannelSubscriber[];
+    /**
+     * Get subscriber count
+     */
+    getSubscriberCount(): number;
+    /**
+     * Check if agent is subscribed
+     */
+    isSubscribed(agentId: string): boolean;
+    /**
+     * Get channel statistics
+     */
+    getStats(): {
+        subscriberCount: number;
+        historySize: number;
+        pendingAckCount: number;
+        oldestMessage: number | null;
+        newestMessage: number | null;
+    };
+    /**
+     * Get configuration
+     */
+    getConfig(): IChannelConfig;
+    /**
+     * Clear history
+     */
+    clearHistory(): void;
+}
+/**
+ * ChannelManager - Manages multiple broadcast channels
+ */
+declare class ChannelManager {
+    private channels;
+    private agentChannels;
+    private nextId;
+    /**
+     * Create a new channel
+     */
+    createChannel(name: string, config?: Partial<IChannelConfig>): BroadcastChannel;
+    /**
+     * Get a channel by ID
+     */
+    getChannel(channelId: string): BroadcastChannel | undefined;
+    /**
+     * Get channel by name
+     */
+    getChannelByName(name: string): BroadcastChannel | undefined;
+    /**
+     * Delete a channel
+     */
+    deleteChannel(channelId: string): boolean;
+    /**
+     * Get all channels
+     */
+    getAllChannels(): BroadcastChannel[];
+    /**
+     * Subscribe agent to channel
+     */
+    subscribeAgent(agentId: string, channelId: string, handler: MessageHandler, options?: {
+        role?: 'publisher' | 'subscriber' | 'both';
+    }): string;
+    /**
+     * Get channels an agent is subscribed to
+     */
+    getAgentChannels(agentId: string): BroadcastChannel[];
+    /**
+     * Broadcast to multiple channels
+     */
+    multicast(channelIds: string[], senderId: string, content: unknown, options?: {
+        metadata?: Record<string, unknown>;
+    }): Promise<Map<string, string>>;
+    /**
+     * Get channel count
+     */
+    getChannelCount(): number;
+}
+
+/**
+ * GossipProtocol - Epidemic-style message propagation
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Implements gossip-based message spreading for decentralized swarms
+ */
+/**
+ * Gossip message wrapper
+ */
+interface IGossipMessage {
+    id: string;
+    originId: string;
+    content: unknown;
+    type: 'data' | 'heartbeat' | 'membership' | 'custom';
+    version: number;
+    createdAt: number;
+    ttl: number;
+    hops: number;
+    path: string[];
+    signature?: string;
+}
+/**
+ * Peer information
+ */
+interface IGossipPeer {
+    id: string;
+    address: string;
+    lastSeen: number;
+    failureCount: number;
+    isActive: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Gossip protocol configuration
+ */
+interface IGossipConfig {
+    /** Number of peers to gossip to per round */
+    fanout: number;
+    /** Gossip interval in milliseconds */
+    gossipInterval: number;
+    /** Maximum TTL for messages */
+    maxTTL: number;
+    /** Maximum hops per message */
+    maxHops: number;
+    /** Failure threshold before marking peer inactive */
+    failureThreshold: number;
+    /** Time before peer considered stale */
+    peerTimeout: number;
+    /** Whether to deduplicate messages */
+    deduplicate: boolean;
+}
+/**
+ * Message handler for gossip
+ */
+type GossipHandler = (message: IGossipMessage, from: string) => void | Promise<void>;
+/**
+ * Peer selector strategy
+ */
+type PeerSelector = (peers: IGossipPeer[], count: number, exclude?: string[]) => IGossipPeer[];
+/**
+ * GossipProtocol - Epidemic-style message propagation
+ */
+declare class GossipProtocol {
+    readonly nodeId: string;
+    private peers;
+    private seenMessages;
+    private messageQueue;
+    private handlers;
+    private config;
+    private running;
+    private gossipTimer;
+    private peerSelector;
+    private nextMsgId;
+    private stats;
+    constructor(nodeId: string, config?: Partial<IGossipConfig>);
+    /**
+     * Start the gossip protocol
+     */
+    start(): void;
+    /**
+     * Stop the gossip protocol
+     */
+    stop(): void;
+    /**
+     * Check if protocol is running
+     */
+    isRunning(): boolean;
+    /**
+     * Add a peer
+     */
+    addPeer(id: string, address: string, metadata?: Record<string, unknown>): void;
+    /**
+     * Remove a peer
+     */
+    removePeer(id: string): boolean;
+    /**
+     * Get a peer
+     */
+    getPeer(id: string): IGossipPeer | undefined;
+    /**
+     * Get all active peers
+     */
+    getActivePeers(): IGossipPeer[];
+    /**
+     * Get all peers
+     */
+    getAllPeers(): IGossipPeer[];
+    /**
+     * Publish a message to the gossip network
+     */
+    publish(content: unknown, type?: IGossipMessage['type'], options?: {
+        ttl?: number;
+        signature?: string;
+    }): string;
+    /**
+     * Receive a message from a peer
+     */
+    receive(message: IGossipMessage, fromPeerId: string): Promise<boolean>;
+    /**
+     * Subscribe to message types
+     */
+    subscribe(type: IGossipMessage['type'] | '*', handler: GossipHandler): () => void;
+    /**
+     * Set custom peer selector
+     */
+    setPeerSelector(selector: PeerSelector): void;
+    /**
+     * Perform a gossip round
+     */
+    gossipRound(): Promise<void>;
+    /**
+     * Send a message to a peer (override for actual network)
+     */
+    protected sendToPeer(_peer: IGossipPeer, _message: IGossipMessage): Promise<void>;
+    /**
+     * Emit message to handlers
+     */
+    private emitToHandlers;
+    /**
+     * Random peer selection
+     */
+    private randomPeerSelection;
+    /**
+     * Clean old seen messages
+     */
+    private cleanSeenMessages;
+    /**
+     * Clean stale peers
+     */
+    private cleanStalePeers;
+    /**
+     * Send a heartbeat
+     */
+    publishHeartbeat(metadata?: Record<string, unknown>): string;
+    /**
+     * Announce membership change
+     */
+    publishMembership(action: 'join' | 'leave', metadata?: Record<string, unknown>): string;
+    /**
+     * Get statistics
+     */
+    getStats(): typeof this.stats & {
+        peerCount: number;
+        activePeerCount: number;
+        queueSize: number;
+        seenCount: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get configuration
+     */
+    getConfig(): IGossipConfig;
+}
+/**
+ * Anti-entropy sync for eventual consistency
+ */
+declare class AntiEntropySync {
+    private nodeId;
+    private protocol;
+    private dataStore;
+    constructor(nodeId: string, protocol: GossipProtocol);
+    /**
+     * Set a value (stores locally and gossips)
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Get a value
+     */
+    get(key: string): unknown;
+    /**
+     * Get all keys
+     */
+    keys(): string[];
+    /**
+     * Handle sync from gossip
+     */
+    private handleSync;
+    /**
+     * Get data snapshot
+     */
+    getSnapshot(): Map<string, unknown>;
+}
+
+/**
+ * SwarmMetrics - Real-time swarm performance metrics
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Collects and aggregates metrics for swarm monitoring
+ */
+/**
+ * Metric value with timestamp
+ */
+interface IMetricValue {
+    value: number;
+    timestamp: number;
+    labels?: Record<string, string>;
+}
+/**
+ * Metric types
+ */
+type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
+/**
+ * Histogram buckets
+ */
+interface IHistogramBuckets {
+    boundaries: number[];
+    counts: number[];
+    sum: number;
+    count: number;
+}
+/**
+ * Summary percentiles
+ */
+interface ISummaryPercentiles {
+    p50: number;
+    p75: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    count: number;
+    sum: number;
+}
+/**
+ * Metric definition
+ */
+interface IMetricDefinition {
+    name: string;
+    type: MetricType;
+    description: string;
+    unit?: string;
+    labels?: string[];
+}
+/**
+ * Aggregated metric stats
+ */
+interface IMetricStats {
+    name: string;
+    type: MetricType;
+    currentValue: number;
+    min: number;
+    max: number;
+    avg: number;
+    count: number;
+    lastUpdate: number;
+}
+/**
+ * SwarmMetrics - Metrics collector for swarm monitoring
+ */
+declare class SwarmMetrics {
+    private metrics;
+    private counters;
+    private gauges;
+    private histograms;
+    private summaries;
+    private retentionPeriod;
+    private maxSamples;
+    constructor(config?: {
+        retentionPeriod?: number;
+        maxSamples?: number;
+    });
+    /**
+     * Register a new metric
+     */
+    register(definition: IMetricDefinition): void;
+    /**
+     * Increment a counter
+     */
+    increment(name: string, value?: number, _labels?: Record<string, string>): void;
+    /**
+     * Set gauge value
+     */
+    setGauge(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * Observe a value for histogram
+     */
+    observeHistogram(name: string, value: number): void;
+    /**
+     * Set histogram boundaries
+     */
+    setHistogramBoundaries(name: string, boundaries: number[]): void;
+    /**
+     * Observe a value for summary
+     */
+    observeSummary(name: string, value: number): void;
+    /**
+     * Get counter value
+     */
+    getCounter(name: string): number;
+    /**
+     * Get current gauge value
+     */
+    getGauge(name: string): number | undefined;
+    /**
+     * Get gauge history
+     */
+    getGaugeHistory(name: string, since?: number): IMetricValue[];
+    /**
+     * Get histogram buckets
+     */
+    getHistogram(name: string): IHistogramBuckets | undefined;
+    /**
+     * Get summary percentiles
+     */
+    getSummary(name: string): ISummaryPercentiles | undefined;
+    /**
+     * Get metric statistics
+     */
+    getStats(name: string): IMetricStats | undefined;
+    /**
+     * Get all registered metrics
+     */
+    getRegistered(): IMetricDefinition[];
+    /**
+     * Reset a metric
+     */
+    reset(name: string): void;
+    /**
+     * Reset all metrics
+     */
+    resetAll(): void;
+    /**
+     * Get all stats as object
+     */
+    getAllStats(): Record<string, IMetricStats>;
+    /**
+     * Prune old gauge values
+     */
+    private pruneGauge;
+    /**
+     * Export metrics in Prometheus format
+     */
+    toPrometheus(): string;
+}
+
+/**
+ * SwarmInspector - Debugging and inspection tools for swarms
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ *
+ * Provides introspection, debugging, and visualization data for swarms
+ */
+/**
+ * Agent state snapshot
+ */
+interface IAgentSnapshot {
+    id: string;
+    swarmId?: string;
+    state: string;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    velocity?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    health: number;
+    load: number;
+    lastActive: number;
+    properties: Record<string, unknown>;
+}
+/**
+ * Swarm state snapshot
+ */
+interface ISwarmSnapshot {
+    id: string;
+    name?: string;
+    memberCount: number;
+    leaderId?: string;
+    state: string;
+    formation?: string;
+    centroid?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    boundingBox?: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    createdAt: number;
+    properties: Record<string, unknown>;
+}
+/**
+ * Relationship between agents
+ */
+interface IAgentRelation {
+    sourceId: string;
+    targetId: string;
+    type: 'member' | 'leader' | 'neighbor' | 'communication' | 'custom';
+    strength: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Debug event
+ */
+interface IDebugEvent {
+    id: string;
+    timestamp: number;
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    source: string;
+    message: string;
+    data?: unknown;
+}
+/**
+ * Health check result
+ */
+interface IHealthCheck {
+    name: string;
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    message?: string;
+    latency?: number;
+    lastCheck: number;
+}
+/**
+ * Inspection result
+ */
+interface IInspectionResult {
+    timestamp: number;
+    swarms: ISwarmSnapshot[];
+    agents: IAgentSnapshot[];
+    relations: IAgentRelation[];
+    health: IHealthCheck[];
+    summary: {
+        totalSwarms: number;
+        totalAgents: number;
+        healthyAgents: number;
+        averageLoad: number;
+        warnings: string[];
+    };
+}
+/**
+ * Event listener
+ */
+type DebugEventListener = (event: IDebugEvent) => void;
+/**
+ * SwarmInspector - Debugging and inspection tools
+ */
+declare class SwarmInspector {
+    private agentSnapshots;
+    private swarmSnapshots;
+    private relations;
+    private healthChecks;
+    private eventLog;
+    private listeners;
+    private maxEvents;
+    private nextEventId;
+    constructor(config?: {
+        maxEvents?: number;
+    });
+    /**
+     * Update agent snapshot
+     */
+    updateAgent(snapshot: IAgentSnapshot): void;
+    /**
+     * Remove agent snapshot
+     */
+    removeAgent(agentId: string): void;
+    /**
+     * Get agent snapshot
+     */
+    getAgent(agentId: string): IAgentSnapshot | undefined;
+    /**
+     * Get all agents
+     */
+    getAllAgents(): IAgentSnapshot[];
+    /**
+     * Get agents in swarm
+     */
+    getSwarmAgents(swarmId: string): IAgentSnapshot[];
+    /**
+     * Update swarm snapshot
+     */
+    updateSwarm(snapshot: ISwarmSnapshot): void;
+    /**
+     * Remove swarm snapshot
+     */
+    removeSwarm(swarmId: string): void;
+    /**
+     * Get swarm snapshot
+     */
+    getSwarm(swarmId: string): ISwarmSnapshot | undefined;
+    /**
+     * Get all swarms
+     */
+    getAllSwarms(): ISwarmSnapshot[];
+    /**
+     * Add relation between agents
+     */
+    addRelation(relation: IAgentRelation): void;
+    /**
+     * Remove relation
+     */
+    removeRelation(sourceId: string, targetId: string, type?: string): void;
+    /**
+     * Get relations for agent
+     */
+    getAgentRelations(agentId: string): IAgentRelation[];
+    /**
+     * Get all relations
+     */
+    getAllRelations(): IAgentRelation[];
+    /**
+     * Register health check result
+     */
+    registerHealthCheck(check: IHealthCheck): void;
+    /**
+     * Get health check
+     */
+    getHealthCheck(name: string): IHealthCheck | undefined;
+    /**
+     * Get all health checks
+     */
+    getAllHealthChecks(): IHealthCheck[];
+    /**
+     * Get overall health status
+     */
+    getOverallHealth(): 'healthy' | 'degraded' | 'unhealthy';
+    /**
+     * Log a debug event
+     */
+    log(level: IDebugEvent['level'], source: string, message: string, data?: unknown): void;
+    /**
+     * Log helpers
+     */
+    trace(source: string, message: string, data?: unknown): void;
+    debug(source: string, message: string, data?: unknown): void;
+    info(source: string, message: string, data?: unknown): void;
+    warn(source: string, message: string, data?: unknown): void;
+    error(source: string, message: string, data?: unknown): void;
+    /**
+     * Get event log
+     */
+    getEventLog(options?: {
+        level?: IDebugEvent['level'];
+        source?: string;
+        since?: number;
+        limit?: number;
+    }): IDebugEvent[];
+    /**
+     * Add event listener
+     */
+    addEventListener(listener: DebugEventListener): () => void;
+    /**
+     * Clear event log
+     */
+    clearEventLog(): void;
+    /**
+     * Get full inspection result
+     */
+    inspect(): IInspectionResult;
+    /**
+     * Generate a visualization-ready graph
+     */
+    toGraph(): {
+        nodes: Array<{
+            id: string;
+            type: 'agent' | 'swarm';
+            data: unknown;
+        }>;
+        edges: Array<{
+            source: string;
+            target: string;
+            type: string;
+            weight: number;
+        }>;
+    };
+    /**
+     * Reset all state
+     */
+    reset(): void;
+}
+
+export { type ACOConfig, ACOEngine, type ACOResult, type AgentInfo, AntiEntropySync, BroadcastChannel, ChannelManager, CollectiveIntelligence, type CollectiveIntelligenceConfig, ContributionSynthesizer, type CreateSwarmRequest, type DebugEventListener, type DisbandOptions, type ElectionMessage, type ElectionRole, type ElectionState, type EventHandler, type EventPriority, FlockingBehavior, FormationController, type FormationType, type GossipHandler, GossipProtocol, type HeartbeatMessage, type IAgentRelation, type IAgentSnapshot, type IBoid, type IChannelConfig, type IChannelMessage, type IChannelSubscriber, type IDebugEvent, type IEventBusConfig, type IEventBusStats, type IEventSubscription, type IFlockingConfig, type IFormationConfig, type IFormationSlot, type IGossipConfig, type IGossipMessage, type IGossipPeer, type IHealthCheck, type IHistogramBuckets, type IInspectionResult, type IMetricDefinition, type IMetricStats, type IMetricValue, type ISummaryPercentiles, type ISwarmEvent, type ISwarmSnapshot, type IZone, type IZoneClaim, type IZoneClaimingConfig, type IZoneEvent, type JoinRequest, LeaderElection, type LeaderElectionConfig, type LeaveRequest, type MemberInfo, type MembershipEvent, type MessageHandler, type MetricType, type PSOConfig, PSOEngine, type PSOResult, type Particle, type PeerSelector, type QuorumConfig, QuorumPolicy, type QuorumState, type QuorumStatus, SwarmCoordinator, type SwarmEvent, SwarmEventBus, type SwarmInfo, SwarmInspector, SwarmManager, type SwarmManagerConfig, SwarmMembership, type SwarmMembershipConfig, SwarmMetrics, type SynthesisResult, type SynthesizerConfig, type TaskInfo, Vector3, type Vote, type VoteRequestMessage, type VoteResponseMessage, type VotingResult, VotingRound, type VotingRoundConfig, ZoneClaiming, type ZoneState };