network-ai 5.10.1 → 5.11.0

package/dist/esm/index.js

@@ -0,0 +1,1352 @@
+"use strict";
+/**
+ * SwarmOrchestrator - Multi-Agent Orchestration Framework for TypeScript/Node.js
+ *
+ * Connects 12 AI frameworks (LangChain, AutoGen, CrewAI, OpenAI Assistants, LlamaIndex,
+ * Semantic Kernel, Haystack, DSPy, Agno, MCP, OpenClaw) via a shared atomic blackboard,
+ * FSM governance, per-agent token budget enforcement, and HMAC audit trails.
+ * OpenClaw skill interface is implemented for backward compatibility.
+ *
+ * @module SwarmOrchestrator
+ * @version 4.0.17
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJsonSchema = exports.QualityGateAgent = exports.BlackboardValidator = exports.NoOpAuthValidator = exports.ComparisonRunner = exports.CoverageReporter = exports.AgentVCR = exports.compileGoal = exports.validateGoal = exports.goalFromObject = exports.parseGoal = exports.MockAgentRegistry = exports.startPlayground = exports.FileJobStore = exports.JobQueue = exports.SwarmTransportClient = exports.SwarmTransportServer = exports.createAdapterTestSuite = exports.ApprovalInbox = exports.LandscapeAgent = exports.TransportAgent = exports.AgentDebate = exports.SpeculativeExecutor = exports.LearningLoop = exports.SharedLongTermMemory = exports.ProceduralMemory = exports.EpisodicMemory = exports.AgentMemory = exports.OrchestratorLifecycleHooks = exports.ConfigWatcher = exports.DryRunSimulator = exports.LookupCostModel = exports.CostGovernor = exports.AnomalyDetector = exports.TimelineScrubber = exports.CostHeatmap = exports.createOrchestratorMetrics = exports.Histogram = exports.Gauge = exports.Counter = exports.MetricsRegistry = exports.SpanStatus = exports.OTelBridge = exports.AgentConversationLog = exports.OrchestratorEventBus = exports.ExplainabilityTracer = exports.TaskDecomposer = exports.AuthGuardian = exports.SharedBlackboard = exports.SwarmOrchestrator = void 0;
+exports.ComplianceMonitor = exports.WORKFLOW_STATES = exports.createDeliveryPipelineFSM = exports.ComplianceViolationError = exports.ComplianceMiddleware = exports.ToolAuthorizationMatrix = exports.JourneyFSM = exports.mapErrorToSkillResult = exports.TimeoutError = exports.ParallelLimitError = exports.AdapterNotInitializedError = exports.AdapterNotFoundError = exports.AdapterAlreadyRegisteredError = exports.ConflictError = exports.LockAcquisitionError = exports.ValidationError = exports.NamespaceViolationError = exports.IdentityVerificationError = exports.NetworkAIError = exports.LogLevel = exports.Logger = exports.McpInProcessTransport = exports.McpBridgeRouter = exports.McpBridgeClient = exports.McpBlackboardBridge = exports.FederatedBudget = exports.isFlushable = exports.ConsistentBackend = exports.mergeEntry = exports.compareClock = exports.isConcurrent = exports.happensBefore = exports.mergeClock = exports.tickClock = exports.CrdtBackend = exports.RedisBackend = exports.MemoryBackend = exports.FileBackend = exports.LockedBlackboard = exports.HttpClientTransport = exports.StdioClientTransport = exports.MCPToolConsumer = exports.CustomAdapter = exports.MCPAdapter = exports.CrewAIAdapter = exports.AutoGenAdapter = exports.LangChainAdapter = exports.OpenClawAdapter = exports.BaseAdapter = exports.AdapterRegistry = void 0;
+exports.EnvironmentManager = exports.ControlPlane = exports.WorkTreeDashboard = exports.WorkTreeUI = exports.WorkTree = exports.DashboardServer = exports.TopologyTracker = exports.createLLMClassifier = exports.createHeuristicClassifier = exports.RouteClassifier = exports.createLLMEvaluator = exports.createKeywordEvaluator = exports.CoverageGate = exports.parsePartitionJSON = exports.createLLMPartitionPlanner = exports.createLexicalOverlapChecker = exports.PartitionPlanner = exports.filterState = exports.ContextThrottler = exports.parsePlanJSON = exports.topologicalLayers = exports.validateDAG = exports.createLLMPlanner = exports.runTeam = exports.TeamRunner = exports.GoalDecomposer = exports.adaptiveStrategy = exports.StrategyAgent = exports.WorkloadPartitioner = exports.AgentPool = exports.ansi = exports.ConsoleUI = exports.RuntimeExecutionError = exports.RuntimeApprovalError = exports.RuntimePolicyError = exports.AgentRuntime = exports.ApprovalGate = exports.FileAccessor = exports.ShellExecutor = exports.SandboxPolicy = exports.FanOutFanIn = exports.ConfidenceFilter = exports.PhasePipeline = exports.SemanticMemory = exports.SkillComposer = exports.matchToolPattern = exports.matchGlob = exports.AdapterHookManager = exports.QAOrchestratorAgent = exports.ClaimVerifier = void 0;
+exports.createOtelHooks = exports.CapturingTelemetryProvider = exports.NullTelemetryProvider = exports.CircuitOpenError = exports.CircuitBreaker = exports.OrchestratorAdapter = exports.BrowserAgentAdapter = exports.PydanticAIAdapter = exports.VertexAIAdapter = exports.OpenAIAgentsAdapter = exports.AnthropicComputerUseAdapter = exports.LangGraphAdapter = exports.CopilotAdapter = exports.NemoClawAdapter = exports.MiniMaxAdapter = exports.CodexAdapter = exports.A2AAdapter = exports.CustomStreamingAdapter = exports.LangChainStreamingAdapter = exports.collectStream = exports.StreamingBaseAdapter = exports.ControlMcpTools = exports.ExtendedMcpTools = exports.OrchestrationPromptProvider = exports.BlackboardResourceProvider = exports.McpStreamableServer = exports.McpBlackboardBridgeAdapter = exports.McpCombinedBridge = exports.McpSseTransport = exports.McpSseServer = exports.BLACKBOARD_TOOL_DEFINITIONS = exports.registerBlackboardTools = exports.BlackboardMCPTools = exports.QuadTree = exports.SourceProtectionError = void 0;
+exports.createSwarmOrchestrator = createSwarmOrchestrator;
+exports.getConfig = getConfig;
+exports.setConfig = setConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const adapter_registry_1 = require("./adapters/adapter-registry");
+const security_1 = require("./security");
+const blackboard_backend_1 = require("./lib/blackboard-backend");
+const consistency_1 = require("./lib/consistency");
+const blackboard_validator_1 = require("./lib/blackboard-validator");
+const logger_1 = require("./lib/logger");
+const errors_1 = require("./lib/errors");
+// Extracted modules (Phase 1.1 — split god-file)
+const shared_blackboard_1 = require("./lib/shared-blackboard");
+const auth_guardian_1 = require("./lib/auth-guardian");
+const explainability_1 = require("./lib/explainability");
+const event_bus_1 = require("./lib/event-bus");
+const agent_conversation_1 = require("./lib/agent-conversation");
+const otel_bridge_1 = require("./lib/otel-bridge");
+const metrics_1 = require("./lib/metrics");
+const cost_heatmap_1 = require("./lib/cost-heatmap");
+const anomaly_detector_1 = require("./lib/anomaly-detector");
+const lifecycle_hooks_1 = require("./lib/lifecycle-hooks");
+const task_decomposer_1 = require("./lib/task-decomposer");
+const orchestrator_types_1 = require("./lib/orchestrator-types");
+const log = logger_1.Logger.create('SwarmOrchestrator');
+// Types, interfaces, CONFIG, and default profiles are now in ./lib/orchestrator-types.ts
+// SharedBlackboard is now in ./lib/shared-blackboard.ts
+// AuthGuardian is now in ./lib/auth-guardian.ts
+// TaskDecomposer is now in ./lib/task-decomposer.ts
+// ============================================================================
+// SWARM ORCHESTRATOR - MAIN SKILL IMPLEMENTATION
+// ============================================================================
+/**
+ * The main orchestrator class — coordinates agents, permissions, blackboard,
+ * quality gates, and adapter routing in a single entry point.
+ *
+ * Implements the OpenClaw skill interface for backward compatibility and
+ * can also be used standalone via {@link createSwarmOrchestrator}.
+ *
+ * @example
+ * ```typescript
+ * import { createSwarmOrchestrator, LangChainAdapter } from 'network-ai';
+ *
+ * const orchestrator = createSwarmOrchestrator({
+ *   adapters: [{ adapter: new LangChainAdapter() }],
+ *   trustLevels: [{ agentId: 'my-agent', trustLevel: 0.8 }],
+ * });
+ *
+ * const result = await orchestrator.execute('delegate_task', {
+ *   targetAgent: 'my-agent',
+ *   taskPayload: { instruction: 'Summarize the quarterly report' },
+ * }, { agentId: 'orchestrator' });
+ * ```
+ */
+class SwarmOrchestrator {
+    name = 'SwarmOrchestrator';
+    version = '3.1.0';
+    blackboard;
+    authGuardian;
+    taskDecomposer;
+    agentRegistry = new Map();
+    gateway;
+    qualityGate;
+    injectionShield;
+    tracer;
+    eventBus;
+    conversationLog;
+    otel;
+    metrics;
+    heatmap;
+    anomalyDetector;
+    lifecycleHooks;
+    /** Named isolated blackboards, keyed by board name */
+    namedBlackboards = new Map();
+    /** Root workspace path -- used as the parent for named board subdirectories */
+    _workspacePath;
+    /** The adapter registry -- routes requests to the right agent framework */
+    adapters;
+    constructor(workspacePath = process.cwd(), adapterRegistry, options) {
+        if (workspacePath !== undefined && typeof workspacePath !== 'string') {
+            throw new errors_1.ValidationError('workspacePath must be a string');
+        }
+        if (workspacePath !== undefined && workspacePath.trim() === '') {
+            throw new errors_1.ValidationError('workspacePath must not be empty');
+        }
+        this._workspacePath = workspacePath;
+        this.blackboard = new shared_blackboard_1.SharedBlackboard(workspacePath);
+        this.authGuardian = new auth_guardian_1.AuthGuardian({
+            trustLevels: options?.trustLevels,
+            resourceProfiles: options?.resourceProfiles,
+        });
+        this.adapters = adapterRegistry ?? new adapter_registry_1.AdapterRegistry();
+        this.taskDecomposer = new task_decomposer_1.TaskDecomposer(this.blackboard, this.authGuardian, this.adapters);
+        this.gateway = new security_1.SecureSwarmGateway();
+        this.qualityGate = new blackboard_validator_1.QualityGateAgent({
+            validationConfig: options?.validationConfig,
+            qualityThreshold: options?.qualityThreshold,
+            aiReviewCallback: options?.aiReviewCallback,
+        });
+        this.injectionShield = new security_1.PromptInjectionShield();
+        this.tracer = new explainability_1.ExplainabilityTracer();
+        this.eventBus = new event_bus_1.OrchestratorEventBus({ snapshotInterval: 100 });
+        this.conversationLog = new agent_conversation_1.AgentConversationLog();
+        this.otel = new otel_bridge_1.OTelBridge();
+        this.metrics = (0, metrics_1.createOrchestratorMetrics)();
+        this.heatmap = new cost_heatmap_1.CostHeatmap();
+        this.anomalyDetector = new anomaly_detector_1.AnomalyDetector();
+        this.lifecycleHooks = new lifecycle_hooks_1.OrchestratorLifecycleHooks();
+        // Register the orchestrator agent on the blackboard with full access
+        this.blackboard.registerAgent('orchestrator', 'system-orchestrator-token', ['*']);
+    }
+    /**
+     * Add an agent framework adapter (LangChain, AutoGen, CrewAI, MCP, custom, etc.)
+     * This is the plug-and-play entry point.
+     */
+    async addAdapter(adapter, config = {}) {
+        if (!adapter || typeof adapter !== 'object') {
+            throw new errors_1.ValidationError('adapter is required and must be an object');
+        }
+        if (typeof adapter.name !== 'string' || adapter.name.trim() === '') {
+            throw new errors_1.ValidationError('adapter.name must be a non-empty string');
+        }
+        await this.adapters.addAdapter(adapter, config);
+    }
+    /**
+     * Main entry point for the skill.
+     * Now integrates SecureSwarmGateway: every request flows through
+     * input sanitization, rate limiting, and agent ID validation.
+     */
+    async execute(action, params, context) {
+        if (!action || typeof action !== 'string') {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'action is required and must be a non-empty string',
+                    recoverable: false,
+                },
+            };
+        }
+        if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'params is required and must be a plain object',
+                    recoverable: false,
+                },
+            };
+        }
+        if (!context || typeof context !== 'object' || !context.agentId || typeof context.agentId !== 'string') {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'context is required and must include a non-empty agentId string',
+                    recoverable: false,
+                },
+            };
+        }
+        const traceId = (0, crypto_1.randomUUID)();
+        // P0: Route through SecureSwarmGateway -- sanitization + rate limiting
+        const gatewayResult = await this.gateway.handleSecureRequest(context.agentId, action, params);
+        if (!gatewayResult.allowed) {
+            return {
+                success: false,
+                error: {
+                    code: 'GATEWAY_DENIED',
+                    message: `Security gateway denied request: ${gatewayResult.reason}`,
+                    recoverable: true,
+                    suggestedAction: 'Check agent ID, rate limits, or input format',
+                },
+            };
+        }
+        // Use sanitized params from gateway
+        const safeParams = gatewayResult.sanitizedParams ?? params;
+        if (orchestrator_types_1.CONFIG.enableTracing) {
+            try {
+                this.blackboard.write(`trace:${traceId}`, {
+                    action,
+                    startTime: new Date().toISOString(),
+                }, context.agentId, undefined, 'system-orchestrator-token');
+            }
+            catch {
+                // Non-fatal -- tracing failure shouldn't block execution
+            }
+        }
+        try {
+            switch (action) {
+                case 'delegate_task':
+                    return await this.delegateTask(safeParams, context);
+                case 'query_swarm_state':
+                    return await this.querySwarmState(safeParams, context);
+                case 'spawn_parallel_agents':
+                    return await this.spawnParallelAgents(safeParams, context);
+                case 'request_permission':
+                    return await this.handlePermissionRequest(safeParams, context);
+                case 'update_blackboard':
+                    return await this.handleBlackboardUpdate(safeParams, context);
+                case 'quality_gate_status':
+                    return this.handleQualityGateStatus();
+                case 'review_quarantine':
+                    return this.handleQuarantineReview(safeParams);
+                default:
+                    return {
+                        success: false,
+                        error: {
+                            code: 'UNKNOWN_ACTION',
+                            message: `Unknown action: ${action}`,
+                            recoverable: false,
+                        },
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    recoverable: true,
+                    trace: { traceId, action },
+                },
+            };
+        }
+    }
+    // -------------------------------------------------------------------------
+    // CAPABILITY: delegate_task
+    // -------------------------------------------------------------------------
+    async delegateTask(params, context) {
+        const targetAgent = params.targetAgent;
+        const taskPayload = params.taskPayload;
+        const priority = params.priority ?? 'normal';
+        const timeout = params.timeout ?? orchestrator_types_1.CONFIG.defaultTimeout;
+        const requiresAuth = params.requiresAuth ?? false;
+        const resourceType = params.resourceType ?? 'EXTERNAL_SERVICE';
+        const delegationTraceId = this.tracer.record({
+            source: 'SwarmOrchestrator',
+            decision: 'delegation_start',
+            outcome: 'initiated',
+            agentId: context.agentId,
+            factors: [
+                { name: 'targetAgent', value: targetAgent },
+                { name: 'priority', value: priority },
+                { name: 'requiresAuth', value: requiresAuth },
+                { name: 'timeout', value: timeout },
+            ],
+        });
+        this.eventBus.publish('orchestrator', 'delegation_start', 'info', {
+            targetAgent, priority, requiresAuth, timeout, traceId: delegationTraceId,
+        }, context.agentId, delegationTraceId);
+        this.metrics.delegationsTotal.inc({ agent: targetAgent });
+        const delegationStartMs = Date.now();
+        // Orchestrator-level beforeSpawn hook
+        const spawnCtx = await this.lifecycleHooks.runBeforeSpawn({
+            agentId: targetAgent,
+            instruction: taskPayload.instruction,
+            priority,
+            requiresAuth,
+            metadata: { timeout, resourceType },
+            aborted: false,
+        });
+        if (spawnCtx.aborted) {
+            return {
+                success: false,
+                error: {
+                    code: 'LIFECYCLE_ABORTED',
+                    message: spawnCtx.abortReason ?? 'Aborted by beforeSpawn hook',
+                    recoverable: true,
+                },
+            };
+        }
+        // Check permission wall if required -- now returns bound restrictions
+        let grantToken = null;
+        if (requiresAuth) {
+            const authResult = await this.authGuardian.requestPermission(context.agentId, resourceType, `Delegating task to ${targetAgent}: ${taskPayload.instruction}`, 'delegate');
+            if (!authResult.granted) {
+                this.tracer.record({
+                    source: 'AuthGuardian', decision: 'permission_check', outcome: 'denied',
+                    agentId: context.agentId, parentTraceId: delegationTraceId,
+                    factors: [{ name: 'reason', value: authResult.reason }],
+                });
+                this.eventBus.publish('auth', 'permission_denied', 'warn', {
+                    reason: authResult.reason, resourceType,
+                }, context.agentId, delegationTraceId);
+                this.metrics.permissionDenials.inc({ agent: context.agentId });
+                return {
+                    success: false,
+                    error: {
+                        code: 'AUTH_DENIED',
+                        message: `Permission denied: ${authResult.reason}`,
+                        recoverable: true,
+                        suggestedAction: 'Provide more specific justification or narrow scope',
+                    },
+                };
+            }
+            grantToken = authResult.grantToken;
+            // Enforce restrictions at point of use
+            if (grantToken) {
+                const restrictionViolation = this.authGuardian.enforceRestrictions(grantToken, {
+                    type: 'execute',
+                });
+                if (restrictionViolation) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'RESTRICTION_VIOLATED',
+                            message: restrictionViolation,
+                            recoverable: true,
+                            suggestedAction: 'Request a grant with broader scope',
+                        },
+                    };
+                }
+            }
+        }
+        // Check blackboard for existing work
+        const cacheKey = `task:${targetAgent}:${JSON.stringify(taskPayload).slice(0, 50)}`;
+        const existingWork = this.blackboard.read(cacheKey);
+        if (existingWork) {
+            return {
+                success: true,
+                data: {
+                    taskId: 'cached',
+                    status: 'completed',
+                    result: existingWork.value,
+                    agentTrace: ['blackboard-cache'],
+                    fromCache: true,
+                },
+            };
+        }
+        // Build handoff message
+        const handoff = {
+            handoffId: (0, crypto_1.randomUUID)(),
+            sourceAgent: context.agentId,
+            targetAgent,
+            taskType: 'delegate',
+            payload: taskPayload,
+            metadata: {
+                priority: this.priorityToNumber(priority),
+                deadline: Date.now() + timeout,
+                parentTaskId: context.taskId ?? null,
+            },
+        };
+        // Execute via adapter registry (routes to the right framework)
+        try {
+            // Sanitize instruction before sending to adapter
+            let sanitizedInstruction = taskPayload.instruction;
+            try {
+                sanitizedInstruction = security_1.InputSanitizer.sanitizeString(taskPayload.instruction, 10000);
+            }
+            catch { /* use original if sanitization fails */ }
+            // Prompt injection detection
+            const injectionResult = this.injectionShield.analyze(sanitizedInstruction);
+            if (!injectionResult.safe) {
+                this.tracer.record({
+                    source: 'PromptInjectionShield', decision: 'injection_scan', outcome: 'blocked',
+                    agentId: context.agentId, parentTraceId: delegationTraceId,
+                    factors: [
+                        { name: 'score', value: injectionResult.score },
+                        { name: 'matchedRules', value: injectionResult.matchedRules },
+                    ],
+                });
+                this.eventBus.publish('injection', 'blocked', 'error', {
+                    score: injectionResult.score, rules: injectionResult.matchedRules,
+                }, context.agentId, delegationTraceId);
+                this.metrics.injectionBlocks.inc({ agent: context.agentId });
+                return {
+                    success: false,
+                    error: {
+                        code: 'PROMPT_INJECTION_BLOCKED',
+                        message: `Prompt injection detected (score=${injectionResult.score.toFixed(2)}, rules: ${injectionResult.matchedRules.join(', ')})`,
+                        recoverable: true,
+                        suggestedAction: 'Rephrase the instruction to remove injection patterns',
+                    },
+                };
+            }
+            // P1: Namespace-scoped snapshot -- target agent only sees keys it's allowed to see
+            const scopedSnapshot = this.blackboard.getScopedSnapshot(targetAgent);
+            const agentPayload = {
+                action: 'execute',
+                params: {},
+                handoff: {
+                    handoffId: handoff.handoffId,
+                    sourceAgent: handoff.sourceAgent,
+                    targetAgent: handoff.targetAgent,
+                    taskType: handoff.taskType,
+                    instruction: sanitizedInstruction,
+                    context: taskPayload.context,
+                    constraints: taskPayload.constraints,
+                    expectedOutput: taskPayload.expectedOutput,
+                    metadata: handoff.metadata,
+                },
+                blackboardSnapshot: scopedSnapshot,
+            };
+            const agentContext = {
+                agentId: context.agentId,
+                taskId: context.taskId,
+                sessionId: context.sessionId,
+            };
+            const otelSpan = this.otel.startDelegation(context.agentId, targetAgent, handoff.handoffId);
+            const result = await Promise.race([
+                this.adapters.executeAgent(targetAgent, agentPayload, agentContext),
+                this.timeoutPromise(timeout),
+            ]);
+            otelSpan.setAttribute('agent.result.success', result.success);
+            otelSpan.end();
+            // P1: Sanitize adapter output before caching
+            let sanitizedResult = result;
+            try {
+                sanitizedResult = security_1.InputSanitizer.sanitizeObject(result);
+            }
+            catch { /* use raw if sanitization fails */ }
+            // Quality gate: validate result before committing to blackboard
+            const gateResult = await this.qualityGate.gate(cacheKey, sanitizedResult, targetAgent, {
+                taskInstruction: taskPayload.instruction,
+                expectedOutput: taskPayload.expectedOutput,
+            });
+            this.tracer.record({
+                source: 'QualityGateAgent', decision: 'quality_gate', outcome: gateResult.decision,
+                agentId: targetAgent, parentTraceId: delegationTraceId,
+                factors: [
+                    { name: 'score', value: gateResult.validation.score },
+                    { name: 'issueCount', value: gateResult.validation.issues.length },
+                ],
+            });
+            this.eventBus.publish('quality', gateResult.decision, gateResult.decision === 'reject' ? 'warn' : 'info', {
+                score: gateResult.validation.score, issueCount: gateResult.validation.issues.length,
+            }, targetAgent, delegationTraceId);
+            if (gateResult.decision === 'reject') {
+                this.metrics.qualityRejections.inc({ agent: targetAgent });
+                return {
+                    success: false,
+                    error: {
+                        code: 'QUALITY_REJECTED',
+                        message: `Result from ${targetAgent} failed quality validation: ${gateResult.validation.issues.filter(i => i.severity === 'error').map(i => i.message).join('; ')}`,
+                        recoverable: gateResult.validation.recoverable,
+                        suggestedAction: gateResult.validation.issues.find(i => i.suggestion)?.suggestion,
+                    },
+                };
+            }
+            if (gateResult.decision === 'quarantine') {
+                // Still return the result but flag it
+                return {
+                    success: true,
+                    data: {
+                        taskId: handoff.handoffId,
+                        status: 'quarantined',
+                        result: sanitizedResult,
+                        agentTrace: [context.agentId, targetAgent],
+                        qualityGate: {
+                            decision: 'quarantine',
+                            quarantineKey: gateResult.quarantineKey,
+                            score: gateResult.validation.score,
+                            issues: gateResult.validation.issues,
+                            reviewNotes: gateResult.reviewNotes,
+                        },
+                    },
+                };
+            }
+            // Approved -- cache result
+            this.blackboard.write(cacheKey, sanitizedResult, context.agentId, 1800, 'system-orchestrator-token'); // 30 min TTL
+            this.metrics.delegationDurationMs.observe({ agent: targetAgent }, Date.now() - delegationStartMs);
+            this.heatmap.record(targetAgent, {
+                durationMs: Date.now() - delegationStartMs,
+                inputTokens: 0, outputTokens: 0, success: true,
+            });
+            this.anomalyDetector.observe(targetAgent, {
+                latencyMs: Date.now() - delegationStartMs, tokens: 0, success: true,
+            });
+            const resultMeta = sanitizedResult?.metadata;
+            this.conversationLog.recordTurn(targetAgent, {
+                instruction: taskPayload.instruction,
+                result: JSON.stringify(sanitizedResult).slice(0, 2000),
+                success: true,
+                tokensUsed: resultMeta?.tokensUsed,
+                executionTimeMs: resultMeta?.executionTimeMs,
+                adapter: resultMeta?.adapter,
+                qualityDecision: gateResult.decision,
+                correlationId: delegationTraceId,
+                sourceAgent: context.agentId,
+            });
+            // Orchestrator-level afterComplete hook
+            await this.lifecycleHooks.runAfterComplete({
+                agentId: targetAgent,
+                instruction: taskPayload.instruction,
+                result: sanitizedResult,
+                durationMs: Date.now() - delegationStartMs,
+                tokensUsed: resultMeta?.tokensUsed ?? 0,
+                metadata: { qualityDecision: gateResult.decision },
+            });
+            return {
+                success: true,
+                data: {
+                    taskId: handoff.handoffId,
+                    status: 'completed',
+                    result: sanitizedResult,
+                    agentTrace: [context.agentId, targetAgent],
+                    qualityGate: {
+                        decision: 'approve',
+                        score: gateResult.validation.score,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            this.metrics.delegationErrors.inc({ agent: targetAgent });
+            this.conversationLog.recordTurn(targetAgent, {
+                instruction: taskPayload.instruction,
+                success: false,
+                errorCode: 'DELEGATION_FAILED',
+                correlationId: delegationTraceId,
+                sourceAgent: context.agentId,
+            });
+            this.eventBus.publish('orchestrator', 'delegation_failed', 'error', {
+                error: error instanceof Error ? error.message : 'unknown',
+            }, targetAgent, delegationTraceId);
+            // Orchestrator-level onFailure hook
+            const failCtx = await this.lifecycleHooks.runOnFailure({
+                agentId: targetAgent,
+                instruction: taskPayload.instruction,
+                error: error instanceof Error ? error : String(error),
+                durationMs: Date.now() - delegationStartMs,
+                metadata: {},
+                suppress: false,
+            });
+            if (failCtx.suppress) {
+                return { success: true, data: { status: 'suppressed', agentTrace: [context.agentId, targetAgent] } };
+            }
+            return {
+                success: false,
+                error: {
+                    code: 'DELEGATION_FAILED',
+                    message: error instanceof Error ? error.message : 'Task delegation failed',
+                    recoverable: true,
+                },
+            };
+        }
+    }
+    // -------------------------------------------------------------------------
+    // CAPABILITY: query_swarm_state
+    // -------------------------------------------------------------------------
+    async querySwarmState(params, context) {
+        const scope = params.scope ?? 'all';
+        const agentFilter = params.agentFilter;
+        const _includeHistory = params.includeHistory ?? false;
+        const state = {
+            timestamp: new Date().toISOString(),
+        };
+        if (scope === 'all' || scope === 'agents') {
+            let agents = Array.from(this.agentRegistry.values());
+            if (agentFilter) {
+                agents = agents.filter(a => agentFilter.includes(a.agentId));
+            }
+            state.activeAgents = agents;
+        }
+        if (scope === 'all' || scope === 'blackboard') {
+            // P1: Namespace-scoped -- agent only sees keys it's allowed to access
+            state.blackboardSnapshot = this.blackboard.getScopedSnapshot(context.agentId);
+        }
+        if (scope === 'all' || scope === 'permissions') {
+            state.permissionGrants = this.authGuardian.getActiveGrants();
+        }
+        if (scope === 'all' || scope === 'tasks') {
+            // Extract tasks from scoped blackboard
+            const snapshot = this.blackboard.getScopedSnapshot(context.agentId);
+            state.pendingTasks = Object.entries(snapshot)
+                .filter(([key]) => key.startsWith('task:'))
+                .map(([, entry]) => ({
+                taskId: entry.key,
+                agentId: entry.sourceAgent,
+                status: 'in_progress',
+                startedAt: entry.timestamp,
+                description: String(entry.value),
+            }));
+        }
+        return {
+            success: true,
+            data: state,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // CAPABILITY: spawn_parallel_agents
+    // -------------------------------------------------------------------------
+    async spawnParallelAgents(params, context) {
+        const tasks = params.tasks;
+        const synthesisStrategy = params.synthesisStrategy ?? 'merge';
+        if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'Tasks array is required and must not be empty',
+                    recoverable: false,
+                },
+            };
+        }
+        try {
+            const result = await this.taskDecomposer.executeParallel(tasks, synthesisStrategy, context);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: 'PARALLEL_EXECUTION_FAILED',
+                    message: error instanceof Error ? error.message : 'Parallel execution failed',
+                    recoverable: true,
+                },
+            };
+        }
+    }
+    // -------------------------------------------------------------------------
+    // CAPABILITY: request_permission
+    // -------------------------------------------------------------------------
+    async handlePermissionRequest(params, context) {
+        const resourceType = params.resourceType;
+        const justification = params.justification;
+        const scope = params.scope;
+        if (!resourceType || !justification) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'resourceType and justification are required',
+                    recoverable: false,
+                },
+            };
+        }
+        const grant = await this.authGuardian.requestPermission(context.agentId, resourceType, justification, scope);
+        return {
+            success: grant.granted,
+            data: grant,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // CAPABILITY: update_blackboard
+    // -------------------------------------------------------------------------
+    async handleBlackboardUpdate(params, context) {
+        const key = params.key;
+        const value = params.value;
+        const ttl = params.ttl;
+        if (!key || value === undefined) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'key and value are required',
+                    recoverable: false,
+                },
+            };
+        }
+        const previousValue = this.blackboard.read(key)?.value ?? null;
+        // Quality gate: validate before writing to blackboard
+        const gateResult = await this.qualityGate.gate(key, value, context.agentId);
+        if (gateResult.decision === 'reject') {
+            return {
+                success: false,
+                error: {
+                    code: 'QUALITY_REJECTED',
+                    message: `Blackboard write rejected: ${gateResult.validation.issues.filter(i => i.severity === 'error').map(i => i.message).join('; ')}`,
+                    recoverable: gateResult.validation.recoverable,
+                    suggestedAction: gateResult.validation.issues.find(i => i.suggestion)?.suggestion,
+                },
+            };
+        }
+        if (gateResult.decision === 'quarantine') {
+            return {
+                success: true,
+                data: {
+                    success: true,
+                    quarantined: true,
+                    quarantineKey: gateResult.quarantineKey,
+                    qualityScore: gateResult.validation.score,
+                    issues: gateResult.validation.issues,
+                    previousValue,
+                },
+            };
+        }
+        this.blackboard.write(key, value, context.agentId, ttl, 'system-orchestrator-token');
+        return {
+            success: true,
+            data: {
+                success: true,
+                previousValue,
+                qualityScore: gateResult.validation.score,
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // QUALITY GATE MANAGEMENT
+    // -------------------------------------------------------------------------
+    /** Returns quality gate metrics and quarantined entries */
+    handleQualityGateStatus() {
+        return {
+            success: true,
+            data: {
+                metrics: this.qualityGate.getMetrics(),
+                quarantined: this.qualityGate.getQuarantined(),
+            },
+        };
+    }
+    /** Approve or reject a quarantined entry */
+    handleQuarantineReview(params) {
+        const quarantineId = params.quarantineId;
+        const decision = params.decision;
+        if (!quarantineId || !decision) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'quarantineId and decision ("approve" or "reject") are required',
+                    recoverable: false,
+                },
+            };
+        }
+        let entry;
+        if (decision === 'approve') {
+            entry = this.qualityGate.approveQuarantined(quarantineId);
+            if (entry) {
+                // Write the approved entry to the blackboard
+                this.blackboard.write(`approved:${quarantineId}`, entry, 'orchestrator', undefined, 'system-orchestrator-token');
+            }
+        }
+        else {
+            entry = this.qualityGate.rejectQuarantined(quarantineId);
+        }
+        return {
+            success: !!entry,
+            data: entry ? { quarantineId, decision, resolved: true } : undefined,
+            error: entry ? undefined : {
+                code: 'NOT_FOUND',
+                message: `Quarantine entry ${quarantineId} not found`,
+                recoverable: false,
+            },
+        };
+    }
+    /** Expose the quality gate for external configuration */
+    getQualityGate() {
+        return this.qualityGate;
+    }
+    // -------------------------------------------------------------------------
+    // NAMED MULTI-BLACKBOARD API (Phase 5)
+    // -------------------------------------------------------------------------
+    /**
+     * Get or create a named, isolated blackboard managed by this orchestrator.
+     *
+     * Each named board is stored in its own subdirectory:
+     *   `<workspacePath>/boards/<name>/`
+     *
+     * Calling `getBlackboard(name)` a second time returns the same instance --
+     * no duplicate boards are created.
+     *
+     * All existing APIs (`orchestrator.blackboard`, adapters, AuthGuardian, etc.)
+     * are completely unaffected. This is a purely additive method.
+     *
+     * @example
+     * ```typescript
+     * const board = orchestrator.getBlackboard('project-alpha');
+     * board.registerAgent('analyst', 'tok-1', ['analysis:']);
+     * board.write('analysis:result', { score: 0.9 }, 'analyst', 3600, 'tok-1');
+     * const entry = board.read('analysis:result');
+     * ```
+     *
+     * @param name    - Board name: alphanumeric, hyphens and underscores only
+     * @param options - Optional creation options (ignored on subsequent calls)
+     * @returns The isolated `SharedBlackboard` instance for this name
+     * @throws {@link ValidationError} if `name` is empty or contains invalid characters
+     */
+    getBlackboard(name, options) {
+        if (!name || typeof name !== 'string' || name.trim() === '') {
+            throw new errors_1.ValidationError('name must be a non-empty string');
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+            throw new errors_1.ValidationError('name must contain only alphanumeric characters, hyphens, or underscores');
+        }
+        // Return existing board (idempotent)
+        if (this.namedBlackboards.has(name)) {
+            return this.namedBlackboards.get(name);
+        }
+        let board;
+        let selectedBackend;
+        if (options?.backend) {
+            // Custom backend — no disk directory needed
+            selectedBackend = options.backend;
+            log.info('Named blackboard created (custom backend)', { name });
+        }
+        else {
+            // Default: file backend persisted to <workspacePath>/boards/<name>/
+            const boardPath = (0, path_1.join)(this._workspacePath, 'boards', name);
+            (0, fs_1.mkdirSync)(boardPath, { recursive: true });
+            selectedBackend = new blackboard_backend_1.FileBackend(boardPath);
+            log.info('Named blackboard created', { name, boardPath: (0, path_1.join)(this._workspacePath, 'boards', name) });
+        }
+        // Auto-wrap with ConsistentBackend when a non-default consistency level is requested
+        if (options?.consistency && options.consistency !== 'eventual') {
+            selectedBackend = new consistency_1.ConsistentBackend(selectedBackend, options.consistency);
+            log.info('Named blackboard wrapped with ConsistentBackend', { name, consistency: options.consistency });
+        }
+        board = new shared_blackboard_1.SharedBlackboard(selectedBackend);
+        // Register the orchestrator agent on this board
+        board.registerAgent('orchestrator', 'system-orchestrator-token', options?.allowedNamespaces ?? ['*']);
+        this.namedBlackboards.set(name, board);
+        return board;
+    }
+    /**
+     * Returns the names of all currently active named blackboards.
+     *
+     * @example
+     * ```typescript
+     * orchestrator.getBlackboard('alpha');
+     * orchestrator.getBlackboard('beta');
+     * orchestrator.listBlackboards(); // ['alpha', 'beta']
+     * ```
+     */
+    listBlackboards() {
+        return Array.from(this.namedBlackboards.keys());
+    }
+    /**
+     * Returns `true` if a named blackboard with the given name is currently active.
+     *
+     * @param name - The board name to check
+     */
+    hasBlackboard(name) {
+        if (!name || typeof name !== 'string')
+            return false;
+        return this.namedBlackboards.has(name);
+    }
+    /**
+     * Removes a named blackboard from the in-memory registry.
+     *
+     * **On-disk data is NOT deleted** -- call `getBlackboard(name)` again to
+     * re-attach to the same persistent board at a later point.
+     *
+     * @param name - The board name to remove
+     * @returns `true` if the board existed and was removed, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * orchestrator.destroyBlackboard('project-alpha'); // true
+     * orchestrator.hasBlackboard('project-alpha');     // false
+     * ```
+     */
+    destroyBlackboard(name) {
+        if (!name || typeof name !== 'string')
+            return false;
+        const existed = this.namedBlackboards.has(name);
+        this.namedBlackboards.delete(name);
+        if (existed)
+            log.info('Named blackboard removed from registry', { name });
+        return existed;
+    }
+    // -------------------------------------------------------------------------
+    // UTILITY METHODS
+    // -------------------------------------------------------------------------
+    priorityToNumber(priority) {
+        const map = {
+            low: 0,
+            normal: 1,
+            high: 2,
+            critical: 3,
+        };
+        return map[priority] ?? 1;
+    }
+    timeoutPromise(ms) {
+        return new Promise((_, reject) => {
+            setTimeout(() => reject(new errors_1.TimeoutError(ms)), ms);
+        });
+    }
+    /**
+     * Register an agent with the swarm
+     */
+    registerAgent(agentId, status = 'available') {
+        if (!agentId || typeof agentId !== 'string' || agentId.trim() === '') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
+        const validStatuses = ['available', 'busy', 'waiting_auth', 'offline'];
+        if (!validStatuses.includes(status)) {
+            throw new errors_1.ValidationError(`status must be one of: ${validStatuses.join(', ')}`);
+        }
+        this.agentRegistry.set(agentId, {
+            agentId,
+            status,
+            currentTask: null,
+            lastHeartbeat: new Date().toISOString(),
+        });
+    }
+    /**
+     * Update agent status
+     */
+    updateAgentStatus(agentId, status, currentTask) {
+        if (!agentId || typeof agentId !== 'string' || agentId.trim() === '') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
+        const existing = this.agentRegistry.get(agentId);
+        if (existing) {
+            existing.status = status;
+            existing.currentTask = currentTask ?? null;
+            existing.lastHeartbeat = new Date().toISOString();
+        }
+    }
+}
+exports.SwarmOrchestrator = SwarmOrchestrator;
+// ============================================================================
+// EXPORTS & MODULE INITIALIZATION
+// ============================================================================
+// Default export for OpenClaw skill loader (backward compatible)
+exports.default = SwarmOrchestrator;
+// Named exports for direct usage (re-exported from extracted modules)
+var shared_blackboard_2 = require("./lib/shared-blackboard");
+Object.defineProperty(exports, "SharedBlackboard", { enumerable: true, get: function () { return shared_blackboard_2.SharedBlackboard; } });
+var auth_guardian_2 = require("./lib/auth-guardian");
+Object.defineProperty(exports, "AuthGuardian", { enumerable: true, get: function () { return auth_guardian_2.AuthGuardian; } });
+var task_decomposer_2 = require("./lib/task-decomposer");
+Object.defineProperty(exports, "TaskDecomposer", { enumerable: true, get: function () { return task_decomposer_2.TaskDecomposer; } });
+var explainability_2 = require("./lib/explainability");
+Object.defineProperty(exports, "ExplainabilityTracer", { enumerable: true, get: function () { return explainability_2.ExplainabilityTracer; } });
+var event_bus_2 = require("./lib/event-bus");
+Object.defineProperty(exports, "OrchestratorEventBus", { enumerable: true, get: function () { return event_bus_2.OrchestratorEventBus; } });
+var agent_conversation_2 = require("./lib/agent-conversation");
+Object.defineProperty(exports, "AgentConversationLog", { enumerable: true, get: function () { return agent_conversation_2.AgentConversationLog; } });
+var otel_bridge_2 = require("./lib/otel-bridge");
+Object.defineProperty(exports, "OTelBridge", { enumerable: true, get: function () { return otel_bridge_2.OTelBridge; } });
+Object.defineProperty(exports, "SpanStatus", { enumerable: true, get: function () { return otel_bridge_2.SpanStatus; } });
+var metrics_2 = require("./lib/metrics");
+Object.defineProperty(exports, "MetricsRegistry", { enumerable: true, get: function () { return metrics_2.MetricsRegistry; } });
+Object.defineProperty(exports, "Counter", { enumerable: true, get: function () { return metrics_2.Counter; } });
+Object.defineProperty(exports, "Gauge", { enumerable: true, get: function () { return metrics_2.Gauge; } });
+Object.defineProperty(exports, "Histogram", { enumerable: true, get: function () { return metrics_2.Histogram; } });
+Object.defineProperty(exports, "createOrchestratorMetrics", { enumerable: true, get: function () { return metrics_2.createOrchestratorMetrics; } });
+var cost_heatmap_2 = require("./lib/cost-heatmap");
+Object.defineProperty(exports, "CostHeatmap", { enumerable: true, get: function () { return cost_heatmap_2.CostHeatmap; } });
+var timeline_scrubber_1 = require("./lib/timeline-scrubber");
+Object.defineProperty(exports, "TimelineScrubber", { enumerable: true, get: function () { return timeline_scrubber_1.TimelineScrubber; } });
+var anomaly_detector_2 = require("./lib/anomaly-detector");
+Object.defineProperty(exports, "AnomalyDetector", { enumerable: true, get: function () { return anomaly_detector_2.AnomalyDetector; } });
+var cost_governor_1 = require("./lib/cost-governor");
+Object.defineProperty(exports, "CostGovernor", { enumerable: true, get: function () { return cost_governor_1.CostGovernor; } });
+Object.defineProperty(exports, "LookupCostModel", { enumerable: true, get: function () { return cost_governor_1.LookupCostModel; } });
+var dry_run_1 = require("./lib/dry-run");
+Object.defineProperty(exports, "DryRunSimulator", { enumerable: true, get: function () { return dry_run_1.DryRunSimulator; } });
+var config_watcher_1 = require("./lib/config-watcher");
+Object.defineProperty(exports, "ConfigWatcher", { enumerable: true, get: function () { return config_watcher_1.ConfigWatcher; } });
+var lifecycle_hooks_2 = require("./lib/lifecycle-hooks");
+Object.defineProperty(exports, "OrchestratorLifecycleHooks", { enumerable: true, get: function () { return lifecycle_hooks_2.OrchestratorLifecycleHooks; } });
+var agent_memory_1 = require("./lib/agent-memory");
+Object.defineProperty(exports, "AgentMemory", { enumerable: true, get: function () { return agent_memory_1.AgentMemory; } });
+Object.defineProperty(exports, "EpisodicMemory", { enumerable: true, get: function () { return agent_memory_1.EpisodicMemory; } });
+Object.defineProperty(exports, "ProceduralMemory", { enumerable: true, get: function () { return agent_memory_1.ProceduralMemory; } });
+Object.defineProperty(exports, "SharedLongTermMemory", { enumerable: true, get: function () { return agent_memory_1.SharedLongTermMemory; } });
+var learning_loop_1 = require("./lib/learning-loop");
+Object.defineProperty(exports, "LearningLoop", { enumerable: true, get: function () { return learning_loop_1.LearningLoop; } });
+var speculative_executor_1 = require("./lib/speculative-executor");
+Object.defineProperty(exports, "SpeculativeExecutor", { enumerable: true, get: function () { return speculative_executor_1.SpeculativeExecutor; } });
+var agent_debate_1 = require("./lib/agent-debate");
+Object.defineProperty(exports, "AgentDebate", { enumerable: true, get: function () { return agent_debate_1.AgentDebate; } });
+// Basis tier — SAP-inspired transport and landscape agents
+var transport_agent_1 = require("./lib/transport-agent");
+Object.defineProperty(exports, "TransportAgent", { enumerable: true, get: function () { return transport_agent_1.TransportAgent; } });
+var landscape_agent_1 = require("./lib/landscape-agent");
+Object.defineProperty(exports, "LandscapeAgent", { enumerable: true, get: function () { return landscape_agent_1.LandscapeAgent; } });
+var approval_inbox_1 = require("./lib/approval-inbox");
+Object.defineProperty(exports, "ApprovalInbox", { enumerable: true, get: function () { return approval_inbox_1.ApprovalInbox; } });
+var adapter_test_harness_1 = require("./lib/adapter-test-harness");
+Object.defineProperty(exports, "createAdapterTestSuite", { enumerable: true, get: function () { return adapter_test_harness_1.createAdapterTestSuite; } });
+var swarm_transport_1 = require("./lib/swarm-transport");
+Object.defineProperty(exports, "SwarmTransportServer", { enumerable: true, get: function () { return swarm_transport_1.SwarmTransportServer; } });
+Object.defineProperty(exports, "SwarmTransportClient", { enumerable: true, get: function () { return swarm_transport_1.SwarmTransportClient; } });
+var job_queue_1 = require("./lib/job-queue");
+Object.defineProperty(exports, "JobQueue", { enumerable: true, get: function () { return job_queue_1.JobQueue; } });
+Object.defineProperty(exports, "FileJobStore", { enumerable: true, get: function () { return job_queue_1.FileJobStore; } });
+var playground_1 = require("./lib/playground");
+Object.defineProperty(exports, "startPlayground", { enumerable: true, get: function () { return playground_1.startPlayground; } });
+Object.defineProperty(exports, "MockAgentRegistry", { enumerable: true, get: function () { return playground_1.MockAgentRegistry; } });
+var goal_dsl_1 = require("./lib/goal-dsl");
+Object.defineProperty(exports, "parseGoal", { enumerable: true, get: function () { return goal_dsl_1.parseGoal; } });
+Object.defineProperty(exports, "goalFromObject", { enumerable: true, get: function () { return goal_dsl_1.goalFromObject; } });
+Object.defineProperty(exports, "validateGoal", { enumerable: true, get: function () { return goal_dsl_1.validateGoal; } });
+Object.defineProperty(exports, "compileGoal", { enumerable: true, get: function () { return goal_dsl_1.compileGoal; } });
+var agent_vcr_1 = require("./lib/agent-vcr");
+Object.defineProperty(exports, "AgentVCR", { enumerable: true, get: function () { return agent_vcr_1.AgentVCR; } });
+var coverage_reporter_1 = require("./lib/coverage-reporter");
+Object.defineProperty(exports, "CoverageReporter", { enumerable: true, get: function () { return coverage_reporter_1.CoverageReporter; } });
+var comparison_runner_1 = require("./lib/comparison-runner");
+Object.defineProperty(exports, "ComparisonRunner", { enumerable: true, get: function () { return comparison_runner_1.ComparisonRunner; } });
+var auth_validator_1 = require("./lib/auth-validator");
+Object.defineProperty(exports, "NoOpAuthValidator", { enumerable: true, get: function () { return auth_validator_1.NoOpAuthValidator; } });
+// Quality gate & validation exports
+var blackboard_validator_2 = require("./lib/blackboard-validator");
+Object.defineProperty(exports, "BlackboardValidator", { enumerable: true, get: function () { return blackboard_validator_2.BlackboardValidator; } });
+Object.defineProperty(exports, "QualityGateAgent", { enumerable: true, get: function () { return blackboard_validator_2.QualityGateAgent; } });
+Object.defineProperty(exports, "validateJsonSchema", { enumerable: true, get: function () { return blackboard_validator_2.validateJsonSchema; } });
+// Adapter system re-exports for convenience
+var adapter_registry_2 = require("./adapters/adapter-registry");
+Object.defineProperty(exports, "AdapterRegistry", { enumerable: true, get: function () { return adapter_registry_2.AdapterRegistry; } });
+var base_adapter_1 = require("./adapters/base-adapter");
+Object.defineProperty(exports, "BaseAdapter", { enumerable: true, get: function () { return base_adapter_1.BaseAdapter; } });
+var openclaw_adapter_1 = require("./adapters/openclaw-adapter");
+Object.defineProperty(exports, "OpenClawAdapter", { enumerable: true, get: function () { return openclaw_adapter_1.OpenClawAdapter; } });
+var langchain_adapter_1 = require("./adapters/langchain-adapter");
+Object.defineProperty(exports, "LangChainAdapter", { enumerable: true, get: function () { return langchain_adapter_1.LangChainAdapter; } });
+var autogen_adapter_1 = require("./adapters/autogen-adapter");
+Object.defineProperty(exports, "AutoGenAdapter", { enumerable: true, get: function () { return autogen_adapter_1.AutoGenAdapter; } });
+var crewai_adapter_1 = require("./adapters/crewai-adapter");
+Object.defineProperty(exports, "CrewAIAdapter", { enumerable: true, get: function () { return crewai_adapter_1.CrewAIAdapter; } });
+var mcp_adapter_1 = require("./adapters/mcp-adapter");
+Object.defineProperty(exports, "MCPAdapter", { enumerable: true, get: function () { return mcp_adapter_1.MCPAdapter; } });
+var custom_adapter_1 = require("./adapters/custom-adapter");
+Object.defineProperty(exports, "CustomAdapter", { enumerable: true, get: function () { return custom_adapter_1.CustomAdapter; } });
+var mcp_tool_consumer_1 = require("./lib/mcp-tool-consumer");
+Object.defineProperty(exports, "MCPToolConsumer", { enumerable: true, get: function () { return mcp_tool_consumer_1.MCPToolConsumer; } });
+Object.defineProperty(exports, "StdioClientTransport", { enumerable: true, get: function () { return mcp_tool_consumer_1.StdioClientTransport; } });
+Object.defineProperty(exports, "HttpClientTransport", { enumerable: true, get: function () { return mcp_tool_consumer_1.HttpClientTransport; } });
+// LockedBlackboard WAL / sweep public API
+var locked_blackboard_1 = require("./lib/locked-blackboard");
+Object.defineProperty(exports, "LockedBlackboard", { enumerable: true, get: function () { return locked_blackboard_1.LockedBlackboard; } });
+// Phase 5 Part 2: Pluggable Backend API
+var blackboard_backend_2 = require("./lib/blackboard-backend");
+Object.defineProperty(exports, "FileBackend", { enumerable: true, get: function () { return blackboard_backend_2.FileBackend; } });
+Object.defineProperty(exports, "MemoryBackend", { enumerable: true, get: function () { return blackboard_backend_2.MemoryBackend; } });
+// Phase 5 Part 3: Redis Backend
+var blackboard_backend_redis_1 = require("./lib/blackboard-backend-redis");
+Object.defineProperty(exports, "RedisBackend", { enumerable: true, get: function () { return blackboard_backend_redis_1.RedisBackend; } });
+// Phase 5 Part 4: CRDT Backend
+var blackboard_backend_crdt_1 = require("./lib/blackboard-backend-crdt");
+Object.defineProperty(exports, "CrdtBackend", { enumerable: true, get: function () { return blackboard_backend_crdt_1.CrdtBackend; } });
+var crdt_1 = require("./lib/crdt");
+Object.defineProperty(exports, "tickClock", { enumerable: true, get: function () { return crdt_1.tickClock; } });
+Object.defineProperty(exports, "mergeClock", { enumerable: true, get: function () { return crdt_1.mergeClock; } });
+Object.defineProperty(exports, "happensBefore", { enumerable: true, get: function () { return crdt_1.happensBefore; } });
+Object.defineProperty(exports, "isConcurrent", { enumerable: true, get: function () { return crdt_1.isConcurrent; } });
+Object.defineProperty(exports, "compareClock", { enumerable: true, get: function () { return crdt_1.compareClock; } });
+Object.defineProperty(exports, "mergeEntry", { enumerable: true, get: function () { return crdt_1.mergeEntry; } });
+// Phase 5 Part 5: Configurable Consistency Levels
+var consistency_2 = require("./lib/consistency");
+Object.defineProperty(exports, "ConsistentBackend", { enumerable: true, get: function () { return consistency_2.ConsistentBackend; } });
+Object.defineProperty(exports, "isFlushable", { enumerable: true, get: function () { return consistency_2.isFlushable; } });
+// Phase 5 Part 6: Federated Budget Tracking
+var federated_budget_1 = require("./lib/federated-budget");
+Object.defineProperty(exports, "FederatedBudget", { enumerable: true, get: function () { return federated_budget_1.FederatedBudget; } });
+// Phase 5 Part 7: MCP Networking
+var mcp_bridge_1 = require("./lib/mcp-bridge");
+Object.defineProperty(exports, "McpBlackboardBridge", { enumerable: true, get: function () { return mcp_bridge_1.McpBlackboardBridge; } });
+Object.defineProperty(exports, "McpBridgeClient", { enumerable: true, get: function () { return mcp_bridge_1.McpBridgeClient; } });
+Object.defineProperty(exports, "McpBridgeRouter", { enumerable: true, get: function () { return mcp_bridge_1.McpBridgeRouter; } });
+Object.defineProperty(exports, "McpInProcessTransport", { enumerable: true, get: function () { return mcp_bridge_1.McpInProcessTransport; } });
+// Logger
+var logger_2 = require("./lib/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_2.Logger; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_2.LogLevel; } });
+// Typed errors
+var errors_2 = require("./lib/errors");
+Object.defineProperty(exports, "NetworkAIError", { enumerable: true, get: function () { return errors_2.NetworkAIError; } });
+Object.defineProperty(exports, "IdentityVerificationError", { enumerable: true, get: function () { return errors_2.IdentityVerificationError; } });
+Object.defineProperty(exports, "NamespaceViolationError", { enumerable: true, get: function () { return errors_2.NamespaceViolationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_2.ValidationError; } });
+Object.defineProperty(exports, "LockAcquisitionError", { enumerable: true, get: function () { return errors_2.LockAcquisitionError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return errors_2.ConflictError; } });
+Object.defineProperty(exports, "AdapterAlreadyRegisteredError", { enumerable: true, get: function () { return errors_2.AdapterAlreadyRegisteredError; } });
+Object.defineProperty(exports, "AdapterNotFoundError", { enumerable: true, get: function () { return errors_2.AdapterNotFoundError; } });
+Object.defineProperty(exports, "AdapterNotInitializedError", { enumerable: true, get: function () { return errors_2.AdapterNotInitializedError; } });
+Object.defineProperty(exports, "ParallelLimitError", { enumerable: true, get: function () { return errors_2.ParallelLimitError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_2.TimeoutError; } });
+Object.defineProperty(exports, "mapErrorToSkillResult", { enumerable: true, get: function () { return errors_2.mapErrorToSkillResult; } });
+// ============================================================================
+// Phase 4: Behavioral Control Plane
+// ============================================================================
+// FSM Journey Layer
+var fsm_journey_1 = require("./lib/fsm-journey");
+Object.defineProperty(exports, "JourneyFSM", { enumerable: true, get: function () { return fsm_journey_1.JourneyFSM; } });
+Object.defineProperty(exports, "ToolAuthorizationMatrix", { enumerable: true, get: function () { return fsm_journey_1.ToolAuthorizationMatrix; } });
+Object.defineProperty(exports, "ComplianceMiddleware", { enumerable: true, get: function () { return fsm_journey_1.ComplianceMiddleware; } });
+Object.defineProperty(exports, "ComplianceViolationError", { enumerable: true, get: function () { return fsm_journey_1.ComplianceViolationError; } });
+Object.defineProperty(exports, "createDeliveryPipelineFSM", { enumerable: true, get: function () { return fsm_journey_1.createDeliveryPipelineFSM; } });
+Object.defineProperty(exports, "WORKFLOW_STATES", { enumerable: true, get: function () { return fsm_journey_1.WORKFLOW_STATES; } });
+// Real-Time Compliance Monitor
+var compliance_monitor_1 = require("./lib/compliance-monitor");
+Object.defineProperty(exports, "ComplianceMonitor", { enumerable: true, get: function () { return compliance_monitor_1.ComplianceMonitor; } });
+// Claim Verifier (Tier 1 Agent Honesty / Lie Detector)
+var claim_verifier_1 = require("./lib/claim-verifier");
+Object.defineProperty(exports, "ClaimVerifier", { enumerable: true, get: function () { return claim_verifier_1.ClaimVerifier; } });
+// QA Orchestrator Agent
+var qa_orchestrator_1 = require("./lib/qa-orchestrator");
+Object.defineProperty(exports, "QAOrchestratorAgent", { enumerable: true, get: function () { return qa_orchestrator_1.QAOrchestratorAgent; } });
+// Adapter Hook Middleware (Phase 7b)
+var adapter_hooks_1 = require("./lib/adapter-hooks");
+Object.defineProperty(exports, "AdapterHookManager", { enumerable: true, get: function () { return adapter_hooks_1.AdapterHookManager; } });
+Object.defineProperty(exports, "matchGlob", { enumerable: true, get: function () { return adapter_hooks_1.matchGlob; } });
+Object.defineProperty(exports, "matchToolPattern", { enumerable: true, get: function () { return adapter_hooks_1.matchToolPattern; } });
+// Skill Composer (Phase 7d)
+var skill_composer_1 = require("./lib/skill-composer");
+Object.defineProperty(exports, "SkillComposer", { enumerable: true, get: function () { return skill_composer_1.SkillComposer; } });
+// Semantic Memory Search (Phase 7e)
+var semantic_search_1 = require("./lib/semantic-search");
+Object.defineProperty(exports, "SemanticMemory", { enumerable: true, get: function () { return semantic_search_1.SemanticMemory; } });
+// Phase Pipeline — Multi-phase workflows with approval gates (Phase 8a)
+var phase_pipeline_1 = require("./lib/phase-pipeline");
+Object.defineProperty(exports, "PhasePipeline", { enumerable: true, get: function () { return phase_pipeline_1.PhasePipeline; } });
+// Confidence Filter — Multi-agent result scoring & filtering (Phase 8b)
+var confidence_filter_1 = require("./lib/confidence-filter");
+Object.defineProperty(exports, "ConfidenceFilter", { enumerable: true, get: function () { return confidence_filter_1.ConfidenceFilter; } });
+// Fan-Out / Fan-In — Parallel agent aggregation (Phase 8d)
+var fan_out_1 = require("./lib/fan-out");
+Object.defineProperty(exports, "FanOutFanIn", { enumerable: true, get: function () { return fan_out_1.FanOutFanIn; } });
+// Agent Runtime — Sandboxed execution environment (Phase 9a)
+var agent_runtime_1 = require("./lib/agent-runtime");
+Object.defineProperty(exports, "SandboxPolicy", { enumerable: true, get: function () { return agent_runtime_1.SandboxPolicy; } });
+Object.defineProperty(exports, "ShellExecutor", { enumerable: true, get: function () { return agent_runtime_1.ShellExecutor; } });
+Object.defineProperty(exports, "FileAccessor", { enumerable: true, get: function () { return agent_runtime_1.FileAccessor; } });
+Object.defineProperty(exports, "ApprovalGate", { enumerable: true, get: function () { return agent_runtime_1.ApprovalGate; } });
+Object.defineProperty(exports, "AgentRuntime", { enumerable: true, get: function () { return agent_runtime_1.AgentRuntime; } });
+Object.defineProperty(exports, "RuntimePolicyError", { enumerable: true, get: function () { return agent_runtime_1.RuntimePolicyError; } });
+Object.defineProperty(exports, "RuntimeApprovalError", { enumerable: true, get: function () { return agent_runtime_1.RuntimeApprovalError; } });
+Object.defineProperty(exports, "RuntimeExecutionError", { enumerable: true, get: function () { return agent_runtime_1.RuntimeExecutionError; } });
+// Console UI — Interactive terminal dashboard (Phase 9b)
+var console_ui_1 = require("./lib/console-ui");
+Object.defineProperty(exports, "ConsoleUI", { enumerable: true, get: function () { return console_ui_1.ConsoleUI; } });
+Object.defineProperty(exports, "ansi", { enumerable: true, get: function () { return console_ui_1.ansi; } });
+// Strategy Agent — AI Meta-Orchestrator (Phase 9c)
+var strategy_agent_1 = require("./lib/strategy-agent");
+Object.defineProperty(exports, "AgentPool", { enumerable: true, get: function () { return strategy_agent_1.AgentPool; } });
+Object.defineProperty(exports, "WorkloadPartitioner", { enumerable: true, get: function () { return strategy_agent_1.WorkloadPartitioner; } });
+Object.defineProperty(exports, "StrategyAgent", { enumerable: true, get: function () { return strategy_agent_1.StrategyAgent; } });
+Object.defineProperty(exports, "adaptiveStrategy", { enumerable: true, get: function () { return strategy_agent_1.adaptiveStrategy; } });
+// Goal Decomposer — LLM-powered goal → task DAG → parallel execution (Phase 10)
+var goal_decomposer_1 = require("./lib/goal-decomposer");
+Object.defineProperty(exports, "GoalDecomposer", { enumerable: true, get: function () { return goal_decomposer_1.GoalDecomposer; } });
+Object.defineProperty(exports, "TeamRunner", { enumerable: true, get: function () { return goal_decomposer_1.TeamRunner; } });
+Object.defineProperty(exports, "runTeam", { enumerable: true, get: function () { return goal_decomposer_1.runTeam; } });
+Object.defineProperty(exports, "createLLMPlanner", { enumerable: true, get: function () { return goal_decomposer_1.createLLMPlanner; } });
+Object.defineProperty(exports, "validateDAG", { enumerable: true, get: function () { return goal_decomposer_1.validateDAG; } });
+Object.defineProperty(exports, "topologicalLayers", { enumerable: true, get: function () { return goal_decomposer_1.topologicalLayers; } });
+Object.defineProperty(exports, "parsePlanJSON", { enumerable: true, get: function () { return goal_decomposer_1.parsePlanJSON; } });
+// Context Throttler — Metadata-driven blackboard pruning (Phase 12)
+var context_throttler_1 = require("./lib/context-throttler");
+Object.defineProperty(exports, "ContextThrottler", { enumerable: true, get: function () { return context_throttler_1.ContextThrottler; } });
+Object.defineProperty(exports, "filterState", { enumerable: true, get: function () { return context_throttler_1.filterState; } });
+// Partition Planner — Logical work partitioning to prevent redundant research (Phase 12)
+var partition_planner_1 = require("./lib/partition-planner");
+Object.defineProperty(exports, "PartitionPlanner", { enumerable: true, get: function () { return partition_planner_1.PartitionPlanner; } });
+Object.defineProperty(exports, "createLexicalOverlapChecker", { enumerable: true, get: function () { return partition_planner_1.createLexicalOverlapChecker; } });
+Object.defineProperty(exports, "createLLMPartitionPlanner", { enumerable: true, get: function () { return partition_planner_1.createLLMPartitionPlanner; } });
+Object.defineProperty(exports, "parsePartitionJSON", { enumerable: true, get: function () { return partition_planner_1.parsePartitionJSON; } });
+// Coverage Gate — Recursive refinement loop with score-gated completion (Phase 12)
+var coverage_gate_1 = require("./lib/coverage-gate");
+Object.defineProperty(exports, "CoverageGate", { enumerable: true, get: function () { return coverage_gate_1.CoverageGate; } });
+Object.defineProperty(exports, "createKeywordEvaluator", { enumerable: true, get: function () { return coverage_gate_1.createKeywordEvaluator; } });
+Object.defineProperty(exports, "createLLMEvaluator", { enumerable: true, get: function () { return coverage_gate_1.createLLMEvaluator; } });
+// Route Classifier — Short-circuit routing for factual lookups (Phase 12)
+var route_classifier_1 = require("./lib/route-classifier");
+Object.defineProperty(exports, "RouteClassifier", { enumerable: true, get: function () { return route_classifier_1.RouteClassifier; } });
+Object.defineProperty(exports, "createHeuristicClassifier", { enumerable: true, get: function () { return route_classifier_1.createHeuristicClassifier; } });
+Object.defineProperty(exports, "createLLMClassifier", { enumerable: true, get: function () { return route_classifier_1.createLLMClassifier; } });
+// Live Agent Topology — Real-time agent graph + dashboard (Phase 11)
+var topology_1 = require("./lib/topology");
+Object.defineProperty(exports, "TopologyTracker", { enumerable: true, get: function () { return topology_1.TopologyTracker; } });
+var dashboard_server_1 = require("./lib/dashboard-server");
+Object.defineProperty(exports, "DashboardServer", { enumerable: true, get: function () { return dashboard_server_1.DashboardServer; } });
+// WorkTree — Hierarchical task decomposition tree with rollup
+var work_tree_1 = require("./lib/work-tree");
+Object.defineProperty(exports, "WorkTree", { enumerable: true, get: function () { return work_tree_1.WorkTree; } });
+// WorkTreeUI — Terminal renderer for WorkTree hierarchies
+var work_tree_ui_1 = require("./lib/work-tree-ui");
+Object.defineProperty(exports, "WorkTreeUI", { enumerable: true, get: function () { return work_tree_ui_1.WorkTreeUI; } });
+// WorkTreeDashboard — Browser-based live WorkTree visualization
+var work_tree_dashboard_1 = require("./lib/work-tree-dashboard");
+Object.defineProperty(exports, "WorkTreeDashboard", { enumerable: true, get: function () { return work_tree_dashboard_1.WorkTreeDashboard; } });
+// ControlPlane — Multi-workspace unified dashboard
+var control_plane_1 = require("./lib/control-plane");
+Object.defineProperty(exports, "ControlPlane", { enumerable: true, get: function () { return control_plane_1.ControlPlane; } });
+// ============================================================================
+// Phase 13 (v5.4.0): Multi-Environment Isolation
+// ============================================================================
+// Environment Manager — isolated data dirs, promotion chain, backup/restore
+var env_manager_1 = require("./lib/env-manager");
+Object.defineProperty(exports, "EnvironmentManager", { enumerable: true, get: function () { return env_manager_1.EnvironmentManager; } });
+// Source Protection — blocks agent access to source code files
+var agent_runtime_2 = require("./lib/agent-runtime");
+Object.defineProperty(exports, "SourceProtectionError", { enumerable: true, get: function () { return agent_runtime_2.SourceProtectionError; } });
+// QuadTree — Barnes-Hut spatial indexing (Tier 1 scalability)
+var quadtree_1 = require("./lib/quadtree");
+Object.defineProperty(exports, "QuadTree", { enumerable: true, get: function () { return quadtree_1.QuadTree; } });
+// MCP Blackboard Tool Bindings
+var mcp_blackboard_tools_1 = require("./lib/mcp-blackboard-tools");
+Object.defineProperty(exports, "BlackboardMCPTools", { enumerable: true, get: function () { return mcp_blackboard_tools_1.BlackboardMCPTools; } });
+Object.defineProperty(exports, "registerBlackboardTools", { enumerable: true, get: function () { return mcp_blackboard_tools_1.registerBlackboardTools; } });
+Object.defineProperty(exports, "BLACKBOARD_TOOL_DEFINITIONS", { enumerable: true, get: function () { return mcp_blackboard_tools_1.BLACKBOARD_TOOL_DEFINITIONS; } });
+/**
+ * Factory function for creating a configured SwarmOrchestrator instance.
+ *
+ * For plug-and-play with other agent systems, pass adapters:
+ *
+ *   const orchestrator = createSwarmOrchestrator({
+ *     adapters: [{ adapter: new LangChainAdapter(), config: {} }],
+ *   });
+ */
+/**
+ * Factory function for creating a fully configured {@link SwarmOrchestrator}.
+ *
+ * Accepts optional configuration for adapters, trust levels, resource profiles,
+ * quality gate settings, and runtime overrides.
+ *
+ * @param config - Optional configuration object. Pass `undefined` for all defaults.
+ * @returns A ready-to-use SwarmOrchestrator instance.
+ *
+ * @example
+ * ```typescript
+ * import { createSwarmOrchestrator, LangChainAdapter } from 'network-ai';
+ *
+ * // Minimal
+ * const orc = createSwarmOrchestrator();
+ *
+ * // With adapters and trust
+ * const orc2 = createSwarmOrchestrator({
+ *   adapters: [{ adapter: new LangChainAdapter() }],
+ *   trustLevels: [{ agentId: 'analyst', trustLevel: 0.8 }],
+ *   qualityThreshold: 0.7,
+ * });
+ * ```
+ */
+function createSwarmOrchestrator(config) {
+    if (config !== undefined && (typeof config !== 'object' || config === null || Array.isArray(config))) {
+        throw new errors_1.ValidationError('config must be a plain object');
+    }
+    if (config) {
+        const { adapters: adapterList, adapterRegistry, trustLevels, resourceProfiles, validationConfig, qualityThreshold, aiReviewCallback, ...rest } = config;
+        Object.assign(orchestrator_types_1.CONFIG, rest);
+        const registry = adapterRegistry ?? new adapter_registry_1.AdapterRegistry();
+        const orchestrator = new SwarmOrchestrator(undefined, registry, {
+            trustLevels,
+            resourceProfiles,
+            validationConfig,
+            qualityThreshold,
+            aiReviewCallback,
+        });
+        // Initialize adapters if provided
+        if (adapterList) {
+            Promise.all(adapterList.map(({ adapter, config: adapterConfig }) => orchestrator.addAdapter(adapter, adapterConfig ?? {}))).catch(err => log.error('Adapter init error', { error: err instanceof Error ? err.message : String(err) }));
+        }
+        return orchestrator;
+    }
+    return new SwarmOrchestrator();
+}
+function getConfig(key) {
+    if (key !== undefined)
+        return orchestrator_types_1.CONFIG[key];
+    return { ...orchestrator_types_1.CONFIG };
+}
+/**
+ * Update a CONFIG key at runtime.  Changes take effect immediately for all
+ * subsequent orchestrator operations.
+ *
+ * @example
+ * ```typescript
+ * setConfig('maxParallelAgents', 10);
+ * setConfig('enableTracing', false);
+ * ```
+ */
+function setConfig(key, value) {
+    orchestrator_types_1.CONFIG[key] = value;
+}
+// Phase 6: SSE transport + extended/control tools
+var mcp_transport_sse_1 = require("./lib/mcp-transport-sse");
+Object.defineProperty(exports, "McpSseServer", { enumerable: true, get: function () { return mcp_transport_sse_1.McpSseServer; } });
+Object.defineProperty(exports, "McpSseTransport", { enumerable: true, get: function () { return mcp_transport_sse_1.McpSseTransport; } });
+Object.defineProperty(exports, "McpCombinedBridge", { enumerable: true, get: function () { return mcp_transport_sse_1.McpCombinedBridge; } });
+Object.defineProperty(exports, "McpBlackboardBridgeAdapter", { enumerable: true, get: function () { return mcp_transport_sse_1.McpBlackboardBridgeAdapter; } });
+// MCP Streamable HTTP Transport — 2025 MCP spec (tools + resources + prompts)
+var mcp_transport_http_1 = require("./lib/mcp-transport-http");
+Object.defineProperty(exports, "McpStreamableServer", { enumerable: true, get: function () { return mcp_transport_http_1.McpStreamableServer; } });
+Object.defineProperty(exports, "BlackboardResourceProvider", { enumerable: true, get: function () { return mcp_transport_http_1.BlackboardResourceProvider; } });
+Object.defineProperty(exports, "OrchestrationPromptProvider", { enumerable: true, get: function () { return mcp_transport_http_1.OrchestrationPromptProvider; } });
+var mcp_tools_extended_1 = require("./lib/mcp-tools-extended");
+Object.defineProperty(exports, "ExtendedMcpTools", { enumerable: true, get: function () { return mcp_tools_extended_1.ExtendedMcpTools; } });
+var mcp_tools_control_1 = require("./lib/mcp-tools-control");
+Object.defineProperty(exports, "ControlMcpTools", { enumerable: true, get: function () { return mcp_tools_control_1.ControlMcpTools; } });
+// Streaming adapters
+var streaming_base_adapter_1 = require("./adapters/streaming-base-adapter");
+Object.defineProperty(exports, "StreamingBaseAdapter", { enumerable: true, get: function () { return streaming_base_adapter_1.StreamingBaseAdapter; } });
+Object.defineProperty(exports, "collectStream", { enumerable: true, get: function () { return streaming_base_adapter_1.collectStream; } });
+var langchain_streaming_adapter_1 = require("./adapters/langchain-streaming-adapter");
+Object.defineProperty(exports, "LangChainStreamingAdapter", { enumerable: true, get: function () { return langchain_streaming_adapter_1.LangChainStreamingAdapter; } });
+var custom_streaming_adapter_1 = require("./adapters/custom-streaming-adapter");
+Object.defineProperty(exports, "CustomStreamingAdapter", { enumerable: true, get: function () { return custom_streaming_adapter_1.CustomStreamingAdapter; } });
+// A2A (Agent-to-Agent) protocol adapter
+var a2a_adapter_1 = require("./adapters/a2a-adapter");
+Object.defineProperty(exports, "A2AAdapter", { enumerable: true, get: function () { return a2a_adapter_1.A2AAdapter; } });
+// Codex adapter (OpenAI Codex CLI / chat / completion)
+var codex_adapter_1 = require("./adapters/codex-adapter");
+Object.defineProperty(exports, "CodexAdapter", { enumerable: true, get: function () { return codex_adapter_1.CodexAdapter; } });
+// MiniMax adapter (MiniMax LLM API)
+var minimax_adapter_1 = require("./adapters/minimax-adapter");
+Object.defineProperty(exports, "MiniMaxAdapter", { enumerable: true, get: function () { return minimax_adapter_1.MiniMaxAdapter; } });
+// NemoClaw adapter (NVIDIA NemoClaw — sandboxed agent execution via OpenShell)
+var nemoclaw_adapter_1 = require("./adapters/nemoclaw-adapter");
+Object.defineProperty(exports, "NemoClawAdapter", { enumerable: true, get: function () { return nemoclaw_adapter_1.NemoClawAdapter; } });
+// Copilot adapter (GitHub Copilot — code generation, review, analysis)
+var copilot_adapter_1 = require("./adapters/copilot-adapter");
+Object.defineProperty(exports, "CopilotAdapter", { enumerable: true, get: function () { return copilot_adapter_1.CopilotAdapter; } });
+// LangGraph adapter
+var langgraph_adapter_1 = require("./adapters/langgraph-adapter");
+Object.defineProperty(exports, "LangGraphAdapter", { enumerable: true, get: function () { return langgraph_adapter_1.LangGraphAdapter; } });
+// Anthropic Computer Use adapter
+var anthropic_computer_use_adapter_1 = require("./adapters/anthropic-computer-use-adapter");
+Object.defineProperty(exports, "AnthropicComputerUseAdapter", { enumerable: true, get: function () { return anthropic_computer_use_adapter_1.AnthropicComputerUseAdapter; } });
+// OpenAI Agents SDK adapter
+var openai_agents_adapter_1 = require("./adapters/openai-agents-adapter");
+Object.defineProperty(exports, "OpenAIAgentsAdapter", { enumerable: true, get: function () { return openai_agents_adapter_1.OpenAIAgentsAdapter; } });
+// Vertex AI adapter
+var vertex_ai_adapter_1 = require("./adapters/vertex-ai-adapter");
+Object.defineProperty(exports, "VertexAIAdapter", { enumerable: true, get: function () { return vertex_ai_adapter_1.VertexAIAdapter; } });
+// Pydantic AI adapter
+var pydantic_ai_adapter_1 = require("./adapters/pydantic-ai-adapter");
+Object.defineProperty(exports, "PydanticAIAdapter", { enumerable: true, get: function () { return pydantic_ai_adapter_1.PydanticAIAdapter; } });
+// Browser Agent adapter
+var browser_agent_adapter_1 = require("./adapters/browser-agent-adapter");
+Object.defineProperty(exports, "BrowserAgentAdapter", { enumerable: true, get: function () { return browser_agent_adapter_1.BrowserAgentAdapter; } });
+// Orchestrator adapter (hierarchical multi-orchestrator coordination)
+var orchestrator_adapter_1 = require("./adapters/orchestrator-adapter");
+Object.defineProperty(exports, "OrchestratorAdapter", { enumerable: true, get: function () { return orchestrator_adapter_1.OrchestratorAdapter; } });
+// Circuit Breaker (v5.6.1)
+var circuit_breaker_1 = require("./lib/circuit-breaker");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return circuit_breaker_1.CircuitBreaker; } });
+Object.defineProperty(exports, "CircuitOpenError", { enumerable: true, get: function () { return circuit_breaker_1.CircuitOpenError; } });
+// Telemetry Provider — BYOT (v5.7.0)
+var telemetry_provider_1 = require("./lib/telemetry-provider");
+Object.defineProperty(exports, "NullTelemetryProvider", { enumerable: true, get: function () { return telemetry_provider_1.NullTelemetryProvider; } });
+Object.defineProperty(exports, "CapturingTelemetryProvider", { enumerable: true, get: function () { return telemetry_provider_1.CapturingTelemetryProvider; } });
+Object.defineProperty(exports, "createOtelHooks", { enumerable: true, get: function () { return telemetry_provider_1.createOtelHooks; } });
+//# sourceMappingURL=index.js.map