@holoscript/framework 6.0.3

package/dist/index.d.ts

@@ -0,0 +1,1729 @@
+import { ac as StoredEntry, ad as ModelConfig, ae as KnowledgeStore, af as AgentConfig, c as BountyManager, ag as TeamConfig, ah as TaskDef, ai as CycleResult, aj as ProposalResult, ak as AgentRuntime, al as SuggestionCreateResult, am as SuggestionVoteResult, an as SuggestionStatus, ao as SuggestionListResult, ap as TeamMode, aq as SetModeResult, ar as DeriveResult, as as AgentPresence, at as PresenceResult, au as HeartbeatResult, e as BountyReward, B as Bounty, h as ClaimResult$1, i as CompletionProof, t as PayoutResult, av as ExcitabilityMetadata, aw as KnowledgeDomain, ax as HotBufferEntry, ay as ConsolidationResult, az as ReconsolidationEvent, aA as DomainConsolidationConfig, aB as KnowledgeInsight, aC as ProtocolAgentConfig, aD as ProtocolAgentHandle } from './InvisibleWallet-rtRrBOA8.js';
+export { aE as AgentCycleResult, aF as AgentPresenceStatus, aG as AgentRole, aH as AgentStatus, b as BountyCurrency, d as BountyManagerConfig, f as BountyStatus, C as CHAIN_IDS, g as CHAIN_ID_TO_NETWORK, aI as ClaimFilter, aJ as ConsensusMode, k as CreatorRevenueAggregator, aK as DOMAIN_CONSOLIDATION, aL as DOMAIN_HALF_LIVES, aM as EmbedResult, I as InvisibleWalletStub, aN as KNOWLEDGE_DOMAINS, aO as KnowledgeConfig, K as KnowledgeListing, m as KnowledgeMarketplace, aP as LLMProvider, n as ListingResult, o as ListingStatus, M as MICRO_PAYMENT_THRESHOLD, p as MicroPaymentLedger, P as PaymentGateway, r as PaymentWebhookService, aQ as PhaseHook, aR as PresenceConfig, v as PricingFactors, aS as ProtocolStyle, w as PurchaseResult, aT as RECONSOLIDATION_WINDOW_MS, aU as ReputationTier, E as RevenueSplitter, aV as SemanticSearchOptions, aW as SlotInfo, aX as SlotRole, aY as Suggestion, aZ as SuggestionVoteEntry, U as USDC_CONTRACTS, a3 as X402Facilitator, aa as X402_VERSION, a_ as applyHalfLifeDecay, a$ as computeExcitability, b0 as triggerReconsolidation } from './InvisibleWallet-rtRrBOA8.js';
+export { A as ActionNode, a as BTContext, B as BTNode, b as BehaviorTree, C as ConditionNode, I as InverterNode, N as NodeStatus, R as RepeaterNode, S as SelectorNode, c as SequenceNode, W as WaitNode } from './BehaviorTree-BrBFECv5.js';
+export { BridgeResult, ClawHubManifest, HoloClawSkill, HoloClawSkillInput, HoloClawSkillOutput, ParsedSkill, SchemaField, SkillActionStep, SkillMetadata, SkillStateVar, SkillTest, SkillTraitDecl, fromHoloClawSkill, generateClawHubManifest, generateClawHubPackage, getHsInstallCommand, getInstallCommand, getPublishCommand, hsplusToSkillMd, parseHsplus, parseSkillMd, skillMdToHsplus, toHoloClawSkill, toHsplus, toSkillMd } from './skills/index.js';
+export { AuditEntry, InitiateOptions, NegotiationConfig, NegotiationEvents, NegotiationProtocol, NegotiationSession, NegotiationStatus, Proposal, ProposalInput, ProposalStatus, Resolution, ResolutionOutcome, TieBreaker, Vote, VoteInput, VoteTally, VotingHandler, VotingMechanism, VotingResult, approvalHandler, bordaHandler, checkQuorum, consensusHandler, getNegotiationProtocol, getTrustWeight, getVotingHandler, majorityHandler, rankedHandler, resetNegotiationProtocol, supermajorityHandler, weightedHandler } from './negotiation/index.js';
+import { G as Goal, B as BaseAgent, A as AgentIdentity, P as PhaseResult, b as ProtocolCycleResult } from './implementations-D9T3un9D.js';
+export { c as BaseService, E as ExecutionPlan, d as ExecutionResult, e as Gotcha, M as MicroPhaseDecomposer, f as MicroPhaseGroup, g as MicroPhaseTask, h as PWGEntry, i as PWGSeverity, j as Pattern, a as ProtocolPhase, S as ServiceConfig, k as ServiceError, l as ServiceErrorCode, m as ServiceHealth, n as ServiceLifecycle, o as ServiceManager, p as ServiceManagerHealth, q as ServiceMetadata, r as ServiceMetrics, W as Wisdom, s as isGotcha, t as isPattern, u as isWisdom } from './implementations-D9T3un9D.js';
+export { O as OrchestratorAgent, m as OrchestratorConfig } from './OrchestratorAgent-Q_CbVTmO.js';
+export { ACOConfig, ACOEngine, ACOResult, AgentInfo, AntiEntropySync, BroadcastChannel, ChannelManager, CollectiveIntelligence, CollectiveIntelligenceConfig, ContributionSynthesizer, CreateSwarmRequest, DebugEventListener, DisbandOptions, ElectionMessage, ElectionRole, ElectionState, EventHandler, EventPriority, FlockingBehavior, FormationController, FormationType, GossipHandler, HeartbeatMessage, IAgentRelation, IAgentSnapshot, IBoid, IChannelConfig, IChannelMessage, IChannelSubscriber, IDebugEvent, IEventBusConfig, IEventBusStats, IEventSubscription, IFlockingConfig, IFormationConfig, IFormationSlot, IGossipConfig, IGossipMessage, IGossipPeer, IHealthCheck, IHistogramBuckets, IInspectionResult, IMetricDefinition, IMetricStats, IMetricValue, ISummaryPercentiles, ISwarmEvent, ISwarmSnapshot, IZone, IZoneClaim, IZoneClaimingConfig, IZoneEvent, JoinRequest, LeaderElection, LeaderElectionConfig, LeaveRequest, MemberInfo, MembershipEvent, MessageHandler, MetricType, PSOConfig, PSOEngine, PSOResult, Particle, PeerSelector, QuorumConfig, QuorumPolicy, QuorumState, QuorumStatus, SwarmCoordinator, SwarmEvent, SwarmEventBus, SwarmInfo, SwarmInspector, SwarmManager, SwarmManagerConfig, SwarmMembership, SwarmMembershipConfig, SwarmMetrics, SynthesisResult, SynthesizerConfig, TaskInfo, Vector3, VoteRequestMessage, VoteResponseMessage, VotingRound, VotingRoundConfig, ZoneClaiming, ZoneState } from './swarm/index.js';
+export { AIAdapter, AICopilot, ALL_CATEGORIES, AnthropicAdapter, AnthropicAdapterConfig, BTStatus, BTTreeContext, BTTreeDef, BehaviorSelector, Blackboard, ExplainResult, FireworksAdapter, FireworksAdapterConfig, FixResult, GeminiAdapter, GeminiAdapterConfig, GenerateOptions, GenerateResult, GenerationAnalytics, GenerationCache, GoalPlanner, GuardFn, GuardNode, HoloScriptGenerator, InfluenceMap, LMStudioAdapter, LMStudioAdapterConfig, NVIDIAAdapter, NVIDIAAdapterConfig, NavMesh, OllamaAdapter, OllamaAdapterConfig, OpenAIAdapter, OpenAIAdapterConfig, OptimizeResult, ParallelNode, PerceptionSystem, PromptTemplate, PromptTemplateSystem, QuickPrompts, SearchResult, SemanticSearchService, StateAction, StateConfig, StateMachine, SteeringBehavior, SteeringBehaviors, TemplateContext, TogetherAdapter, TogetherAdapterConfig, TrainingDataGenerator, TransitionConfig, UtilityAI, XAIAdapter, XAIAdapterConfig, cachedGenerate, createAnalytics, createTrainingDataGenerator, explainHoloScript, fixHoloScript, generateBatch, generateHoloScript, generateHoloScriptWithAdapter, getAIAdapter, getDefaultAIAdapter, isAISafe, listAIAdapters, optimizeHoloScript, registerAIAdapter, setDefaultAIAdapter, unregisterAIAdapter, useAnthropic, useFireworks, useGemini, useGrok, useLMStudio, useNVIDIA, useOllama, useOpenAI, useTogether, useXAI, validateAIOutput, validateBatch } from './ai/index.js';
+export { AlpacaEntry, DEFAULT_GENERATOR_THRESHOLDS, DEFAULT_INTEGRATION_CONFIG, DEFAULT_LR_SCHEDULER_CONFIG, DEFAULT_SCORING_CONFIG, DEFAULT_SOFTDEDUP_CONFIG, DEFAULT_TRAINING_PIPELINE_CONFIG, DIFFICULTY_LEVELS, DatasetSplit, DifficultyLevel, EnergyEfficiencyMetrics, GRPO_LR_SCHEDULER_CONFIG, GeneratorMetrics, IntegrationResult, LRScheduleStats, LRScheduler, LRSchedulerConfig, LRSchedulerSnapshot, LayerActivityInput, NgramStats, PipelineSettings, QUALITY_THRESHOLDS, QualityDetail, QualityScore, QualityScoringConfig, QualityScoringPipeline, QualityTier, RULEFORGE_DOMAINS, RuleForgeDomain, SNNLayerMetrics, SceneObject, SoftDedup, SoftDedupConfig, SoftDedupResult, SoftDedupStats, SparsityMonitor, SparsityMonitorConfig, SparsityMonitorStats, SparsityQualityHistoryEntry, SparsitySnapshot, SparsityViolation, SpatialDifficulty, SpatialGeneratorConfig, SpatialGeneratorStats, SpatialRelationship, SpatialRelationshipParams, SpatialRelationshipType, SpatialScene, SpatialTrainingDataGenerator, SpatialTrainingExample, SpatialTrainingJSONLEntry, SplitStats, TM_REGISTERED_TRAITS, TRAINING_CATEGORIES, TrainingCategory, TrainingCompressionResult, TrainingExample, TrainingExampleMetadata, TrainingHyperparameters, TrainingMetadata, TrainingMonkeyConfig, TrainingMonkeyIntegration, TrainingMonkeyIntegrationConfig, TrainingPipelineConfig, TrainingQualityScore, TrainingValidationError, TrainingValidationResult, TraitMapping, TraitValidationReport, WeightedAlpacaEntry, buildTrainingPipelineConfig, computeTotalSteps, createGRPOScheduler, createSFTScheduler, createSoftDedup, createSparsityMonitor, createSpatialTrainingDataGenerator, createTrainingMonkeyIntegration, generateValidationReport, getQualityTier, isValidCategory, isValidDifficulty, validateTrainingExample, validateTraitName } from './training/index.js';
+export { EpisodicEvent, EpisodicMemory, MemoryConsolidator, MemoryScorer, ProceduralCompiler, ProceduralSkill, SemanticClusterer, SemanticFact } from './learning/index.js';
+import '@holoscript/core';
+import './AgentManifest-CB4xM-Ma.js';
+import 'events';
+
+/**
+ * GoalSynthesizer — Autonomous goal generation from context
+ *
+ * When a team's board is empty, agents should not idle. This module
+ * synthesizes goals from knowledge store context, recent activity,
+ * and domain expertise using an LLM (when available) or falling back
+ * to heuristic goal generation.
+ *
+ * Absorbed from @holoscript/agent-protocol per FW-0.2.
+ */
+
+interface GoalContext {
+    /** Agent's primary domain (e.g. 'coding', 'research', 'security') */
+    domain: string;
+    /** Recent knowledge entries for context */
+    recentKnowledge?: StoredEntry[];
+    /** Recent completed task titles for dedup */
+    recentCompletedTasks?: string[];
+    /** Team name for context */
+    teamName?: string;
+    /** Agent name for personalization */
+    agentName?: string;
+    /** Agent capabilities */
+    capabilities?: string[];
+    /** Additional context to inject into the LLM prompt */
+    additionalContext?: string;
+}
+interface SynthesizedGoal extends Goal {
+    /** Rationale explaining why this goal was chosen */
+    rationale: string;
+    /** Relevance score 0-1 based on context alignment */
+    relevanceScore: number;
+}
+declare const GENERIC_GOALS: string[];
+declare const DOMAIN_GOALS: Record<string, string[]>;
+declare class GoalSynthesizer {
+    private llmConfig;
+    private knowledgeStore;
+    constructor(opts?: {
+        llm?: ModelConfig;
+        knowledge?: KnowledgeStore;
+    });
+    /**
+     * Synthesize goals from context. Uses LLM when available, falls back to heuristics.
+     * Returns goals ranked by relevance.
+     */
+    synthesizeMultiple(context: GoalContext, count?: number): Promise<SynthesizedGoal[]>;
+    /**
+     * Synthesize a single goal. Backward-compatible with the original API.
+     */
+    synthesize(agentDomain?: string, source?: Goal['source']): Goal;
+    private queryKnowledge;
+    private synthesizeWithLLM;
+    private parseLLMGoals;
+    private synthesizeHeuristic;
+}
+
+/**
+ * defineAgent() — Builder for creating agent configurations.
+ *
+ * Returns a validated AgentConfig that can be passed to defineTeam().
+ */
+
+declare function defineAgent(config: AgentConfig): AgentConfig;
+
+/**
+ * Board Types — Canonical home for all team board data structures.
+ *
+ * Absorbed from mcp-server/src/holomesh/http-routes.ts.
+ * The mcp-server should import these instead of defining inline.
+ */
+type TaskStatus = 'open' | 'claimed' | 'done' | 'blocked';
+type SlotRole = 'coder' | 'tester' | 'researcher' | 'reviewer' | 'flex';
+interface TaskAction {
+    /** What to do when this task completes */
+    type: 'commit' | 'push' | 'deploy' | 'notify' | 'chain' | 'review';
+    /** For 'chain': task ID to unblock. For 'notify': agent name. For 'deploy': service name. */
+    target?: string;
+    /** Human-readable label shown in UI */
+    label?: string;
+}
+interface TeamTask {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    claimedBy?: string;
+    claimedByName?: string;
+    completedBy?: string;
+    commitHash?: string;
+    source?: string;
+    priority: number;
+    role?: SlotRole;
+    createdAt: string;
+    completedAt?: string;
+    /** Task IDs that must complete before this task can be claimed */
+    dependsOn?: string[];
+    /** Task IDs that this task unblocks when completed */
+    unblocks?: string[];
+    /** Actions to execute when this task is marked done */
+    onComplete?: TaskAction[];
+    /** Tags for filtering and categorization */
+    tags?: string[];
+    /** Arbitrary metadata (estimatedHours, repo, branch, etc.) */
+    metadata?: Record<string, unknown>;
+}
+interface DoneLogEntry {
+    taskId: string;
+    title: string;
+    completedBy: string;
+    commitHash?: string;
+    timestamp: string;
+    summary: string;
+}
+type SuggestionCategory = 'process' | 'tooling' | 'architecture' | 'testing' | 'docs' | 'performance' | 'other';
+interface SuggestionVote {
+    agentId: string;
+    agentName: string;
+    value: 1 | -1;
+    reason?: string;
+    votedAt: string;
+}
+interface TeamSuggestion {
+    id: string;
+    title: string;
+    description: string;
+    category: SuggestionCategory;
+    proposedBy: string;
+    proposedByName: string;
+    votes: SuggestionVote[];
+    score: number;
+    status: 'open' | 'promoted' | 'dismissed';
+    promotedTaskId?: string;
+    evidence?: string;
+    createdAt: string;
+    resolvedAt?: string;
+}
+interface RoomPreset {
+    objective: string;
+    taskSources: string[];
+    rules: string[];
+}
+declare const ROOM_PRESETS: Record<string, RoomPreset>;
+type AgentRole = 'architect' | 'coder' | 'researcher' | 'reviewer';
+type AIProvider = 'anthropic' | 'openai' | 'xai';
+interface ClaimFilter {
+    roles: SlotRole[];
+    maxPriority: number;
+}
+interface TeamAgentProfile {
+    id: string;
+    name: string;
+    role: AgentRole;
+    capabilities: string[];
+    model: string;
+    provider: AIProvider;
+    claimFilter: ClaimFilter;
+    systemPrompt: string;
+    knowledgeDomains: string[];
+}
+declare const BRITTNEY_AGENT: TeamAgentProfile;
+declare const DAEMON_AGENT: TeamAgentProfile;
+declare const ABSORB_AGENT: TeamAgentProfile;
+declare const ORACLE_AGENT: TeamAgentProfile;
+declare const TEAM_AGENT_PROFILES: ReadonlyMap<string, TeamAgentProfile>;
+declare function getAllProfiles(): TeamAgentProfile[];
+declare function getProfileById(id: string): TeamAgentProfile | undefined;
+declare function getProfilesByClaimRole(role: SlotRole): TeamAgentProfile[];
+declare function getProfilesByDomain(domain: string): TeamAgentProfile[];
+/** Normalize a title for dedup comparison. */
+declare function normalizeTitle(s: string): string;
+/** Generate a unique task ID. */
+declare function generateTaskId(): string;
+/** Generate a unique suggestion ID. */
+declare function generateSuggestionId(): string;
+/** Infer priority from TODO/FIXME kind and text. */
+declare function inferFixPriority(kind: string, text: string): number;
+/** Parse a derive source (markdown, grep output) into task candidates. */
+declare function parseDeriveContent(content: string, source: string): Array<Omit<TeamTask, 'id' | 'status' | 'createdAt'>>;
+
+/**
+ * Done-Log Audit Logic (FW-0.3)
+ *
+ * Absorbed from mcp-server/src/holomesh/http-routes.ts.
+ * Verifies commit proof, detects duplicates, checks monotonic timestamps,
+ * and provides per-agent/per-source statistics.
+ *
+ * Two APIs:
+ * - `auditDoneLog(entries)` — the original function (unchanged signature)
+ * - `DoneLogAuditor` class — richer audit with stats, violations, and Team integration
+ */
+
+interface AuditResult {
+    total: number;
+    proofRequiredTotal: number;
+    nonProofEntries: number;
+    verified: number;
+    unverified: number;
+    duplicates: number;
+    unverifiedTasks: Array<{
+        taskId: string;
+        title: string;
+        completedBy: string;
+        summary: string;
+        timestamp: string;
+    }>;
+    duplicateTasks: Array<{
+        title: string;
+        count: number;
+    }>;
+    health: {
+        verificationRate: number;
+        message: string;
+    };
+}
+/** A single violation found by the auditor. */
+interface AuditViolation {
+    /** Which check produced this violation. */
+    rule: 'missing-completedBy' | 'missing-summary' | 'missing-commit' | 'duplicate-entry' | 'non-monotonic-timestamp';
+    /** Human-readable description. */
+    message: string;
+    /** The entry that triggered the violation. */
+    entry: DoneLogEntry;
+}
+/** Per-agent completion statistics. */
+interface AgentStats {
+    agent: string;
+    completed: number;
+    verified: number;
+    unverified: number;
+}
+/** Per-source completion statistics. */
+interface SourceStats {
+    source: string;
+    completed: number;
+}
+/** Completion rate bucket for a time period. */
+interface CompletionBucket {
+    /** ISO date string (YYYY-MM-DD). */
+    date: string;
+    completed: number;
+}
+/** Full statistics from DoneLogAuditor.stats(). */
+interface DoneLogStats {
+    total: number;
+    byAgent: AgentStats[];
+    bySource: SourceStats[];
+    completionOverTime: CompletionBucket[];
+}
+/** Combined audit + stats result from DoneLogAuditor. */
+interface FullAuditResult {
+    /** Original AuditResult (backward compatible). */
+    audit: AuditResult;
+    /** Structural violations (missing fields, duplicates, non-monotonic). */
+    violations: AuditViolation[];
+    /** Statistics breakdown. */
+    stats: DoneLogStats;
+}
+/** Check if a done-log entry is a report/session summary (not real task work). */
+declare function isLikelyReportEntry(entry: {
+    title?: string;
+    summary?: string;
+}): boolean;
+/** Check if a commit hash looks like real git proof. */
+declare function isCommitProof(commitHash?: string): boolean;
+/** Audit a done log: verify commits, find duplicates, calculate health. */
+declare function auditDoneLog(doneLog: DoneLogEntry[]): AuditResult;
+/**
+ * Stateless auditor that inspects a done-log for structural violations
+ * and computes aggregate statistics. Designed for Team.audit() integration.
+ */
+declare class DoneLogAuditor {
+    private readonly entries;
+    constructor(entries: DoneLogEntry[]);
+    /**
+     * Run all audit checks and return violations.
+     *
+     * Checks:
+     * 1. Every done task has completedBy, summary, and commit proof
+     * 2. No duplicate entries (by taskId)
+     * 3. Timestamps are monotonically increasing
+     */
+    audit(): AuditViolation[];
+    /** Get aggregate statistics over the done log. */
+    stats(): DoneLogStats;
+    /** Run full audit: original AuditResult + violations + stats. */
+    fullAudit(): FullAuditResult;
+}
+
+/**
+ * Provider-Agnostic LLM Adapter
+ *
+ * Thin wrapper that dispatches to Anthropic, OpenAI, xAI, or OpenRouter.
+ * Each agent can use a different provider/model.
+ */
+
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface LLMResponse {
+    content: string;
+    model: string;
+    provider: string;
+    tokensUsed?: number;
+}
+declare function callLLM(config: ModelConfig, messages: LLMMessage[], options?: {
+    maxTokens?: number;
+    temperature?: number;
+}): Promise<LLMResponse>;
+
+/**
+ * MicroPhaseDecomposer — LLM-powered parallel task decomposition (FW-0.2)
+ *
+ * Takes a complex task description, uses an LLM to break it into independent
+ * micro-phases with dependency edges, then builds a wave-based execution plan
+ * where each wave runs in parallel.
+ *
+ * Two modes:
+ * 1. LLM-powered: `decompose()` calls the LLM to analyze task complexity
+ * 2. Manual: `decomposeManual()` accepts pre-defined phases (for testing / deterministic use)
+ *
+ * Wired into Team: when a task's estimated complexity exceeds a threshold,
+ * the team decomposes it before distributing sub-phases to agents.
+ */
+
+interface TaskDescription {
+    id: string;
+    title: string;
+    description: string;
+    requiredCapabilities?: string[];
+    maxParallelism?: number;
+    complexityThreshold?: number;
+}
+interface MicroPhase {
+    id: string;
+    description: string;
+    dependencies: string[];
+    estimatedDuration: number;
+    requiredCapabilities: string[];
+}
+interface WaveExecutionPlan {
+    waves: MicroPhase[][];
+    totalEstimatedDuration: number;
+    parallelizationRatio: number;
+    phaseCount: number;
+}
+interface DecompositionResult {
+    taskId: string;
+    phases: MicroPhase[];
+    plan: WaveExecutionPlan;
+    wasDecomposed: boolean;
+}
+interface LLMAdapter {
+    call(messages: LLMMessage[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<string>;
+}
+/** Create an LLMAdapter from a ModelConfig */
+declare function createLLMAdapter(config: ModelConfig): LLMAdapter;
+declare class SmartMicroPhaseDecomposer {
+    private llm;
+    constructor(llm: LLMAdapter);
+    /**
+     * Decompose a complex task into parallel micro-phases using LLM analysis.
+     * Returns phases with dependency edges and a wave-based execution plan.
+     */
+    decompose(task: TaskDescription): Promise<DecompositionResult>;
+    /**
+     * Manual decomposition — accepts pre-defined phases. Useful for testing
+     * and deterministic pipelines where LLM analysis isn't needed.
+     */
+    decomposeManual(taskId: string, phases: MicroPhase[]): DecompositionResult;
+    /**
+     * Build an execution plan from phases — topological sort into parallel waves.
+     * Each wave contains phases that can run simultaneously.
+     */
+    buildExecutionPlan(phases: MicroPhase[]): WaveExecutionPlan;
+    private parseLLMResponse;
+    private fallbackSinglePhase;
+    private validatePhases;
+    private topologicalSort;
+    /**
+     * If maxParallelism is set, add synthetic dependencies to limit
+     * the number of phases running concurrently in any wave.
+     */
+    private enforceParallelismLimit;
+}
+
+/**
+ * Mesh Module — Peer discovery, signaling, gossip, and A2A interoperability.
+ *
+ * Canonical home for mesh primitives (previously in @holoscript/agent-sdk,
+ * which has been deleted).
+ */
+interface PeerMetadata {
+    id: string;
+    hostname: string;
+    port: number;
+    version: string;
+    agentCount: number;
+    capabilities: string[];
+    lastSeen: number;
+    latency?: number;
+}
+declare class MeshDiscovery {
+    private peers;
+    private emitter;
+    readonly localId: string;
+    constructor(localId?: string);
+    registerPeer(peer: PeerMetadata): void;
+    removePeer(peerId: string): boolean;
+    getPeers(): PeerMetadata[];
+    getPeer(id: string): PeerMetadata | undefined;
+    getPeerCount(): number;
+    pruneStalePeers(timeoutMs?: number): number;
+    onPeerDiscovered(cb: (peer: PeerMetadata) => void): () => void;
+    onPeerLost(cb: (peer: PeerMetadata) => void): () => void;
+}
+type SignalType = 'did-resolver' | 'mcp-server' | 'storage-node' | 'agent-host' | string;
+interface MeshSignal {
+    type: SignalType;
+    nodeId: string;
+    url: string;
+    capabilities: string[];
+    expiresAt: number;
+}
+declare class SignalService {
+    private localSignals;
+    private remoteSignals;
+    readonly nodeId: string;
+    constructor(nodeId?: string);
+    broadcastSignal(signal: Omit<MeshSignal, 'nodeId' | 'expiresAt'>, ttlMs?: number): MeshSignal;
+    receiveSignal(signal: MeshSignal): void;
+    discoverSignals(type: SignalType): MeshSignal[];
+    getLocalSignals(): MeshSignal[];
+}
+interface GossipPacket {
+    id: string;
+    source: string;
+    version: number;
+    payload: unknown;
+    timestamp: number;
+}
+declare class GossipProtocol {
+    private pool;
+    shareWisdom(sourceId: string, payload: unknown): GossipPacket;
+    antiEntropySync(peerPool: Map<string, GossipPacket>): number;
+    getPool(): Map<string, GossipPacket>;
+    getPoolSize(): number;
+}
+interface MCPToolSchema {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+declare const MCP_TOOL_SCHEMAS: MCPToolSchema[];
+interface AgentCard {
+    name: string;
+    description: string;
+    version: string;
+    url: string;
+    capabilities: AgentCapability[];
+    skills: AgentSkill[];
+    authentication?: AgentAuthentication;
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+}
+interface AgentCapability {
+    id: string;
+    name: string;
+    description: string;
+}
+interface AgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    examples?: string[];
+}
+interface AgentAuthentication {
+    type: 'none' | 'api-key' | 'oauth2' | 'bearer';
+    credentials?: Record<string, string>;
+}
+declare function createAgentCard(config: {
+    name: string;
+    description: string;
+    version: string;
+    url: string;
+    skills: AgentSkill[];
+    capabilities?: AgentCapability[];
+    auth?: AgentAuthentication;
+}): AgentCard;
+declare function validateAgentCard(card: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * Team — The central orchestrator.
+ *
+ * A persistent, knowledge-compounding workspace where agents claim tasks,
+ * execute work, publish knowledge, and get smarter over time.
+ *
+ * Local-first: works entirely in-process. Optional remote board/knowledge.
+ */
+
+declare class Team {
+    readonly name: string;
+    readonly knowledge: KnowledgeStore;
+    private config;
+    private agentConfigs;
+    private runtimes;
+    private board;
+    private doneLog;
+    private cycle;
+    private consensusMode;
+    private proposals;
+    private localSuggestions;
+    private currentMode;
+    private modeObjective;
+    private modeRules;
+    private goalSynthesizer;
+    private decomposer;
+    private presenceRecords;
+    private idleTimeoutMs;
+    private offlineTimeoutMs;
+    readonly mesh: MeshDiscovery;
+    readonly signals: SignalService;
+    readonly gossip: GossipProtocol;
+    readonly bounties: BountyManager;
+    constructor(config: TeamConfig);
+    /** Whether this team is connected to a remote HoloMesh board. */
+    get isRemote(): boolean;
+    /** POST/GET/PATCH to remote board API. Returns null if local-only. */
+    private boardFetch;
+    /** Add tasks to the board. Deduplicates by normalized title. */
+    addTasks(tasks: Array<Omit<TaskDef, 'id' | 'status' | 'createdAt'>>): Promise<TaskDef[]>;
+    /** Get all open tasks, sorted by priority. */
+    get openTasks(): TaskDef[];
+    /** Get all board tasks. */
+    get allTasks(): TaskDef[];
+    /** Get completed task count. */
+    get completedCount(): number;
+    /**
+     * Run one work cycle: each agent checks the board, claims a matching task,
+     * executes it via LLM, publishes knowledge, and compounds insights.
+     */
+    runCycle(): Promise<CycleResult>;
+    /** Remote work cycle: board ops via HoloMesh API, execution local via LLM. */
+    private runRemoteCycle;
+    /** Propose a decision for the team to vote on. */
+    propose<T>(key: string, value: T): Promise<ProposalResult<T>>;
+    /** Get the reputation leaderboard. */
+    leaderboard(): AgentRuntime[];
+    /** Get a specific agent's runtime. */
+    getAgent(name: string): AgentRuntime | undefined;
+    /**
+     * Audit the done log: check for missing fields, duplicates, non-monotonic
+     * timestamps, and return aggregate statistics.
+     *
+     * Works in both local and remote modes. In local mode, the internal doneLog
+     * is converted to DoneLogEntry format. In remote mode, fetches the board
+     * and extracts the done log from the response.
+     */
+    audit(): Promise<FullAuditResult>;
+    /**
+     * Create a suggestion for the team.
+     * Works locally (in-memory) and remotely (delegates to HoloMesh API).
+     */
+    suggest(title: string, opts?: {
+        description?: string;
+        category?: string;
+        evidence?: string;
+        proposedBy?: string;
+        autoPromoteThreshold?: number;
+        autoDismissThreshold?: number;
+    }): Promise<SuggestionCreateResult>;
+    /**
+     * Vote on an existing suggestion.
+     * Local mode: vote(id, agentName, 'up'|'down', reason?).
+     * Remote mode: vote(id, 1|-1, reason?) for backward compatibility.
+     */
+    vote(suggestionId: string, agentNameOrValue: string | 1 | -1, voteOrReason?: 'up' | 'down' | string, reason?: string): Promise<SuggestionVoteResult>;
+    /**
+     * List suggestions, optionally filtered by status.
+     * Works locally (in-memory) and remotely (delegates to HoloMesh API).
+     */
+    suggestions(status?: SuggestionStatus): Promise<SuggestionListResult>;
+    /** Promote a suggestion to a board task manually. Local-only. */
+    promoteSuggestion(suggestionId: string, promoterName?: string): Promise<SuggestionVoteResult>;
+    /** Dismiss a suggestion. Local-only. */
+    dismissSuggestion(suggestionId: string): SuggestionVoteResult;
+    /** Get the current operating mode. */
+    get mode(): TeamMode;
+    /** Get the current mode's objective string. */
+    get objective(): string;
+    /** Get the current mode's rules. */
+    get rules(): string[];
+    /** Switch the team's operating mode. Local-first with optional remote sync. */
+    setMode(mode: TeamMode): Promise<SetModeResult>;
+    /**
+     * Derive tasks from a source document (audit, roadmap, grep output, etc.).
+     * Parses markdown checkboxes, section headers, and TODO/FIXME patterns.
+     * Deduplicates against existing board and done log.
+     * Works locally and remotely.
+     */
+    derive(source: string, content: string): Promise<DeriveResult>;
+    /**
+     * Delegate a task from this team's board to another team's board.
+     * Modifies both boards. Requires connected remote board.
+     */
+    delegate(otherTeamId: string, taskId: string): Promise<boolean>;
+    /**
+     * Record that an agent is alive. Updates lastSeen timestamp.
+     * Works locally on all teams. Optionally pass the task the agent is working on.
+     */
+    localHeartbeat(agentName: string, currentTask?: string): void;
+    /**
+     * Return the presence status of all known agents.
+     * Agents not heartbeating within idleTimeoutMs → 'idle'.
+     * Agents not heartbeating within offlineTimeoutMs → 'offline'.
+     */
+    localPresence(): AgentPresence[];
+    /** Get presence/slot info for the team. Requires remote board. */
+    presence(): Promise<PresenceResult>;
+    /** Send a heartbeat to the team's presence system. Requires remote board. */
+    heartbeat(ideType?: string): Promise<HeartbeatResult>;
+    /**
+     * Get discovered peers with their metadata.
+     * Prunes stale peers (>15s since last seen) before returning.
+     */
+    peers(): PeerMetadata[];
+    /**
+     * Register a peer node for multi-team coordination.
+     */
+    registerPeer(peer: PeerMetadata): void;
+    /**
+     * Broadcast this team's capabilities as a mesh signal.
+     * Other teams can discover this signal via `signals.discoverSignals('agent-host')`.
+     */
+    broadcastCapabilities(url?: string): void;
+    /**
+     * Share a knowledge insight via gossip protocol.
+     * Returns the gossip packet for cross-team anti-entropy sync.
+     */
+    shareKnowledge(payload: unknown): GossipPacket;
+    /**
+     * Sync knowledge from a peer's gossip pool.
+     * Returns the number of new entries absorbed.
+     */
+    syncFromPeer(peerPool: Map<string, GossipPacket>): number;
+    /** On-demand scout: parse TODO/FIXME content into tasks. */
+    scoutFromTodos(grepOutput: string): Promise<TaskDef[]>;
+    /**
+     * Decompose a complex task into parallel micro-phases and distribute
+     * the sub-phases as individual board tasks. Each sub-phase becomes a
+     * separate task that agents can claim independently.
+     *
+     * Returns the decomposition result including the wave-based execution plan.
+     * If no decomposer is available (no LLM configured), falls back to adding
+     * the task as-is.
+     */
+    decomposeAndDistribute(task: TaskDef): Promise<DecompositionResult | null>;
+    /** Get the decomposer instance for direct use (e.g., manual decomposition). */
+    getDecomposer(): SmartMicroPhaseDecomposer | null;
+    listBoard(): Promise<Record<string, unknown>>;
+    claimTask(taskId: string): Promise<Record<string, unknown>>;
+    completeTask(taskId: string, commit?: string, summary?: string): Promise<Record<string, unknown>>;
+    assignSlots(roles: string[]): Promise<Record<string, unknown>>;
+    /** Create a bounty for a board task. */
+    createBounty(taskId: string, reward: BountyReward, createdBy: string, deadline?: number): Bounty;
+    /** Claim a bounty for an agent. */
+    claimBountyForAgent(bountyId: string, agentId: string): ClaimResult$1;
+    /** Complete a bounty with proof. */
+    completeBountyWithProof(bountyId: string, proof: CompletionProof): PayoutResult;
+    /** List bounties, optionally filtered by status. */
+    listBounties(status?: Bounty['status']): Bounty[];
+    /** Convert a synthesized Goal into a TaskDef and add it to the board. */
+    private goalToTask;
+    private findClaimableTask;
+    private executeTask;
+    private getAgentVote;
+}
+
+/**
+ * defineTeam() — Builder for creating a Team instance.
+ *
+ * Validates configuration and returns a ready-to-use Team.
+ */
+
+declare function defineTeam(config: TeamConfig): Team;
+
+/**
+ * Consolidation Engine — Pure state machine for neuroscience-inspired memory consolidation.
+ *
+ * Absorbed from mcp-server/src/holomesh/crdt-sync.ts (V9 consolidation cycle).
+ * Extracts the hot buffer → cold store promotion pipeline as a standalone engine
+ * with no CRDT, HTTP, or persistence dependencies.
+ *
+ * Algorithm (6-phase biological consolidation cycle):
+ *   1. REPLAY     — Filter hot buffer by TTL + corroboration threshold
+ *   1.5 SANITIZE  — Reject entries with injection patterns (defense-in-depth)
+ *   2. CLUSTER    — Find duplicate/overlapping entries by content+type
+ *   3. MERGE      — Combine corroborations from duplicates
+ *   4. DOWNSCALE  — Reduce all cold store excitability (synaptic homeostasis)
+ *   5. PROMOTE    — Move surviving hot entries to cold store with metadata
+ *   6. PRUNE      — Evict lowest-excitability entries when over capacity
+ */
+
+interface ColdStoreEntry {
+    id: string;
+    content: string;
+    type: string;
+    authorDid: string;
+    tags: string[];
+    timestamp: number;
+    accessCount: number;
+    lastAccessed: number;
+    _excitability: ExcitabilityMetadata;
+    _contradictions?: string[];
+    _deprecated?: boolean;
+    _deprecatedAt?: number;
+    _deprecationReason?: string;
+}
+/**
+ * ConsolidationEngine manages hot buffer + cold store per knowledge domain.
+ *
+ * Pure state machine — no HTTP, no CRDT, no persistence.
+ * Feed it entries via `ingest()`, run cycles via `runConsolidationCycle()`,
+ * and read results via `getHotBuffer()` / `getColdStore()`.
+ */
+declare class ConsolidationEngine {
+    private hotBuffers;
+    private coldStores;
+    private lastConsolidation;
+    private reconsolidationWindows;
+    constructor();
+    /**
+     * Ingest knowledge into the hot buffer (hippocampus).
+     * Entries stage here until a consolidation cycle promotes them.
+     */
+    ingest(domain: KnowledgeDomain, entry: {
+        content: string;
+        type: string;
+        authorDid: string;
+        tags: string[];
+    }, sourcePeerDid: string): HotBufferEntry;
+    /**
+     * Corroborate a hot buffer entry (another peer independently confirms it).
+     * Increases promotion likelihood during consolidation.
+     */
+    corroborate(domain: KnowledgeDomain, entryId: string, peerDid: string): boolean;
+    /**
+     * Seed cold store directly (for loading persisted state).
+     */
+    seedColdStore(domain: KnowledgeDomain, entries: ColdStoreEntry[]): void;
+    /**
+     * Run a consolidation (sleep) cycle for a specific domain.
+     *
+     * Implements the 6-phase biological consolidation cycle:
+     * 1. REPLAY   — Filter hot buffer by TTL and corroboration threshold
+     * 1.5 SANITIZE — Reject entries with injection patterns
+     * 2. CLUSTER  — Find duplicate/overlapping entries (content+type match)
+     * 3. MERGE    — Combine corroborations from duplicates
+     * 4. DOWNSCALE — Reduce all cold store excitability (synaptic homeostasis)
+     * 5. PROMOTE  — Move validated entries from hot buffer to cold store
+     * 6. PRUNE    — Evict lowest-excitability entries if over capacity
+     */
+    runConsolidationCycle(domain: KnowledgeDomain): ConsolidationResult;
+    /**
+     * Run consolidation across ALL domains (full sleep cycle).
+     * Only consolidates domains whose sleepFrequency has elapsed.
+     */
+    sleepCycle(force?: boolean): ConsolidationResult[];
+    /**
+     * Check if any domain needs a consolidation cycle.
+     */
+    needsConsolidation(): {
+        domain: KnowledgeDomain;
+        overdue: boolean;
+        bufferSize: number;
+    }[];
+    /**
+     * Retrieve a cold store entry with excitability strengthening.
+     * Every retrieval is a read-modify-write that strengthens the entry
+     * and opens a reconsolidation window for updates.
+     */
+    retrieveWithReconsolidation(domain: KnowledgeDomain, entryId: string): {
+        entry: ColdStoreEntry;
+        reconsolidation: ReconsolidationEvent;
+    } | null;
+    /**
+     * Update an entry during its reconsolidation window.
+     * Returns false if the window is closed or entry not found.
+     */
+    reconsolidateEntry(domain: KnowledgeDomain, entryId: string, updatedContent: string): boolean;
+    /**
+     * Mark an entry as contradicted by a peer.
+     * 3+ contradictions → pruned (microglia-mediated removal).
+     */
+    contradictEntry(domain: KnowledgeDomain, entryId: string, contradictingPeerDid: string): {
+        contradicted: boolean;
+        pruned: boolean;
+    };
+    /**
+     * Deprecate an entry (self-superseding).
+     * Zeroes excitability — will be pruned in next consolidation cycle.
+     */
+    deprecateEntry(domain: KnowledgeDomain, entryId: string, reason: string): boolean;
+    /** Get hot buffer contents for a domain (copy). */
+    getHotBuffer(domain: KnowledgeDomain): HotBufferEntry[];
+    /** Get cold store entries for a domain (copy). */
+    getColdStore(domain: KnowledgeDomain): ColdStoreEntry[];
+    /** Get cold store entry by ID. */
+    getColdStoreEntry(domain: KnowledgeDomain, entryId: string): ColdStoreEntry | undefined;
+    /** Get hot buffer size across all domains. */
+    getHotBufferStats(): {
+        domain: string;
+        count: number;
+    }[];
+    /** Get cold store size across all domains. */
+    getColdStoreStats(): {
+        domain: string;
+        count: number;
+    }[];
+    /** Get consolidation config for a domain. */
+    getDomainConfig(domain: KnowledgeDomain): DomainConsolidationConfig;
+    /**
+     * Surface entries that appear across multiple domains, indicating cross-cutting patterns.
+     * Uses token overlap to find similar entries in different domains.
+     * Returns pairs of entries whose content overlaps above the threshold.
+     */
+    surfaceCrossDomainPatterns(minOverlap?: number): CrossDomainMatch[];
+}
+interface CrossDomainMatch {
+    entryA: {
+        id: string;
+        domain: KnowledgeDomain;
+        content: string;
+    };
+    entryB: {
+        id: string;
+        domain: KnowledgeDomain;
+        content: string;
+    };
+    overlap: number;
+}
+
+/**
+ * Knowledge Consolidator — FW-0.5
+ *
+ * Higher-level orchestrator that adds:
+ * - Tiered sleep/wake consolidation (hot → warm → cold)
+ * - Cross-domain pattern surfacing
+ * - Contradiction detection (content-based, not just peer-flagged)
+ * - Provenance chain tracking
+ *
+ * Builds on KnowledgeStore (local persistence) and ConsolidationEngine (pure state machine).
+ */
+
+type KnowledgeTier = 'hot' | 'warm' | 'cold';
+interface TieredEntry extends StoredEntry {
+    tier: KnowledgeTier;
+    /** Last tier transition timestamp */
+    tierChangedAt: number;
+    /** Full provenance chain (newest first) */
+    provenanceChain: ProvenanceNode[];
+}
+interface ProvenanceNode {
+    /** Entry ID at this point */
+    entryId: string;
+    /** Agent that created or modified */
+    agentId: string;
+    /** Timestamp of action */
+    timestamp: number;
+    /** What happened */
+    action: 'created' | 'promoted' | 'demoted' | 'merged' | 'corrected' | 'cited';
+    /** Optional parent entry (what was this derived from) */
+    parentEntryId?: string;
+    /** Optional hash for integrity verification */
+    hash?: string;
+}
+interface CrossDomainPattern {
+    /** Shared keywords or concepts across domains */
+    pattern: string;
+    /** Domains where the pattern appears */
+    domains: string[];
+    /** Entries contributing to this pattern */
+    entries: Array<{
+        id: string;
+        domain: string;
+        snippet: string;
+    }>;
+    /** Strength: how many entries corroborate */
+    strength: number;
+}
+interface Contradiction {
+    /** First entry */
+    entryA: {
+        id: string;
+        content: string;
+        domain: string;
+    };
+    /** Conflicting entry */
+    entryB: {
+        id: string;
+        content: string;
+        domain: string;
+    };
+    /** Why they conflict */
+    reason: string;
+    /** Confidence that this is a real contradiction (0-1) */
+    confidence: number;
+}
+interface ConsolidationStats {
+    demoted: number;
+    promoted: number;
+    evicted: number;
+    timestamp: number;
+}
+/** Thresholds for tier transitions */
+interface ConsolidatorConfig {
+    /** Entries with no queries in this many ms get demoted hot→warm (default: 6h) */
+    warmDemoteAfterMs: number;
+    /** Entries with no queries in this many ms get demoted warm→cold (default: 48h) */
+    coldDemoteAfterMs: number;
+    /** Max entries in hot tier before forced demotion (default: 100) */
+    hotCapacity: number;
+    /** Max entries in warm tier before forced demotion (default: 500) */
+    warmCapacity: number;
+}
+/**
+ * Orchestrates tiered consolidation, cross-domain surfacing,
+ * contradiction detection, and provenance chain tracking.
+ */
+declare class KnowledgeConsolidator {
+    private tiers;
+    private config;
+    constructor(config?: Partial<ConsolidatorConfig>);
+    /**
+     * Import entries from a KnowledgeStore into the tiered system.
+     * All imported entries start in the hot tier.
+     */
+    importFromStore(store: KnowledgeStore): number;
+    /**
+     * Add a single entry directly.
+     */
+    addEntry(entry: StoredEntry, parentEntryId?: string): TieredEntry;
+    /**
+     * Sleep cycle: demote stale entries down tiers.
+     * hot → warm if no access within warmDemoteAfterMs
+     * warm → cold if no access within coldDemoteAfterMs
+     */
+    sleepCycle(): ConsolidationStats;
+    /**
+     * Wake cycle: promote entries that were recently accessed back up tiers.
+     * cold → warm if accessed since last sleep
+     * warm → hot if access count > 3 since demotion
+     */
+    wakeCycle(): ConsolidationStats;
+    /**
+     * Promote a specific entry to a higher tier.
+     */
+    promote(entryId: string): boolean;
+    /**
+     * Evict an entry from all tiers.
+     */
+    evict(entryId: string): boolean;
+    /**
+     * Find entries that share concepts across multiple domains.
+     * Extracts significant keywords from each entry and groups
+     * entries that share keywords across different domains.
+     */
+    surfaceCrossDomainPatterns(domains?: string[]): CrossDomainPattern[];
+    /**
+     * Detect contradictions between entries.
+     *
+     * Strategy: find entry pairs in the same or related domains where:
+     * 1. They share significant keywords (about the same topic)
+     * 2. One contains negation patterns relative to the other
+     *
+     * This is a heuristic — not an LLM call. False positives are expected
+     * and should be reviewed by agents.
+     */
+    detectContradictions(entries?: StoredEntry[]): Contradiction[];
+    /**
+     * Get the full provenance chain for an entry.
+     * Returns nodes from most recent to oldest.
+     */
+    getProvenanceChain(entryId: string): ProvenanceNode[];
+    /**
+     * Record a citation: entry B cites entry A.
+     */
+    recordCitation(citedEntryId: string, citingAgentId: string): boolean;
+    getByTier(tier: KnowledgeTier): TieredEntry[];
+    getEntry(id: string): TieredEntry | undefined;
+    get size(): number;
+    stats(): {
+        hot: number;
+        warm: number;
+        cold: number;
+        total: number;
+    };
+    all(): TieredEntry[];
+    private appendProvenance;
+}
+
+/**
+ * ProtocolAgent — Concrete BaseAgent backed by LLM calls.
+ *
+ * Wraps the 7-phase uAA2++ lifecycle around a team agent's task execution.
+ * Uses haiku-tier models for lightweight phases (reflect, compress, grow, evolve)
+ * and the agent's configured model for the execute phase.
+ */
+
+/** Result of executing a full protocol cycle on a task. */
+interface ProtocolTaskResult {
+    summary: string;
+    insights: KnowledgeInsight[];
+    phaseResults: PhaseResult[];
+    totalDurationMs: number;
+}
+declare class ProtocolAgent extends BaseAgent {
+    readonly identity: AgentIdentity;
+    private agentConfig;
+    private teamKnowledge;
+    private task;
+    constructor(agentConfig: AgentConfig, teamKnowledge?: string);
+    intake(input: unknown): Promise<PhaseResult>;
+    reflect(data: unknown): Promise<PhaseResult>;
+    execute(plan: unknown): Promise<PhaseResult>;
+    compress(results: unknown): Promise<PhaseResult>;
+    reintake(compressed: unknown): Promise<PhaseResult>;
+    grow(learnings: unknown): Promise<PhaseResult>;
+    evolve(adaptations: unknown): Promise<PhaseResult>;
+}
+/**
+ * Execute a full protocol cycle for a task and extract the structured result.
+ * This is the main entry point used by Team.executeTask.
+ */
+declare function runProtocolCycle(agentConfig: AgentConfig, task: {
+    title: string;
+    description: string;
+}, teamKnowledge: string): Promise<ProtocolTaskResult>;
+/**
+ * Convert a protocol ProtocolCycleResult into the framework's team-oriented CycleResult.
+ */
+declare function protocolToFrameworkCycleResult(protocol: ProtocolCycleResult, teamName: string, cycle: number): CycleResult;
+/**
+ * Convert a framework CycleResult into a protocol ProtocolCycleResult.
+ */
+declare function frameworkToProtocolCycleResult(fw: CycleResult, task: string, domain: string): ProtocolCycleResult;
+/**
+ * Creates a live protocol agent handle backed by LLM calls.
+ *
+ * The returned handle has execute(task), pause/resume/cancel controls,
+ * status tracking, and phase history.
+ *
+ * ```ts
+ * const agent = defineProtocolAgent({
+ *   name: 'researcher',
+ *   role: 'researcher',
+ *   model: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' },
+ *   capabilities: ['search', 'summarize'],
+ *   claimFilter: { roles: ['researcher'], maxPriority: 10 },
+ * });
+ * const result = await agent.execute({ title: 'Find X', description: 'Research X' });
+ * ```
+ */
+declare function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentHandle;
+
+/**
+ * Board Operations — Pure state machine logic for task and suggestion lifecycle.
+ *
+ * Absorbed from mcp-server/src/holomesh/http-routes.ts.
+ * These are pure functions that mutate board/suggestion arrays.
+ * The HTTP layer calls these and handles persistence + responses.
+ */
+
+interface TaskActionResult {
+    success: boolean;
+    error?: string;
+    task?: TeamTask;
+    doneEntry?: DoneLogEntry;
+}
+/** Claim an open task. Returns error if task isn't open or has unmet dependencies. */
+declare function claimTask(board: TeamTask[], taskId: string, claimerId: string, claimerName: string): TaskActionResult;
+/** Mark a task as done. Removes from board, returns done log entry. */
+declare function completeTask(board: TeamTask[], taskId: string, completedBy: string, opts?: {
+    commit?: string;
+    summary?: string;
+}): {
+    result: TaskActionResult & {
+        onComplete?: TaskAction[];
+        unblocked?: string[];
+    };
+    updatedBoard: TeamTask[];
+};
+/** Block a task. */
+declare function blockTask(board: TeamTask[], taskId: string): TaskActionResult;
+/** Reopen a task (unclaim). */
+declare function reopenTask(board: TeamTask[], taskId: string): TaskActionResult;
+/** Delegate a task from a source board to a target board. */
+declare function delegateTask(sourceBoard: TeamTask[], targetBoard: TeamTask[], taskId: string): {
+    result: TaskActionResult;
+    updatedSource: TeamTask[];
+    updatedTarget: TeamTask[];
+};
+/** Add tasks to a board with dedup against existing + done log. */
+declare function addTasksToBoard(board: TeamTask[], doneLog: DoneLogEntry[], tasks: Array<Omit<TeamTask, 'id' | 'status' | 'createdAt'>>): {
+    added: TeamTask[];
+    updatedBoard: TeamTask[];
+};
+interface SuggestionActionResult {
+    success: boolean;
+    error?: string;
+    suggestion?: TeamSuggestion;
+    promotedTask?: TeamTask;
+}
+/** Create a suggestion with dedup against existing open suggestions. */
+declare function createSuggestion(suggestions: TeamSuggestion[], opts: {
+    title: string;
+    description?: string;
+    category?: SuggestionCategory;
+    evidence?: string;
+    proposedBy: string;
+    proposedByName: string;
+}): SuggestionActionResult;
+/** Vote on a suggestion. Auto-promotes at majority, auto-dismisses at negative majority. */
+declare function voteSuggestion(suggestions: TeamSuggestion[], board: TeamTask[], suggestionId: string, voterId: string, voterName: string, value: 1 | -1, maxSlots: number, reason?: string): SuggestionActionResult;
+/** Promote a suggestion manually. Creates a board task. */
+declare function promoteSuggestion(suggestions: TeamSuggestion[], board: TeamTask[], suggestionId: string, promoterName: string, opts?: {
+    priority?: number;
+    role?: SlotRole;
+}): SuggestionActionResult;
+/** Dismiss a suggestion. */
+declare function dismissSuggestion(suggestions: TeamSuggestion[], suggestionId: string): SuggestionActionResult;
+
+/**
+ * DistributedClaimer — Optimistic CAS-based task claiming across machines.
+ *
+ * Uses the MeshDiscovery gossip layer for distributed state.
+ * Conflict resolution: priority + first-writer-wins via monotonic timestamps.
+ *
+ * FW-0.6 — Distributed task claiming across machines.
+ *
+ * @module distributed-claimer
+ */
+
+interface ClaimResult {
+    /** Whether this agent successfully claimed the task */
+    success: boolean;
+    /** The task ID that was claimed */
+    taskId: string;
+    /** The agent that holds the claim (may differ from requester on conflict) */
+    claimedBy: string;
+    /** Monotonic timestamp of the winning claim */
+    claimTimestamp: number;
+    /** If claim was contested, the losing agent IDs */
+    contested?: string[];
+}
+interface ClaimRecord {
+    taskId: string;
+    agentId: string;
+    /** Monotonic timestamp (Date.now + counter to guarantee uniqueness) */
+    timestamp: number;
+    /** Agent priority — lower is higher priority */
+    priority: number;
+    /** Expiry timestamp — claims expire if not confirmed */
+    expiresAt: number;
+}
+interface DistributedClaimerConfig {
+    /** Claim TTL in ms before auto-expiry (default 30_000) */
+    claimTtlMs?: number;
+    /** How often to prune expired claims in ms (default 10_000) */
+    pruneIntervalMs?: number;
+}
+declare class DistributedClaimer {
+    private mesh;
+    private gossip;
+    private claims;
+    private claimTtlMs;
+    private counter;
+    constructor(mesh: MeshDiscovery, gossip: GossipProtocol, config?: DistributedClaimerConfig);
+    /**
+     * Attempt to claim a task using optimistic CAS.
+     *
+     * 1. Check local claim state
+     * 2. If unclaimed, write optimistic claim + broadcast via gossip
+     * 3. If already claimed, compare priority + timestamp (first-writer-wins)
+     */
+    claim(taskId: string, agentId: string, priority?: number): ClaimResult;
+    /**
+     * Release a claim (task completed or abandoned).
+     */
+    release(taskId: string, agentId: string): boolean;
+    /**
+     * Confirm a claim (mark as committed — extends TTL significantly).
+     */
+    confirm(taskId: string, agentId: string): boolean;
+    /**
+     * Get the current claim holder for a task.
+     */
+    getClaimHolder(taskId: string): ClaimRecord | undefined;
+    /**
+     * Get all active claims.
+     */
+    getActiveClaims(): ClaimRecord[];
+    /**
+     * Ingest a gossip packet (called when receiving from peers).
+     */
+    ingestGossip(packet: GossipPacket): void;
+    private broadcastClaim;
+    private pruneExpired;
+}
+
+/**
+ * SkillRouter — Skill-based task routing via agent capabilities.
+ *
+ * Matches task requirements to agent capabilities, scores by overlap,
+ * and returns the best-fit agent. Supports required vs preferred skills.
+ *
+ * FW-0.6 — Skill-based routing via agent capabilities.
+ *
+ * @module skill-router
+ */
+
+interface RoutingResult {
+    /** The selected agent, or null if no match */
+    agent: AgentConfig | null;
+    /** Score of the selected agent (0-100) */
+    score: number;
+    /** All candidates with their scores, sorted descending */
+    candidates: ScoredCandidate[];
+    /** Reason for selection or rejection */
+    reason: string;
+}
+interface ScoredCandidate {
+    agent: AgentConfig;
+    score: number;
+    matchedCapabilities: string[];
+    roleMatch: boolean;
+}
+interface RoutingPolicy {
+    /** Minimum score threshold (0-100) to be eligible (default 10) */
+    minScore?: number;
+    /** Weight for capability matches (default 15) */
+    capabilityWeight?: number;
+    /** Weight for exact role match (default 25) */
+    roleWeight?: number;
+    /** Weight for priority alignment (default 10) */
+    priorityWeight?: number;
+    /** Required capabilities — agent MUST have all of these */
+    requiredCapabilities?: string[];
+}
+declare class SkillRouter {
+    private defaultPolicy;
+    constructor(policy?: RoutingPolicy);
+    /**
+     * Route a task to the best-fit agent.
+     *
+     * Scoring:
+     * - Each capability keyword match in task title/description: +capabilityWeight
+     * - Exact role match (task.role === agent role mapping): +roleWeight
+     * - Priority alignment (agent.claimFilter.maxPriority >= task.priority): +priorityWeight
+     * - Required capabilities must ALL be present or agent is filtered out
+     */
+    route(task: TaskDef, agents: AgentConfig[], policy?: RoutingPolicy): RoutingResult;
+    /**
+     * Route a task to multiple agents (for parallel execution or fallback chains).
+     */
+    routeMultiple(task: TaskDef, agents: AgentConfig[], count: number, policy?: RoutingPolicy): RoutingResult;
+    private agentMatchesRole;
+}
+
+/**
+ * Cross-team Delegation — Send tasks between teams.
+ *
+ * Tracks delegation chains to prevent infinite loops and
+ * enables cross-team collaboration via board forwarding.
+ *
+ * FW-0.6 — Cross-team delegation.
+ *
+ * @module delegation
+ */
+
+interface DelegationResult {
+    /** Whether the delegation was accepted */
+    success: boolean;
+    /** The task that was delegated */
+    taskId: string;
+    /** Source team ID */
+    fromTeam: string;
+    /** Target team ID */
+    toTeam: string;
+    /** The delegation chain (to detect loops) */
+    chain: string[];
+    /** Reason for success or failure */
+    reason: string;
+}
+interface DelegationRecord {
+    /** Original task ID */
+    taskId: string;
+    /** Task title (for display) */
+    taskTitle: string;
+    /** The team that delegated */
+    fromTeam: string;
+    /** The team that received */
+    toTeam: string;
+    /** Full chain of delegations */
+    chain: string[];
+    /** When the delegation happened */
+    timestamp: number;
+    /** Status of the delegated task */
+    status: 'pending' | 'accepted' | 'rejected' | 'completed' | 'bounced';
+    /** Callback URL or team reference for result delivery */
+    callbackRef?: string;
+}
+interface DelegationPolicy {
+    /** Maximum delegation chain length before rejecting (default 5) */
+    maxChainLength?: number;
+    /** Whether to allow delegating back to a team already in the chain (default false) */
+    allowCycles?: boolean;
+    /** Required capabilities the target team must have (optional) */
+    requiredCapabilities?: string[];
+}
+/**
+ * Adapter interface for sending tasks to other teams.
+ * Implementations may use HTTP (remote boards), gossip (mesh), or in-process (local).
+ */
+interface TeamBoardAdapter {
+    /** Send a task to a target team's board */
+    sendTask(targetTeamId: string, task: Pick<TaskDef, 'title' | 'description' | 'priority' | 'role' | 'source'>): Promise<{
+        accepted: boolean;
+        taskId?: string;
+        reason?: string;
+    }>;
+    /** Notify a team about delegation completion */
+    notifyCompletion(teamId: string, delegation: DelegationRecord, result: {
+        summary: string;
+    }): Promise<void>;
+}
+type AddTasksFn = (tasks: Array<Pick<TaskDef, 'title' | 'description' | 'priority' | 'role' | 'source'>>) => Promise<TaskDef[]>;
+declare class InProcessBoardAdapter implements TeamBoardAdapter {
+    private teams;
+    registerTeam(teamId: string, addTasks: AddTasksFn): void;
+    sendTask(targetTeamId: string, task: Pick<TaskDef, 'title' | 'description' | 'priority' | 'role' | 'source'>): Promise<{
+        accepted: boolean;
+        taskId?: string;
+        reason?: string;
+    }>;
+    notifyCompletion(_teamId: string, _delegation: DelegationRecord, _result: {
+        summary: string;
+    }): Promise<void>;
+}
+declare class DelegationManager {
+    private teamId;
+    private adapter;
+    private delegations;
+    private policy;
+    constructor(teamId: string, adapter: TeamBoardAdapter, policy?: DelegationPolicy);
+    /**
+     * Delegate a task to another team.
+     *
+     * 1. Validate delegation chain (no cycles, max length)
+     * 2. Forward task to target team's board via adapter
+     * 3. Track delegation record
+     */
+    delegate(task: TaskDef, targetTeamId: string, existingChain?: string[]): Promise<DelegationResult>;
+    /**
+     * Mark a delegation as completed.
+     */
+    completeDelegation(taskId: string, targetTeamId: string, summary: string): Promise<boolean>;
+    /**
+     * Get all delegations from this team.
+     */
+    getOutboundDelegations(): DelegationRecord[];
+    /**
+     * Get pending delegations.
+     */
+    getPendingDelegations(): DelegationRecord[];
+}
+
+/**
+ * Absorb Scanner — Framework scans its own codebase for improvements.
+ *
+ * Queries the MCP Orchestrator knowledge store for framework-related
+ * insights, and scans local source files for TODO/FIXME markers.
+ *
+ * Does NOT depend on the absorb service being up — the orchestrator's
+ * knowledge store is the source of truth (always available).
+ */
+interface AbsorbScanConfig {
+    /** MCP Orchestrator URL (default: production) */
+    orchestratorUrl?: string;
+    /** MCP API key for orchestrator auth */
+    mcpApiKey?: string;
+    /** Workspace ID for knowledge queries (default: ai-ecosystem) */
+    workspaceId?: string;
+    /** Max improvement tasks to generate */
+    maxTasks?: number;
+    /** Search query for knowledge store */
+    searchQuery?: string;
+}
+interface ScanResult {
+    scanned: boolean;
+    filesAnalyzed: number;
+    issuesFound: number;
+    improvements: ImprovementTask[];
+    knowledge: ExtractedKnowledge[];
+    error?: string;
+}
+interface ImprovementTask {
+    title: string;
+    description: string;
+    priority: number;
+    category: 'refactor' | 'test' | 'docs' | 'performance' | 'type-safety';
+    file?: string;
+    line?: number;
+}
+interface ExtractedKnowledge {
+    type: 'wisdom' | 'pattern' | 'gotcha';
+    content: string;
+    domain: string;
+    confidence: number;
+}
+/**
+ * Scan the framework via the MCP Orchestrator knowledge store.
+ * Returns improvement tasks + extracted knowledge.
+ * Falls back gracefully if the orchestrator is unreachable.
+ */
+declare function scanFramework(config?: AbsorbScanConfig): Promise<ScanResult>;
+/**
+ * Scan local source files for TODO/FIXME/HACK markers.
+ * Returns improvement tasks derived from code comments.
+ */
+declare function scanTodos(codebasePath: string): Promise<ScanResult>;
+
+/**
+ * Evolution Engine — The framework improves itself.
+ *
+ * The pipeline:
+ * 1. SCAN: Query orchestrator knowledge store + scan local TODOs
+ * 2. PROPOSE: Convert findings to improvement suggestions
+ * 3. VOTE: Team agents vote on which improvements matter
+ * 4. EXECUTE: Winning suggestions become board tasks
+ * 5. COMPOUND: Knowledge from execution feeds back into the store
+ *
+ * This is the v1.0 singularity point — the framework's own agents
+ * can propose, vote on, and ship improvements to themselves.
+ */
+
+interface EvolutionConfig {
+    /** Absorb scan configuration */
+    absorb?: AbsorbScanConfig;
+    /** Path to scan for TODOs (default: none — skip TODO scan) */
+    codebasePath?: string;
+    /** Auto-propose improvements as suggestions (default: true) */
+    autoPropose?: boolean;
+    /** Auto-add high-priority improvements to board (default: false) */
+    autoBoard?: boolean;
+    /** Minimum priority to auto-board (1=critical, default: 2) */
+    autoBoardMinPriority?: number;
+}
+interface EvolutionResult {
+    scan: ScanResult;
+    todoScan?: ScanResult;
+    suggestionsCreated: number;
+    tasksCreated: number;
+    knowledgePublished: number;
+}
+/**
+ * Run one evolution cycle on a team.
+ *
+ * Scans the orchestrator knowledge store and local TODOs,
+ * proposes improvements as suggestions, publishes extracted knowledge,
+ * and optionally adds high-priority items directly to the board.
+ */
+declare function evolve(team: Team, config?: EvolutionConfig): Promise<EvolutionResult>;
+
+/**
+ * FrameworkAbsorber — Class-based absorb integration for framework self-scanning.
+ *
+ * @experimental
+ *
+ * Wraps the absorb service (https://absorb.holoscript.net) to scan the
+ * framework codebase, query for code health, and surface improvements.
+ * Falls back to the MCP Orchestrator knowledge store when the absorb
+ * service is unreachable.
+ */
+
+interface CodebaseGraph {
+    /** Number of files in the graph */
+    fileCount: number;
+    /** Number of edges (dependencies) between files */
+    edgeCount: number;
+    /** Top-level modules detected */
+    modules: string[];
+    /** Raw graph data from absorb (opaque — shape depends on service version) */
+    raw?: unknown;
+}
+interface Improvement {
+    id: string;
+    title: string;
+    description: string;
+    priority: number;
+    category: ImprovementTask['category'];
+    file?: string;
+    line?: number;
+    /** Confidence score from absorb analysis (0-1) */
+    confidence: number;
+}
+interface AbsorberConfig extends AbsorbScanConfig {
+    /** Absorb service URL (default: production) */
+    absorbUrl?: string;
+    /** Absorb API key (default: ABSORB_API_KEY env var) */
+    absorbApiKey?: string;
+    /** Path to scan for local TODOs */
+    codebasePath?: string;
+}
+/**
+ * FrameworkAbsorber — scans the framework codebase for improvements.
+ *
+ * @experimental
+ *
+ * Usage:
+ * ```ts
+ * const absorber = new FrameworkAbsorber({ codebasePath: 'packages/framework' });
+ * const graph = await absorber.scanSelf();
+ * const improvements = await absorber.findImprovements();
+ * ```
+ */
+declare class FrameworkAbsorber {
+    private readonly config;
+    private lastScan;
+    constructor(config?: AbsorberConfig);
+    /**
+     * Scan the framework codebase via the absorb service.
+     * Returns a CodebaseGraph with module/dependency info.
+     *
+     * Calls absorb_run_absorb MCP tool via JSON-RPC for full graph analysis.
+     * Falls back to knowledge store scan if the absorb service is unreachable.
+     */
+    scanSelf(): Promise<CodebaseGraph>;
+    /**
+     * Find improvements by scanning knowledge store + local TODOs.
+     * Returns ranked improvement list with confidence scores.
+     */
+    findImprovements(): Promise<Improvement[]>;
+    /**
+     * Get extracted knowledge from the last scan.
+     */
+    getKnowledge(): ExtractedKnowledge[];
+    /**
+     * Run a full scan (knowledge store + local TODOs).
+     */
+    private runFullScan;
+}
+
+/**
+ * TestGenerator — Auto-generate tests for framework source files.
+ *
+ * @experimental
+ *
+ * Uses the LLM adapter to generate vitest test files from source code.
+ * Part of FW-1.0 self-evolution: the framework writes its own tests.
+ */
+
+interface TestGeneratorConfig {
+    /** LLM model configuration */
+    model: ModelConfig;
+    /** Maximum tokens for test generation */
+    maxTokens?: number;
+    /** Temperature (lower = more deterministic tests) */
+    temperature?: number;
+    /** Test framework (default: vitest) */
+    testFramework?: 'vitest' | 'jest';
+    /** Additional context to include in the prompt */
+    additionalContext?: string;
+}
+interface GeneratedTest {
+    /** Source file path */
+    sourceFile: string;
+    /** Generated test file content */
+    testContent: string;
+    /** Suggested test file path */
+    testFilePath: string;
+    /** Number of test cases generated */
+    testCount: number;
+    /** LLM tokens used */
+    tokensUsed: number;
+}
+/**
+ * TestGenerator — generates test files from source code via LLM.
+ *
+ * @experimental
+ *
+ * Usage:
+ * ```ts
+ * const gen = new TestGenerator({ model: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' } });
+ * const result = await gen.generateTests('src/self-improve/absorb-scanner.ts');
+ * ```
+ */
+declare class TestGenerator {
+    private readonly config;
+    constructor(config: TestGeneratorConfig);
+    /**
+     * Generate a test file for the given source file.
+     *
+     * @param filePath - Path to the TypeScript source file
+     * @returns Generated test content and metadata
+     */
+    generateTests(filePath: string): Promise<GeneratedTest>;
+    /**
+     * Generate tests for multiple files.
+     *
+     * @param filePaths - Array of source file paths
+     * @returns Array of generated tests
+     */
+    generateBatch(filePaths: string[]): Promise<GeneratedTest[]>;
+}
+
+/**
+ * PromptOptimizer — A/B test prompts to find the most effective phrasing.
+ *
+ * @experimental
+ *
+ * Part of FW-1.0 self-evolution: the framework optimizes its own prompts
+ * by running controlled experiments and measuring quality metrics.
+ */
+
+interface ABTestConfig {
+    /** LLM model configuration for running the test */
+    model: ModelConfig;
+    /** Number of runs per prompt variant (default: 3) */
+    runs?: number;
+    /** Evaluation criteria (default: quality + relevance) */
+    criteria?: EvaluationCriteria[];
+    /** Maximum tokens per response */
+    maxTokens?: number;
+    /** Temperature for test runs */
+    temperature?: number;
+}
+interface EvaluationCriteria {
+    name: string;
+    description: string;
+    weight: number;
+}
+interface PromptVariantResult {
+    prompt: string;
+    responses: string[];
+    avgScore: number;
+    scores: number[];
+    avgTokens: number;
+    avgLatencyMs: number;
+}
+interface ABTestResult {
+    /** The task/question both prompts were tested against */
+    task: string;
+    /** Results for prompt A */
+    variantA: PromptVariantResult;
+    /** Results for prompt B */
+    variantB: PromptVariantResult;
+    /** Which variant won ('A' | 'B' | 'tie') */
+    winner: 'A' | 'B' | 'tie';
+    /** Confidence in the result (0-1, based on score delta and consistency) */
+    confidence: number;
+    /** Total tokens consumed across all runs */
+    totalTokens: number;
+}
+/**
+ * PromptOptimizer — A/B tests prompt variants to find the best one.
+ *
+ * @experimental
+ *
+ * Usage:
+ * ```ts
+ * const optimizer = new PromptOptimizer({
+ *   model: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }
+ * });
+ * const result = await optimizer.abTest(
+ *   'Explain HoloScript in one paragraph.',
+ *   'You are a HoloScript expert. Explain HoloScript concisely.',
+ *   'What is HoloScript?'
+ * );
+ * console.log(`Winner: ${result.winner} (confidence: ${result.confidence})`);
+ * ```
+ */
+declare class PromptOptimizer {
+    private readonly config;
+    constructor(config: ABTestConfig);
+    /**
+     * Run an A/B test comparing two prompt variants on a given task.
+     */
+    abTest(promptA: string, promptB: string, task: string): Promise<ABTestResult>;
+    /**
+     * Run a single variant N times and evaluate.
+     */
+    private runVariant;
+    /**
+     * Judge a response using the LLM as evaluator.
+     * Returns a weighted score (0-10).
+     */
+    private judge;
+    /**
+     * Compute variance of a number array.
+     */
+    private variance;
+}
+
+export { ABSORB_AGENT, type ABTestConfig, type ABTestResult, type AIProvider, type AbsorbScanConfig, type AbsorberConfig, type AgentAuthentication, type AgentCapability, type AgentCard, AgentConfig, AgentIdentity, AgentPresence, AgentRuntime, type AgentSkill, type AgentStats, type AuditResult, type AuditViolation, BRITTNEY_AGENT, BaseAgent, Bounty, BountyManager, BountyReward, type ClaimRecord, ClaimResult$1 as ClaimResult, type CodebaseGraph, type ColdStoreEntry, type CompletionBucket, CompletionProof, ConsolidationEngine, ConsolidationResult, type ConsolidationStats, type ConsolidatorConfig, type Contradiction, type CrossDomainMatch, type CrossDomainPattern, CycleResult, DAEMON_AGENT, DOMAIN_GOALS, type DecompositionResult, DelegationManager, type DelegationPolicy, type DelegationRecord, type DelegationResult, DeriveResult, type ClaimResult as DistributedClaimResult, DistributedClaimer, type DistributedClaimerConfig, DomainConsolidationConfig, DoneLogAuditor, type DoneLogEntry, type DoneLogStats, type EvaluationCriteria, type EvolutionConfig, type EvolutionResult, ExcitabilityMetadata, type ExtractedKnowledge, FrameworkAbsorber, type FullAuditResult, GENERIC_GOALS, type GeneratedTest, Goal, type GoalContext, GoalSynthesizer, type GossipPacket, GossipProtocol, HeartbeatResult, HotBufferEntry, type Improvement, type ImprovementTask, InProcessBoardAdapter, KnowledgeConsolidator, KnowledgeDomain, KnowledgeInsight, KnowledgeStore, type KnowledgeTier, type LLMAdapter, type LLMMessage, type LLMResponse, type MCPToolSchema, MCP_TOOL_SCHEMAS, MeshDiscovery, type MeshSignal, type MicroPhase, ModelConfig, ORACLE_AGENT, PayoutResult, type PeerMetadata, PhaseResult, PresenceResult, PromptOptimizer, type PromptVariantResult, ProposalResult, ProtocolAgent, ProtocolAgentConfig, ProtocolAgentHandle, ProtocolCycleResult, type ProtocolTaskResult, type ProvenanceNode, ROOM_PRESETS, ReconsolidationEvent, type RoomPreset, type RoutingPolicy, type RoutingResult, type ScanResult, type ScoredCandidate, SetModeResult, SignalService, type SignalType, SkillRouter, SmartMicroPhaseDecomposer, type SourceStats, StoredEntry, type SuggestionActionResult, type SuggestionCategory, SuggestionCreateResult, SuggestionListResult, SuggestionStatus, type SuggestionVote, SuggestionVoteResult, type SynthesizedGoal, TEAM_AGENT_PROFILES, type TaskActionResult, TaskDef, type TaskDescription, type TaskStatus, Team, type TeamAgentProfile, type TeamBoardAdapter, TeamConfig, TeamMode, type TeamSuggestion, type TeamTask, TestGenerator, type TestGeneratorConfig, type TieredEntry, type WaveExecutionPlan, addTasksToBoard, auditDoneLog, blockTask, callLLM, claimTask, completeTask, createAgentCard, createLLMAdapter, createSuggestion, defineAgent, defineProtocolAgent, defineTeam, delegateTask, dismissSuggestion, evolve, frameworkToProtocolCycleResult, generateSuggestionId, generateTaskId, getAllProfiles, getProfileById, getProfilesByClaimRole, getProfilesByDomain, inferFixPriority, isCommitProof, isLikelyReportEntry, normalizeTitle, parseDeriveContent, promoteSuggestion, protocolToFrameworkCycleResult, reopenTask, runProtocolCycle, scanFramework, scanTodos, validateAgentCard, voteSuggestion };