network-ai 4.15.3 → 5.0.0

package/dist/index.d.ts

@@ -11,562 +11,20 @@
  * @license MIT
  */
 import { AdapterRegistry } from './adapters/adapter-registry';
-import type { ConflictResolutionStrategy, AgentPriority, LockedBlackboardOptions } from './lib/locked-blackboard';
-import type { BlackboardBackend } from './lib/blackboard-backend';
-import type { ConsistencyLevel } from './lib/consistency';
 import { QualityGateAgent } from './lib/blackboard-validator';
 import type { ValidationConfig, AIReviewCallback } from './lib/blackboard-validator';
 import type { IAgentAdapter, AdapterConfig } from './types/agent-adapter';
-type OpenClawSkill = {
-    name: string;
-    version: string;
-    execute(action: string, params: Record<string, unknown>, context: SkillContext): Promise<SkillResult>;
-};
-/**
- * Execution context passed to every skill invocation.
- * Identifies the calling agent and associates the call with a task/session.
- */
-interface SkillContext {
-    /** The agent initiating the request */
-    agentId: string;
-    /** Unique task identifier (optional) */
-    taskId?: string;
-    /** Session identifier for multi-turn interactions */
-    sessionId?: string;
-    /** Arbitrary metadata from the host system */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Unified result shape returned by every skill action.
- * Includes structured error information with recovery hints.
- */
-interface SkillResult {
-    /** Whether the action completed successfully */
-    success: boolean;
-    /** Result data (shape varies by action) */
-    data?: unknown;
-    /** Structured error when `success` is false */
-    error?: {
-        /** Machine-readable error code (e.g., `'AUTH_DENIED'`, `'GATEWAY_DENIED'`) */
-        code: string;
-        /** Human-readable error description */
-        message: string;
-        /** Whether the caller can retry or adjust and succeed */
-        recoverable: boolean;
-        /** Suggested remediation step */
-        suggestedAction?: string;
-        /** Trace metadata for debugging */
-        trace?: Record<string, unknown>;
-    };
-}
-/**
- * A task to be delegated to an agent.
- *
- * @example
- * ```typescript
- * const payload: TaskPayload = {
- *   instruction: 'Analyze Q4 revenue trends',
- *   context: { department: 'finance' },
- *   constraints: ['read_only', 'no_pii'],
- *   expectedOutput: 'JSON summary with top-line metrics',
- * };
- * ```
- */
-interface TaskPayload {
-    /** Natural-language instruction for the agent */
-    instruction: string;
-    /** Additional context data relevant to the task */
-    context?: Record<string, unknown>;
-    /** Restrictions or guardrails the agent must respect */
-    constraints?: string[];
-    /** Description of the expected output format */
-    expectedOutput?: string;
-}
-/**
- * Internal message structure for agent-to-agent task handoffs.
- * The orchestrator creates these when delegating work between agents.
- */
-interface HandoffMessage {
-    /** Unique handoff identifier */
-    handoffId: string;
-    /** Agent initiating the handoff */
-    sourceAgent: string;
-    /** Agent receiving the task */
-    targetAgent: string;
-    /** How the target agent should process the task */
-    taskType: 'delegate' | 'collaborate' | 'validate';
-    /** The task to execute */
-    payload: TaskPayload;
-    /** Scheduling and priority metadata */
-    metadata: {
-        /** Priority level (0=low, 3=critical) */
-        priority: number;
-        /** Unix timestamp deadline */
-        deadline: number;
-        /** Parent task for sub-task tracking */
-        parentTaskId: string | null;
-    };
-}
-/**
- * Result of a permission request through the AuthGuardian.
- * Contains the grant token (if approved) and any restrictions.
- */
-interface PermissionGrant {
-    /** Whether permission was granted */
-    granted: boolean;
-    /** Opaque token to present when using the granted resource */
-    grantToken: string | null;
-    /** ISO 8601 expiration timestamp */
-    expiresAt: string | null;
-    /** Restrictions applied to this grant (e.g., `'read_only'`, `'max_records:100'`) */
-    restrictions: string[];
-    /** Human-readable denial reason (when `granted` is false) */
-    reason?: string;
-}
-/** Full snapshot of the swarm's runtime state. */
-interface SwarmState {
-    /** ISO 8601 timestamp when the snapshot was taken */
-    timestamp: string;
-    /** All registered agents and their current status */
-    activeAgents: AgentStatus[];
-    /** Tasks currently pending or in progress */
-    pendingTasks: TaskRecord[];
-    /** Namespace-scoped blackboard entries visible to the querying agent */
-    blackboardSnapshot: Record<string, BlackboardEntry>;
-    /** Active permission grants */
-    permissionGrants: ActiveGrant[];
-}
-/** Runtime status of a registered agent. */
-interface AgentStatus {
-    /** Unique agent identifier */
-    agentId: string;
-    /** Current operational state */
-    status: 'available' | 'busy' | 'waiting_auth' | 'offline';
-    /** ID of the task currently being executed, or null */
-    currentTask: string | null;
-    /** ISO 8601 timestamp of the last heartbeat */
-    lastHeartbeat: string;
-}
-interface TaskRecord {
-    taskId: string;
-    agentId: string;
-    status: 'pending' | 'in_progress' | 'completed' | 'failed';
-    startedAt: string;
-    description: string;
-}
-/** A single entry stored on the shared blackboard. */
-interface BlackboardEntry {
-    /** Entry key (namespace-prefixed, e.g., `'task:analyze'`) */
-    key: string;
-    /** Stored value (any serializable data) */
-    value: unknown;
-    /** Agent that wrote this entry */
-    sourceAgent: string;
-    /** ISO 8601 timestamp of the write */
-    timestamp: string;
-    /** Time-to-live in seconds, or null for no expiry */
-    ttl: number | null;
-}
-/** An active permission grant held by an agent. */
-interface ActiveGrant {
-    /** Opaque grant token */
-    grantToken: string;
-    /** Resource type this grant covers (e.g., `'FILE_SYSTEM'`, `'DATABASE'`) */
-    resourceType: string;
-    /** Agent holding the grant */
-    agentId: string;
-    /** ISO 8601 expiration timestamp */
-    expiresAt: string;
-    /** Restrictions bound to this grant */
-    restrictions: string[];
-    /** Optional scope narrowing (e.g., `'read'`, `'staging_only'`) */
-    scope?: string;
-}
-/**
- * Configurable resource profile -- makes the system domain-agnostic.
- * Users can define any resource type (coding, finance, devops, etc.)
- */
-interface ResourceProfile {
-    /** Base risk score 0-1 */
-    baseRisk: number;
-    /** Default restrictions applied when access is granted */
-    defaultRestrictions: string[];
-    /** Human-readable description */
-    description?: string;
-}
-/**
- * Configuration for agent trust levels.
- * Pass your own agents with their trust scores.
- */
-interface AgentTrustConfig {
-    agentId: string;
-    trustLevel: number;
-    /** Namespace prefixes this agent can read from the blackboard */
-    allowedNamespaces?: string[];
-    /** Resource types this agent can request */
-    allowedResources?: string[];
-}
-/**
- * Options for creating a named blackboard via `orchestrator.getBlackboard(name)`.
- * All fields are optional -- sensible defaults are applied automatically.
- */
-export interface NamedBlackboardOptions {
-    /**
-     * Namespace prefixes the orchestrator agent is allowed to use on this board.
-     * Defaults to `['*']` (full access). Pass e.g. `['analysis:', 'result:']` to
-     * restrict the board to specific key prefixes.
-     */
-    allowedNamespaces?: string[];
-    /**
-     * Custom validation config applied to writes on this board.
-     * Falls back to the orchestrator's global config when omitted.
-     */
-    validationConfig?: Partial<ValidationConfig>;
-    /**
-     * Pluggable storage backend for this board.
-     *
-     * - Omit (default): `FileBackend` — persisted to disk at `<workspacePath>/boards/<name>/`
-     * - `new MemoryBackend()`: pure in-memory, no disk writes
-     * - Custom class implementing `BlackboardBackend`: Redis, CRDT, cloud KV, etc.
-     *
-     * @example
-     * ```typescript
-     * // Ephemeral board (testing / short-lived tasks)
-     * const board = orchestrator.getBlackboard('tmp', { backend: new MemoryBackend() });
-     *
-     * // Custom Redis backend
-     * const board = orchestrator.getBlackboard('prod', { backend: new RedisBackend(client) });
-     * ```
-     */
-    backend?: BlackboardBackend;
-    /**
-     * Consistency level applied to this board's backend.
-     *
-     * When provided, the backend is automatically wrapped in a `ConsistentBackend`
-     * with the specified level. Omitting this (or passing `'eventual'`) leaves the
-     * backend unwrapped for maximum performance.
-     *
-     * - `'eventual'` (default): no wrapping — highest throughput
-     * - `'session'`: read-your-writes guarantee via a local session cache
-     * - `'strong'`: use `board.writeAsync()` to await `backend.flush()` confirmation
-     *
-     * @example
-     * ```typescript
-     * const board = orchestrator.getBlackboard('live', {
-     *   backend: new RedisBackend(client),
-     *   consistency: 'strong',
-     * });
-     * ```
-     */
-    consistency?: ConsistencyLevel;
-}
-/** A single task within a parallel execution batch. */
-interface ParallelTask {
-    /** Agent type or adapter-prefixed ID to route the task to */
-    agentType: string;
-    /** The task payload to execute */
-    taskPayload: TaskPayload;
-}
-/** Result of a parallel execution batch, including synthesis and metrics. */
-interface ParallelExecutionResult {
-    /** Combined result produced by the synthesis strategy */
-    synthesizedResult: unknown;
-    /** Per-agent results with timing */
-    individualResults: Array<{
-        agentType: string;
-        success: boolean;
-        result: unknown;
-        /** Wall-clock execution time in milliseconds */
-        executionTime: number;
-    }>;
-    /** Aggregate execution metrics */
-    executionMetrics: {
-        /** Total wall-clock time in milliseconds */
-        totalTime: number;
-        /** Fraction of tasks that succeeded (0-1) */
-        successRate: number;
-        /** Strategy used to combine results */
-        synthesisStrategy: string;
-    };
-}
-/**
- * Strategy for combining results from parallel agent executions.
- * - `'merge'`  — Combine all successful results into one object
- * - `'vote'`   — Pick the result with the highest confidence/size
- * - `'chain'`  — Use the final result in sequence
- * - `'first-success'` — Return the first successful result
- */
-type SynthesisStrategy = 'merge' | 'vote' | 'chain' | 'first-success';
-declare const CONFIG: {
-    blackboardPath: string;
-    maxParallelAgents: number;
-    defaultTimeout: number;
-    enableTracing: boolean;
-    grantTokenTTL: number;
-    maxBlackboardValueSize: number;
-    auditLogPath: string;
-    trustConfigPath: string;
-};
-/**
- * Namespace-scoped, identity-verified shared state for multi-agent coordination.
- *
- * Every write is identity-verified (agent token), namespace-checked,
- * size-validated, input-sanitized, and atomically persisted through
- * {@link LockedBlackboard}.
- *
- * @example
- * ```typescript
- * const bb = new SharedBlackboard('./workspace');
- * bb.registerAgent('analyst', 'secret-token', ['task:', 'analytics:']);
- * bb.write('task:revenue', { q4: 42_000 }, 'analyst', 3600, 'secret-token');
- * const entry = bb.read('task:revenue');
- * ```
- */
-declare class SharedBlackboard {
-    private backend;
-    private agentTokens;
-    private agentNamespaces;
-    constructor(backendOrPath: string | BlackboardBackend);
-    /**
-     * Register a verified agent identity. Only agents with registered tokens
-     * can write to the blackboard. The orchestrator registers agents after
-     * verifying their identity through the AuthGuardian.
-     */
-    registerAgent(agentId: string, verificationToken: string, allowedNamespaces?: string[]): void;
-    /**
-     * Check if an agent is allowed to access a key based on namespace rules.
-     */
-    private canAccessKey;
-    /**
-     * Verify that the calling agent is who they claim to be.
-     */
-    private verifyAgent;
-    /**
-     * Validate value size and structure before writing.
-     * Prevents DoS via oversized writes and circular data.
-     */
-    private validateValue;
-    /**
-     * Sanitize a key to prevent markdown injection.
-     */
-    private sanitizeKey;
-    /**
-     * Read an entry from the blackboard by key.
-     *
-     * @param key - The entry key to look up
-     * @returns The entry, or `null` if not found or expired
-     * @throws {@link ValidationError} if `key` is not a non-empty string
-     */
-    read(key: string): BlackboardEntry | null;
-    /**
-     * Write to the blackboard with identity verification, namespace checks,
-     * value validation, and input sanitization. Uses LockedBlackboard for
-     * atomic file-system writes.
-     *
-     * @param key - The key to write
-     * @param value - The value (will be sanitized and size-checked)
-     * @param sourceAgent - Agent claiming to write (verified against registered token)
-     * @param ttl - Optional TTL in seconds
-     * @param agentToken - Optional verification token for identity check
-     */
-    write(key: string, value: unknown, sourceAgent: string, ttl?: number, agentToken?: string): BlackboardEntry;
-    /**
-     * Check whether a key exists on the blackboard (not expired).
-     * @param key - The entry key to check
-     */
-    exists(key: string): boolean;
-    /**
-     * Get a full snapshot of all blackboard entries.
-     */
-    getSnapshot(): Record<string, BlackboardEntry>;
-    /**
-     * Get a namespace-scoped snapshot -- only returns keys an agent is allowed to see.
-     * Prevents data leakage between agents.
-     */
-    getScopedSnapshot(agentId: string): Record<string, BlackboardEntry>;
-    /**
-     * Clear all entries (for testing).
-     */
-    clear(): void;
-}
-/**
- * Universal permission wall for multi-agent systems.
- *
- * Evaluates permission requests using a weighted formula of justification
- * quality (40%), agent trust level (30%), and risk score (30%).
- * Resource types, risk profiles, trust levels, and restrictions are all
- * configurable — works for coding, finance, DevOps, or any domain.
- *
- * @example
- * ```typescript
- * const guardian = new AuthGuardian({
- *   trustLevels: [{ agentId: 'analyst', trustLevel: 0.8 }],
- *   resourceProfiles: { CUSTOM_API: { baseRisk: 0.5, defaultRestrictions: ['audit_required'] } },
- * });
- *
- * const grant = await guardian.requestPermission(
- *   'analyst', 'CUSTOM_API', 'Need to fetch Q4 revenue data for report', 'read'
- * );
- * if (grant.granted) {
- *   // Use grant.grantToken to prove authorization
- * }
- * ```
- */
-declare class AuthGuardian {
-    private activeGrants;
-    private agentTrustLevels;
-    private agentTrustConfigs;
-    private resourceProfiles;
-    private auditLog;
-    private auditLogPath;
-    private trustConfigPath;
-    private readonly signingAlgorithm;
-    private readonly hmacSecret;
-    private readonly ed25519PrivateKey;
-    private readonly ed25519PublicKey;
-    constructor(options?: {
-        trustLevels?: AgentTrustConfig[];
-        resourceProfiles?: Record<string, ResourceProfile>;
-        auditLogPath?: string;
-        trustConfigPath?: string;
-        /** Signing algorithm for grant tokens. Default: 'hmac-sha256'. */
-        algorithm?: 'hmac-sha256' | 'ed25519';
-        /** HMAC secret (only used when algorithm is 'hmac-sha256'). Auto-generated if omitted. */
-        hmacSecret?: string;
-    });
-    /**
-     * Register a new resource type at runtime.
-     * Makes the system extensible for any domain.
-     */
-    registerResourceType(name: string, profile: ResourceProfile): void;
-    /**
-     * Register or update an agent's trust configuration at runtime.
-     */
-    registerAgentTrust(config: AgentTrustConfig): void;
-    /**
-     * Request permission to access a resource.
-     * resourceType is now a free string -- validated against registered profiles.
-     */
-    requestPermission(agentId: string, resourceType: string, justification: string, scope?: string): Promise<PermissionGrant>;
-    /**
-     * Validate a grant token and return `true` if it is active and not expired.
-     *
-     * @param token - The grant token to validate
-     * @returns `true` if the token is valid, `false` otherwise
-     */
-    validateToken(token: string): boolean;
-    /**
-     * Validate a token and return the bound restrictions and scope.
-     * Used to enforce restrictions at the point of use.
-     */
-    /**
-     * Validate a token and return the full grant object (including restrictions
-     * and scope) for point-of-use enforcement.
-     *
-     * @param token - The grant token to validate
-     * @returns The grant details, or `null` if invalid/expired
-     */
-    validateTokenWithGrant(token: string): ActiveGrant | null;
-    /**
-     * Enforce restrictions on an operation. Returns an error string if
-     * the operation violates any restriction, or null if allowed.
-     */
-    /**
-     * Enforce restrictions on an operation. Returns an error string if
-     * the operation violates any restriction, or `null` if all restrictions pass.
-     *
-     * @param grantToken  - The grant token authorizing the operation
-     * @param operation   - Description of the operation to check against restrictions
-     * @returns Error message string if a restriction is violated, or `null` if allowed
-     */
-    enforceRestrictions(grantToken: string, operation: {
-        type?: string;
-        recordCount?: number;
-        hasAttachments?: boolean;
-        targetPath?: string;
-        command?: string;
-    }): string | null;
-    /**
-     * Revoke a grant token, immediately invalidating it.
-     * Silently no-ops if the token doesn't exist.
-     *
-     * @param token - The grant token to revoke
-     */
-    revokeToken(token: string): void;
-    private evaluateRequest;
-    /**
-     * Improved justification scoring with resource-relevance checking.
-     * Prevents trivial gaming by verifying the justification mentions
-     * concepts relevant to the requested resource.
-     */
-    private scoreJustification;
-    private assessRisk;
-    private generateGrantToken;
-    /**
-     * Verify a grant token's cryptographic signature.
-     * For Ed25519 tokens, this can be done by any party holding the public key.
-     * For HMAC tokens, only the issuing AuthGuardian can verify.
-     *
-     * @param token - The grant token to verify
-     * @returns `true` if the signature is valid
-     */
-    verifyTokenSignature(token: string): boolean;
-    /**
-     * Get the signing algorithm used by this AuthGuardian instance.
-     */
-    getSigningAlgorithm(): 'hmac-sha256' | 'ed25519';
-    /**
-     * Export the Ed25519 public key in PEM format for third-party verification.
-     * Returns `null` if the instance uses HMAC signing.
-     */
-    exportPublicKey(): string | null;
-    private log;
-    /**
-     * Get all active (non-expired) permission grants.
-     * Automatically cleans up expired grants before returning.
-     */
-    getActiveGrants(): ActiveGrant[];
-    /**
-     * Get the full audit log of permission decisions.
-     * Returns a defensive copy.
-     */
-    getAuditLog(): typeof this.auditLog;
-    /**
-     * Get all registered resource profiles.
-     */
-    getResourceProfiles(): Record<string, ResourceProfile>;
-    /**
-     * Get the allowed namespaces for an agent (used by blackboard scoping).
-     */
-    getAgentNamespaces(agentId: string): string[];
-    private loadTrustFromDisk;
-    private persistTrustToDisk;
-    private loadAuditFromDisk;
-}
-/**
- * Decomposes complex tasks into parallel sub-agent executions.
- *
- * Supports four synthesis strategies (`merge`, `vote`, `chain`, `first-success`)
- * and caches results on the blackboard to avoid redundant work.
- * Routes each sub-task through the {@link AdapterRegistry} so any
- * registered framework can participate.
- */
-declare class TaskDecomposer {
-    private blackboard;
-    private authGuardian;
-    private adapterRegistry;
-    constructor(blackboard: SharedBlackboard, authGuardian: AuthGuardian, adapterRegistry: AdapterRegistry);
-    /**
-     * Decomposes a complex task into parallel sub-agent calls
-     * This is the "Wall Breaker" - transforms impossible monolithic tasks
-     * into manageable parallel executions
-     */
-    executeParallel(tasks: ParallelTask[], synthesisStrategy: SynthesisStrategy | undefined, context: SkillContext): Promise<ParallelExecutionResult>;
-    private executeSingleTask;
-    private synthesize;
-    private generateMergeSummary;
-    private hashPayload;
-}
+import { SharedBlackboard } from './lib/shared-blackboard';
+import { ExplainabilityTracer } from './lib/explainability';
+import { OrchestratorEventBus } from './lib/event-bus';
+import { AgentConversationLog } from './lib/agent-conversation';
+import { OTelBridge } from './lib/otel-bridge';
+import { createOrchestratorMetrics } from './lib/metrics';
+import { CostHeatmap } from './lib/cost-heatmap';
+import { AnomalyDetector } from './lib/anomaly-detector';
+import { OrchestratorLifecycleHooks } from './lib/lifecycle-hooks';
+import { CONFIG } from './lib/orchestrator-types';
+import type { OpenClawSkill, SkillContext, SkillResult, AgentStatus, ResourceProfile, AgentTrustConfig, NamedBlackboardOptions } from './lib/orchestrator-types';
 /**
  * The main orchestrator class — coordinates agents, permissions, blackboard,
  * quality gates, and adapter routing in a single entry point.
@@ -598,6 +56,15 @@ export declare class SwarmOrchestrator implements OpenClawSkill {
     private agentRegistry;
     private gateway;
     private qualityGate;
+    private injectionShield;
+    readonly tracer: ExplainabilityTracer;
+    readonly eventBus: OrchestratorEventBus;
+    readonly conversationLog: AgentConversationLog;
+    readonly otel: OTelBridge;
+    readonly metrics: ReturnType<typeof createOrchestratorMetrics>;
+    readonly heatmap: CostHeatmap;
+    readonly anomalyDetector: AnomalyDetector;
+    readonly lifecycleHooks: OrchestratorLifecycleHooks;
     /** Named isolated blackboards, keyed by board name */
     private namedBlackboards;
     /** Root workspace path -- used as the parent for named board subdirectories */
@@ -704,8 +171,63 @@ export declare class SwarmOrchestrator implements OpenClawSkill {
     updateAgentStatus(agentId: string, status: AgentStatus['status'], currentTask?: string): void;
 }
 export default SwarmOrchestrator;
-export { SharedBlackboard, AuthGuardian, TaskDecomposer };
-export { BlackboardValidator, QualityGateAgent } from './lib/blackboard-validator';
+export { SharedBlackboard } from './lib/shared-blackboard';
+export { AuthGuardian } from './lib/auth-guardian';
+export { TaskDecomposer } from './lib/task-decomposer';
+export { ExplainabilityTracer } from './lib/explainability';
+export type { DecisionCard, DecisionFactor } from './lib/explainability';
+export { OrchestratorEventBus } from './lib/event-bus';
+export type { BusEvent, StateSnapshot, ReplayOptions, ReplayResult, EventSource, EventSeverity } from './lib/event-bus';
+export { AgentConversationLog } from './lib/agent-conversation';
+export type { AgentTurn, AgentStats, AgentConversation } from './lib/agent-conversation';
+export { OTelBridge, SpanStatus } from './lib/otel-bridge';
+export type { OTelSpan, OTelTracer, OTelSpanOptions } from './lib/otel-bridge';
+export { MetricsRegistry, Counter, Gauge, Histogram, createOrchestratorMetrics } from './lib/metrics';
+export type { Labels, HistogramBuckets } from './lib/metrics';
+export { CostHeatmap } from './lib/cost-heatmap';
+export type { HeatmapCell, HeatmapSnapshot, CostRate, ExecutionSample } from './lib/cost-heatmap';
+export { TimelineScrubber } from './lib/timeline-scrubber';
+export type { TimelineFrame, TimelineRange } from './lib/timeline-scrubber';
+export { AnomalyDetector } from './lib/anomaly-detector';
+export type { Anomaly, AnomalyMetric, BaselineSummary } from './lib/anomaly-detector';
+export { CostGovernor, LookupCostModel } from './lib/cost-governor';
+export type { DAGCostPrediction, NodeCostEstimate, CostModel, CostDAGNode, CostBudget } from './lib/cost-governor';
+export { DryRunSimulator } from './lib/dry-run';
+export type { DryRunReport, SimulatedNode, DryRunNode, DryRunBudget } from './lib/dry-run';
+export { ConfigWatcher } from './lib/config-watcher';
+export type { ReloadableConfig, TrustEntry, BudgetOverrides, ConfigTargets, ReloadEvent, ReloadError } from './lib/config-watcher';
+export { OrchestratorLifecycleHooks } from './lib/lifecycle-hooks';
+export type { LifecyclePhase, BeforeSpawnContext, AfterCompleteContext, OnFailureContext, LifecycleHandler, LifecycleHookEntry } from './lib/lifecycle-hooks';
+export { AgentMemory, EpisodicMemory, ProceduralMemory, SharedLongTermMemory } from './lib/agent-memory';
+export type { MemoryEntry, EpisodicEntry, ProceduralEntry, SharedEntry, RecallOptions } from './lib/agent-memory';
+export { LearningLoop } from './lib/learning-loop';
+export type { DAGPattern, PatternStep, DAGOutcome, PatternMatch } from './lib/learning-loop';
+export { SpeculativeExecutor } from './lib/speculative-executor';
+export type { SpeculativeCandidate, SpeculativeResult, SpeculativeOutcome, SpeculativeOptions, SpeculativeExecutorFn } from './lib/speculative-executor';
+export { AgentDebate } from './lib/agent-debate';
+export type { DebateTurn, DebateConfig, DebateOutcome, CritiqueResult, RevisionResult, ProposerFn, CriticFn } from './lib/agent-debate';
+export { ApprovalInbox } from './lib/approval-inbox';
+export type { ApprovalEntry, ApprovalInboxOptions, ApprovalStatus, InboxEvent, InboxEventType, InboxStats } from './lib/approval-inbox';
+export { createAdapterTestSuite } from './lib/adapter-test-harness';
+export type { AdapterTestSuiteConfig, AdapterTestResult, AssertFn, SectionFn } from './lib/adapter-test-harness';
+export { SwarmTransportServer, SwarmTransportClient } from './lib/swarm-transport';
+export type { TransportEnvelope, TransportMeta, TransportResponse, TransportServerConfig, TransportClientConfig, TransportHandler } from './lib/swarm-transport';
+export { JobQueue, FileJobStore } from './lib/job-queue';
+export type { JobRecord, JobCreateOptions, JobHandler, JobQueueConfig, JobQueueStats, JobStatus, JobPriority, IJobStore } from './lib/job-queue';
+export { startPlayground, MockAgentRegistry } from './lib/playground';
+export type { PlaygroundConfig, PlaygroundInstance } from './lib/playground';
+export { parseGoal, goalFromObject, validateGoal, compileGoal } from './lib/goal-dsl';
+export type { GoalDefinition, GoalTask, GoalConstraints, GoalOutput, GoalValidationError, GoalValidationResult, ExecutionLayer, CompiledGoal } from './lib/goal-dsl';
+export { AgentVCR } from './lib/agent-vcr';
+export type { VCRMode, VCRInteraction, VCRCassette, VCRConfig, VCRHandler, VCRMatchResult } from './lib/agent-vcr';
+export { CoverageReporter } from './lib/coverage-reporter';
+export type { FileCoverage, CoverageReport, CoverageThresholds, CoverageReporterConfig } from './lib/coverage-reporter';
+export { ComparisonRunner } from './lib/comparison-runner';
+export type { ComparisonHandler, ComparisonOutput, ComparisonConfig, ComparisonInput, RunResult, SideResult, ComparisonResult } from './lib/comparison-runner';
+export { NoOpAuthValidator } from './lib/auth-validator';
+export type { IAuthValidator, PermissionRequest, PermissionResult, AgentTrust } from './lib/auth-validator';
+export { BlackboardValidator, QualityGateAgent, validateJsonSchema } from './lib/blackboard-validator';
+export type { JsonSchema } from './lib/blackboard-validator';
 export type { ValidationResult, ValidationIssue, ValidationConfig, QualityGateResult, GateDecision, AIReviewCallback, CustomValidationRule, } from './lib/blackboard-validator';
 export { AdapterRegistry } from './adapters/adapter-registry';
 export type { AdapterFactory } from './adapters/adapter-registry';
@@ -716,10 +238,12 @@ export { AutoGenAdapter } from './adapters/autogen-adapter';
 export { CrewAIAdapter } from './adapters/crewai-adapter';
 export { MCPAdapter } from './adapters/mcp-adapter';
 export { CustomAdapter } from './adapters/custom-adapter';
-export type { TaskPayload, HandoffMessage, PermissionGrant, SwarmState, AgentStatus, ParallelTask, ParallelExecutionResult, SynthesisStrategy, ResourceProfile, AgentTrustConfig, };
+export { MCPToolConsumer, StdioClientTransport, HttpClientTransport } from './lib/mcp-tool-consumer';
+export type { MCPConsumerOptions, RemoteToolInfo, MCPClientTransport, JsonRpcRequest, JsonRpcResponse, ToolCallResult } from './lib/mcp-tool-consumer';
+export type { TaskPayload, HandoffMessage, PermissionGrant, SwarmState, AgentStatus, TaskRecord, BlackboardEntry, ActiveGrant, ParallelTask, ParallelExecutionResult, SynthesisStrategy, ResourceProfile, AgentTrustConfig, NamedBlackboardOptions, } from './lib/orchestrator-types';
 export type { IAgentAdapter, AgentPayload, AgentContext, AgentResult, AgentInfo, AdapterConfig, AdapterCapabilities, } from './types/agent-adapter';
-export type { OpenClawSkill, SkillContext, SkillResult };
-export type { ConflictResolutionStrategy, AgentPriority, LockedBlackboardOptions };
+export type { OpenClawSkill, SkillContext, SkillResult } from './lib/orchestrator-types';
+export type { ConflictResolutionStrategy, AgentPriority, LockedBlackboardOptions } from './lib/locked-blackboard';
 export { FileBackend, MemoryBackend } from './lib/blackboard-backend';
 export type { BlackboardBackend } from './lib/blackboard-backend';
 export { RedisBackend } from './lib/blackboard-backend-redis';
@@ -735,7 +259,7 @@ export { McpBlackboardBridge, McpBridgeClient, McpBridgeRouter, McpInProcessTran
 export type { McpJsonRpcRequest, McpJsonRpcResponse, McpJsonRpcError, McpListToolsResult, McpCallToolResult, McpContentBlock, McpTransport, McpBlackboardBridgeOptions, } from './lib/mcp-bridge';
 export { Logger, LogLevel } from './lib/logger';
 export type { LogEntry, LogTransport, LoggerConfig } from './lib/logger';
-export { NetworkAIError, IdentityVerificationError, NamespaceViolationError, ValidationError, LockAcquisitionError, ConflictError, AdapterAlreadyRegisteredError, AdapterNotFoundError, AdapterNotInitializedError, ParallelLimitError, TimeoutError, } from './lib/errors';
+export { NetworkAIError, IdentityVerificationError, NamespaceViolationError, ValidationError, LockAcquisitionError, ConflictError, AdapterAlreadyRegisteredError, AdapterNotFoundError, AdapterNotInitializedError, ParallelLimitError, TimeoutError, mapErrorToSkillResult, } from './lib/errors';
 export { JourneyFSM, ToolAuthorizationMatrix, ComplianceMiddleware, ComplianceViolationError, createDeliveryPipelineFSM, WORKFLOW_STATES, } from './lib/fsm-journey';
 export type { WorkflowStateDefinition, StateTransition, TransitionResult, ComplianceCheckResult, JourneyFSMOptions, } from './lib/fsm-journey';
 export { ComplianceMonitor } from './lib/compliance-monitor';
@@ -762,6 +286,12 @@ export { AgentPool, WorkloadPartitioner, StrategyAgent, adaptiveStrategy, } from
 export type { AgentTemplate, ManagedAgent, WorkChunk, StrategyPlan, SystemSnapshot, PoolStatus, StrategyFunction, StrategyEvents, StrategyAgentOptions, } from './lib/strategy-agent';
 export { GoalDecomposer, TeamRunner, runTeam, createLLMPlanner, validateDAG, topologicalLayers, parsePlanJSON, } from './lib/goal-decomposer';
 export type { TaskNode, TaskDAG, TeamAgent, PlannedTask, PlannerFunction, ExecutorFunction, RunTeamOptions, TeamResult, TeamRunnerEvents, } from './lib/goal-decomposer';
+export { TopologyTracker } from './lib/topology';
+export type { AgentNode, AgentNodeStatus, AgentRole, TopologyEdge, EdgeType, TopologyEvent, TopologyEventType, TopologySnapshot, TopologyTrackerEvents, TopologyTrackerOptions, PhaseMilestone, PhaseProgress, AttentionItem, AttentionPanel, TimelineSpan, AgentCluster, TopologyDelta, } from './lib/topology';
+export { DashboardServer } from './lib/dashboard-server';
+export type { DashboardServerOptions } from './lib/dashboard-server';
+export { QuadTree } from './lib/quadtree';
+export type { QTPoint, QTBounds, QTMass } from './lib/quadtree';
 export { BlackboardMCPTools, registerBlackboardTools, BLACKBOARD_TOOL_DEFINITIONS, } from './lib/mcp-blackboard-tools';
 export type { MCPToolDefinition, MCPJsonSchema, BlackboardToolResult, IBlackboard, } from './lib/mcp-blackboard-tools';
 /**
@@ -849,5 +379,19 @@ export { MiniMaxAdapter } from './adapters/minimax-adapter';
 export type { MiniMaxAgentConfig, MiniMaxChatClient } from './adapters/minimax-adapter';
 export { NemoClawAdapter } from './adapters/nemoclaw-adapter';
 export type { NemoClawAgentConfig, OpenShellExecutor, BlueprintAction, BlueprintRunResult, SandboxState, SandboxStatus, NetworkPolicy, PolicyEndpoint, } from './adapters/nemoclaw-adapter';
+export { CopilotAdapter } from './adapters/copilot-adapter';
+export type { CopilotTaskType, CopilotOptions, CopilotConnection } from './adapters/copilot-adapter';
+export { LangGraphAdapter } from './adapters/langgraph-adapter';
+export type { LangGraphRunnable, LangGraphStreamable, LangGraphAgentConfig } from './adapters/langgraph-adapter';
+export { AnthropicComputerUseAdapter } from './adapters/anthropic-computer-use-adapter';
+export type { ComputerAction, ComputerToolCall, ComputerToolResult, ComputerActionHandler, AnthropicMessagesClient, ComputerUseAgentConfig } from './adapters/anthropic-computer-use-adapter';
+export { OpenAIAgentsAdapter } from './adapters/openai-agents-adapter';
+export type { OAIAgentTool, OAIAgentRunResult, OAIAgentRunner, OAIAgentsConfig } from './adapters/openai-agents-adapter';
+export { VertexAIAdapter } from './adapters/vertex-ai-adapter';
+export type { VertexFunctionDeclaration, VertexContentPart, VertexGenerateResponse, VertexGenerativeClient, VertexFunctionExecutor, VertexAIAgentConfig } from './adapters/vertex-ai-adapter';
+export { PydanticAIAdapter } from './adapters/pydantic-ai-adapter';
+export type { PydanticAIRunResult, PydanticAIRunner, PydanticAIHttpConfig, PydanticAIAgentConfig } from './adapters/pydantic-ai-adapter';
+export { BrowserAgentAdapter } from './adapters/browser-agent-adapter';
+export type { BrowserMode, BrowserStep, BrowserActionResult, BrowserDriver, BrowserAgentConfig } from './adapters/browser-agent-adapter';
 export type { StreamingChunk, IStreamingAdapter, StreamCollector } from './types/streaming-adapter';
 //# sourceMappingURL=index.d.ts.map