@mxf-dev/core 1.0.0

package/dist/constants/EnhancementConstants.d.ts

@@ -0,0 +1,352 @@
+/**
+ * Enhancement Constants for MXF P6-P9 Features
+ *
+ * Constants for LSP, Workflow System, Memory Strata, and Decentralization features.
+ */
+/**
+ * LSP Constants
+ */
+export declare const LSP_CONSTANTS: {
+    /** Default LSP server configurations */
+    readonly SERVERS: {
+        readonly TYPESCRIPT: {
+            readonly COMMAND: "typescript-language-server";
+            readonly ARGS: readonly ["--stdio"];
+            readonly DEFAULT_MAX_MEMORY: 4096;
+        };
+        readonly PYTHON: {
+            readonly COMMAND: "pylsp";
+            readonly ARGS: readonly [];
+            readonly TYPE: "pylsp";
+        };
+        readonly GO: {
+            readonly COMMAND: "gopls";
+            readonly ARGS: readonly [];
+        };
+    };
+    /** Document management defaults */
+    readonly DOCUMENT: {
+        readonly SYNC_MODE: "incremental";
+        readonly IDLE_CLOSE_TIMEOUT: 300000;
+        readonly MAX_OPEN_DOCUMENTS: 50;
+    };
+    /** Lifecycle defaults */
+    readonly LIFECYCLE: {
+        readonly HEALTH_CHECK_INTERVAL: 30000;
+        readonly STARTUP_TIMEOUT: 30000;
+        readonly SHUTDOWN_TIMEOUT: 10000;
+        readonly MAX_INSTANCES: 10;
+        readonly RESTART_POLICY: {
+            readonly MAX_RETRIES: 3;
+            readonly BACKOFF_MULTIPLIER: 2;
+            readonly INITIAL_DELAY: 1000;
+            readonly MAX_DELAY: 30000;
+        };
+    };
+    /** Cache defaults */
+    readonly CACHE: {
+        readonly DIAGNOSTICS_TTL: 5000;
+        readonly SYMBOLS_TTL: 60000;
+        readonly COMPLETIONS_TTL: 1000;
+    };
+    /** Timeouts for LSP operations */
+    readonly TIMEOUTS: {
+        readonly GOTO_DEFINITION: 30000;
+        readonly FIND_REFERENCES: 60000;
+        readonly DIAGNOSTICS: 10000;
+        readonly COMPLETIONS: 5000;
+        readonly HOVER: 5000;
+        readonly RENAME: 60000;
+        readonly DOCUMENT_SYMBOLS: 10000;
+        readonly WORKSPACE_SYMBOLS: 30000;
+    };
+    /** Position indexing */
+    readonly POSITION: {
+        /** LSP uses 0-indexed positions */
+        readonly LSP_INDEXED: 0;
+        /** MXF tools use 1-indexed positions */
+        readonly TOOL_INDEXED: 1;
+    };
+};
+/**
+ * Workflow System Constants
+ */
+export declare const WORKFLOW_CONSTANTS: {
+    /** Workflow execution defaults */
+    readonly EXECUTION: {
+        readonly DEFAULT_TIMEOUT: 300000;
+        readonly MAX_PARALLEL_STEPS: 10;
+        readonly MAX_WORKFLOW_DURATION: 3600000;
+    };
+    /** Retry defaults */
+    readonly RETRY: {
+        readonly DEFAULT_MAX_ATTEMPTS: 3;
+        readonly DEFAULT_INITIAL_DELAY: 1000;
+        readonly DEFAULT_BACKOFF_MULTIPLIER: 2;
+        readonly DEFAULT_MAX_DELAY: 30000;
+    };
+    /** Loop limits */
+    readonly LOOP: {
+        readonly DEFAULT_MAX_ITERATIONS: 100;
+        readonly SAFETY_MAX_ITERATIONS: 1000;
+    };
+    /** Wait limits */
+    readonly WAIT: {
+        readonly DEFAULT_TIMEOUT: 60000;
+        readonly MAX_WAIT_DURATION: 3600000;
+    };
+    /** Step types */
+    readonly STEP_TYPES: {
+        readonly TOOL_EXECUTION: "tool_execution";
+        readonly LLM_CALL: "llm_call";
+        readonly DECISION: "decision";
+        readonly LOOP: "loop";
+        readonly PARALLEL: "parallel";
+        readonly SUBPROCESS: "subprocess";
+        readonly WAIT: "wait";
+        readonly VALIDATION: "validation";
+        readonly CUSTOM: "custom";
+    };
+    /** Workflow statuses */
+    readonly STATUSES: {
+        readonly PENDING: "pending";
+        readonly RUNNING: "running";
+        readonly PAUSED: "paused";
+        readonly COMPLETED: "completed";
+        readonly FAILED: "failed";
+        readonly CANCELLED: "cancelled";
+    };
+};
+/**
+ * Memory Strata Constants
+ */
+export declare const MEMORY_STRATA_CONSTANTS: {
+    /** Stratum names */
+    readonly STRATA: {
+        readonly WORKING: "working";
+        readonly SHORT_TERM: "short_term";
+        readonly LONG_TERM: "long_term";
+        readonly EPISODIC: "episodic";
+        readonly SEMANTIC: "semantic";
+    };
+    /** Default stratum configurations */
+    readonly DEFAULTS: {
+        readonly WORKING: {
+            readonly MAX_ENTRIES: 100;
+            readonly TTL: 3600000;
+        };
+        readonly SHORT_TERM: {
+            readonly MAX_ENTRIES: 500;
+            readonly TTL: 86400000;
+            readonly CONSOLIDATION_THRESHOLD: 50;
+        };
+        readonly LONG_TERM: {
+            readonly MAX_ENTRIES_PER_AGENT: 10000;
+            readonly MIN_IMPORTANCE: 3;
+            readonly ARCHIVAL_AGE: 2592000000;
+        };
+        readonly EPISODIC: {
+            readonly MAX_EPISODES_PER_AGENT: 1000;
+            readonly EPISODE_DURATION: 3600000;
+        };
+        readonly SEMANTIC: {
+            readonly MAX_CONCEPTS_PER_AGENT: 5000;
+            readonly MIN_CONFIDENCE: 0.7;
+        };
+    };
+    /** Surprise detection */
+    readonly SURPRISE: {
+        readonly DEFAULT_THRESHOLD: 0.7;
+        readonly ANALYSIS_WINDOW: 100;
+        readonly TYPES: {
+            readonly SCHEMA_VIOLATION: "schema_violation";
+            readonly PREDICTION_FAILURE: "prediction_failure";
+            readonly ANOMALY: "anomaly";
+            readonly NOVEL_PATTERN: "novel_pattern";
+            readonly CONTEXT_MISMATCH: "context_mismatch";
+            readonly PERFORMANCE_DEVIATION: "performance_deviation";
+            readonly UNEXPECTED_ERROR: "unexpected_error";
+            readonly UNEXPECTED_SUCCESS: "unexpected_success";
+        };
+    };
+    /** Consolidation */
+    readonly CONSOLIDATION: {
+        readonly INTERVAL: 3600000;
+        readonly SIMILARITY_THRESHOLD: 0.8;
+        readonly TYPES: {
+            readonly MERGE: "merge";
+            readonly SUMMARIZE: "summarize";
+            readonly ABSTRACT: "abstract";
+            readonly PROMOTE: "promote";
+            readonly DEMOTE: "demote";
+            readonly ARCHIVE: "archive";
+        };
+    };
+    /** Pattern detection */
+    readonly PATTERNS: {
+        readonly MIN_LENGTH: 3;
+        readonly MIN_CONFIDENCE: 0.6;
+        readonly ANALYSIS_INTERVAL: 7200000;
+    };
+    /** Importance levels */
+    readonly IMPORTANCE: {
+        readonly CRITICAL: 5;
+        readonly HIGH: 4;
+        readonly MEDIUM: 3;
+        readonly LOW: 2;
+        readonly TRIVIAL: 1;
+    };
+};
+/**
+ * Decentralization Constants
+ */
+export declare const DECENTRALIZATION_CONSTANTS: {
+    /** Network defaults */
+    readonly NETWORK: {
+        readonly DEFAULT_PORT: 7000;
+        readonly MAX_CONNECTIONS: 50;
+        readonly MAX_MESSAGE_SIZE: 1048576;
+    };
+    /** Discovery defaults */
+    readonly DISCOVERY: {
+        readonly INTERVAL: 60000;
+        readonly METHODS: {
+            readonly BOOTSTRAP: "bootstrap";
+            readonly MULTICAST: "multicast";
+            readonly DNS: "dns";
+            readonly TRACKER: "tracker";
+            readonly GOSSIP: "gossip";
+            readonly MANUAL: "manual";
+        };
+    };
+    /** Gossip protocol */
+    readonly GOSSIP: {
+        readonly INTERVAL: 5000;
+        readonly FANOUT: 3;
+        readonly MAX_HOPS: 7;
+        readonly MESSAGE_TTL: 300000;
+        readonly TYPES: {
+            readonly PEER_LIST: "peer_list";
+            readonly STATE_UPDATE: "state_update";
+            readonly EVENT: "event";
+            readonly RUMOR: "rumor";
+            readonly ALERT: "alert";
+            readonly HEARTBEAT: "heartbeat";
+        };
+    };
+    /** DHT (Distributed Hash Table) */
+    readonly DHT: {
+        readonly REPLICATION_FACTOR: 3;
+        readonly BUCKET_SIZE: 20;
+        readonly REFRESH_INTERVAL: 3600000;
+    };
+    /** Routing */
+    readonly ROUTING: {
+        readonly UPDATE_INTERVAL: 30000;
+        readonly ROUTE_TIMEOUT: 300000;
+        readonly ALGORITHMS: {
+            readonly FLOODING: "flooding";
+            readonly DISTANCE_VECTOR: "distance_vector";
+            readonly LINK_STATE: "link_state";
+            readonly DHT_BASED: "dht_based";
+        };
+    };
+    /** Consensus */
+    readonly CONSENSUS: {
+        readonly QUORUM_SIZE: 0.67;
+        readonly PROPOSAL_TIMEOUT: 30000;
+        readonly PROTOCOLS: {
+            readonly RAFT: "raft";
+            readonly PAXOS: "paxos";
+            readonly PBFT: "pbft";
+            readonly GOSSIP_BASED: "gossip_based";
+            readonly CRDT: "crdt";
+        };
+    };
+    /** Health monitoring */
+    readonly HEALTH: {
+        readonly PING_INTERVAL: 10000;
+        readonly PING_TIMEOUT: 5000;
+        readonly UNHEALTHY_THRESHOLD: 3;
+        readonly BAN_DURATION: 3600000;
+    };
+    /** Security */
+    readonly SECURITY: {
+        readonly MIN_REPUTATION: 0.5;
+        readonly TRUST_MODELS: {
+            readonly FULL_TRUST: "full_trust";
+            readonly WEB_OF_TRUST: "web_of_trust";
+            readonly REPUTATION_BASED: "reputation_based";
+        };
+    };
+    /** Message priorities */
+    readonly MESSAGE_PRIORITY: {
+        readonly CRITICAL: 5;
+        readonly HIGH: 4;
+        readonly NORMAL: 3;
+        readonly LOW: 2;
+        readonly BACKGROUND: 1;
+    };
+    /** Peer statuses */
+    readonly PEER_STATUS: {
+        readonly CONNECTED: "connected";
+        readonly CONNECTING: "connecting";
+        readonly DISCONNECTED: "disconnected";
+        readonly ERROR: "error";
+        readonly BANNED: "banned";
+    };
+};
+/**
+ * Event names for new features
+ */
+export declare const ENHANCEMENT_EVENTS: {
+    /** LSP events */
+    readonly LSP: {
+        readonly SERVER_STARTED: "lsp:server:started";
+        readonly SERVER_STOPPED: "lsp:server:stopped";
+        readonly SERVER_ERROR: "lsp:server:error";
+        readonly SERVER_HEALTH_CHECK: "lsp:server:health_check";
+        readonly DOCUMENT_OPENED: "lsp:document:opened";
+        readonly DOCUMENT_CLOSED: "lsp:document:closed";
+        readonly OPERATION_COMPLETED: "lsp:operation:completed";
+        readonly OPERATION_FAILED: "lsp:operation:failed";
+    };
+    /** Workflow events */
+    readonly WORKFLOW: {
+        readonly CREATED: "workflow:created";
+        readonly STARTED: "workflow:started";
+        readonly STEP_STARTED: "workflow:step:started";
+        readonly STEP_COMPLETED: "workflow:step:completed";
+        readonly STEP_FAILED: "workflow:step:failed";
+        readonly PAUSED: "workflow:paused";
+        readonly RESUMED: "workflow:resumed";
+        readonly COMPLETED: "workflow:completed";
+        readonly FAILED: "workflow:failed";
+        readonly CANCELLED: "workflow:cancelled";
+    };
+    /** Memory Strata events */
+    readonly MEMORY_STRATA: {
+        readonly ENTRY_CREATED: "memory:entry:created";
+        readonly ENTRY_ACCESSED: "memory:entry:accessed";
+        readonly ENTRY_EXPIRED: "memory:entry:expired";
+        readonly SURPRISE_DETECTED: "memory:surprise:detected";
+        readonly CONSOLIDATION_STARTED: "memory:consolidation:started";
+        readonly CONSOLIDATION_COMPLETED: "memory:consolidation:completed";
+        readonly PATTERN_DETECTED: "memory:pattern:detected";
+        readonly TRANSITION: "memory:transition";
+    };
+    /** Decentralization events */
+    readonly DECENTRALIZATION: {
+        readonly PEER_CONNECTED: "p2p:peer:connected";
+        readonly PEER_DISCONNECTED: "p2p:peer:disconnected";
+        readonly PEER_DISCOVERED: "p2p:peer:discovered";
+        readonly MESSAGE_SENT: "p2p:message:sent";
+        readonly MESSAGE_RECEIVED: "p2p:message:received";
+        readonly GOSSIP_PROPAGATED: "p2p:gossip:propagated";
+        readonly CONSENSUS_REACHED: "p2p:consensus:reached";
+        readonly PARTITION_DETECTED: "p2p:partition:detected";
+        readonly PARTITION_HEALED: "p2p:partition:healed";
+        readonly REPUTATION_UPDATED: "p2p:reputation:updated";
+    };
+};
+//# sourceMappingURL=EnhancementConstants.d.ts.map

package/dist/constants/EnhancementConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnhancementConstants.d.ts","sourceRoot":"","sources":["../../src/constants/EnhancementConstants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB,wCAAwC;;;;;;;;;;;;;;;;;IAkBxC,mCAAmC;;;;;;IAOnC,yBAAyB;;;;;;;;;;;;;IAczB,qBAAqB;;;;;;IAOrB,kCAAkC;;;;;;;;;;;IAYlC,wBAAwB;;QAEtB,mCAAmC;;QAEnC,wCAAwC;;;CAGlC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,kCAAkC;;;;;;IAOlC,qBAAqB;;;;;;;IAQrB,kBAAkB;;;;;IAMlB,kBAAkB;;;;;IAMlB,iBAAiB;;;;;;;;;;;;IAajB,wBAAwB;;;;;;;;;CAShB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,oBAAoB;;;;;;;;IASpB,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;IA0BrC,yBAAyB;;;;;;;;;;;;;;;IAgBzB,oBAAoB;;;;;;;;;;;;;IAcpB,wBAAwB;;;;;;IAOxB,wBAAwB;;;;;;;;CAQhB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,0BAA0B;IACrC,uBAAuB;;;;;;IAOvB,yBAAyB;;;;;;;;;;;;IAazB,sBAAsB;;;;;;;;;;;;;;;IAgBtB,mCAAmC;;;;;;IAOnC,cAAc;;;;;;;;;;;IAYd,gBAAgB;;;;;;;;;;;;IAahB,wBAAwB;;;;;;;IAQxB,eAAe;;;;;;;;;IAUf,yBAAyB;;;;;;;;IASzB,oBAAoB;;;;;;;;CAQZ,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,iBAAiB;;;;;;;;;;;IAYjB,sBAAsB;;;;;;;;;;;;;IActB,2BAA2B;;;;;;;;;;;IAY3B,8BAA8B;;;;;;;;;;;;;CAatB,CAAC"}

package/dist/constants/EnhancementConstants.js

@@ -0,0 +1,352 @@
+/**
+ * Enhancement Constants for MXF P6-P9 Features
+ *
+ * Constants for LSP, Workflow System, Memory Strata, and Decentralization features.
+ */
+/**
+ * LSP Constants
+ */
+export const LSP_CONSTANTS = {
+    /** Default LSP server configurations */
+    SERVERS: {
+        TYPESCRIPT: {
+            COMMAND: 'typescript-language-server',
+            ARGS: ['--stdio'],
+            DEFAULT_MAX_MEMORY: 4096, // MB
+        },
+        PYTHON: {
+            COMMAND: 'pylsp',
+            ARGS: [],
+            TYPE: 'pylsp',
+        },
+        GO: {
+            COMMAND: 'gopls',
+            ARGS: [],
+        },
+    },
+    /** Document management defaults */
+    DOCUMENT: {
+        SYNC_MODE: 'incremental',
+        IDLE_CLOSE_TIMEOUT: 300000, // 5 minutes
+        MAX_OPEN_DOCUMENTS: 50,
+    },
+    /** Lifecycle defaults */
+    LIFECYCLE: {
+        HEALTH_CHECK_INTERVAL: 30000, // 30 seconds
+        STARTUP_TIMEOUT: 30000, // 30 seconds
+        SHUTDOWN_TIMEOUT: 10000, // 10 seconds
+        MAX_INSTANCES: 10,
+        RESTART_POLICY: {
+            MAX_RETRIES: 3,
+            BACKOFF_MULTIPLIER: 2,
+            INITIAL_DELAY: 1000, // 1 second
+            MAX_DELAY: 30000, // 30 seconds
+        },
+    },
+    /** Cache defaults */
+    CACHE: {
+        DIAGNOSTICS_TTL: 5000, // 5 seconds
+        SYMBOLS_TTL: 60000, // 1 minute
+        COMPLETIONS_TTL: 1000, // 1 second
+    },
+    /** Timeouts for LSP operations */
+    TIMEOUTS: {
+        GOTO_DEFINITION: 30000, // 30 seconds
+        FIND_REFERENCES: 60000, // 1 minute
+        DIAGNOSTICS: 10000, // 10 seconds
+        COMPLETIONS: 5000, // 5 seconds
+        HOVER: 5000, // 5 seconds
+        RENAME: 60000, // 1 minute
+        DOCUMENT_SYMBOLS: 10000, // 10 seconds
+        WORKSPACE_SYMBOLS: 30000, // 30 seconds
+    },
+    /** Position indexing */
+    POSITION: {
+        /** LSP uses 0-indexed positions */
+        LSP_INDEXED: 0,
+        /** MXF tools use 1-indexed positions */
+        TOOL_INDEXED: 1,
+    },
+};
+/**
+ * Workflow System Constants
+ */
+export const WORKFLOW_CONSTANTS = {
+    /** Workflow execution defaults */
+    EXECUTION: {
+        DEFAULT_TIMEOUT: 300000, // 5 minutes
+        MAX_PARALLEL_STEPS: 10,
+        MAX_WORKFLOW_DURATION: 3600000, // 1 hour
+    },
+    /** Retry defaults */
+    RETRY: {
+        DEFAULT_MAX_ATTEMPTS: 3,
+        DEFAULT_INITIAL_DELAY: 1000, // 1 second
+        DEFAULT_BACKOFF_MULTIPLIER: 2,
+        DEFAULT_MAX_DELAY: 30000, // 30 seconds
+    },
+    /** Loop limits */
+    LOOP: {
+        DEFAULT_MAX_ITERATIONS: 100,
+        SAFETY_MAX_ITERATIONS: 1000,
+    },
+    /** Wait limits */
+    WAIT: {
+        DEFAULT_TIMEOUT: 60000, // 1 minute
+        MAX_WAIT_DURATION: 3600000, // 1 hour
+    },
+    /** Step types */
+    STEP_TYPES: {
+        TOOL_EXECUTION: 'tool_execution',
+        LLM_CALL: 'llm_call',
+        DECISION: 'decision',
+        LOOP: 'loop',
+        PARALLEL: 'parallel',
+        SUBPROCESS: 'subprocess',
+        WAIT: 'wait',
+        VALIDATION: 'validation',
+        CUSTOM: 'custom',
+    },
+    /** Workflow statuses */
+    STATUSES: {
+        PENDING: 'pending',
+        RUNNING: 'running',
+        PAUSED: 'paused',
+        COMPLETED: 'completed',
+        FAILED: 'failed',
+        CANCELLED: 'cancelled',
+    },
+};
+/**
+ * Memory Strata Constants
+ */
+export const MEMORY_STRATA_CONSTANTS = {
+    /** Stratum names */
+    STRATA: {
+        WORKING: 'working',
+        SHORT_TERM: 'short_term',
+        LONG_TERM: 'long_term',
+        EPISODIC: 'episodic',
+        SEMANTIC: 'semantic',
+    },
+    /** Default stratum configurations */
+    DEFAULTS: {
+        WORKING: {
+            MAX_ENTRIES: 100,
+            TTL: 3600000, // 1 hour
+        },
+        SHORT_TERM: {
+            MAX_ENTRIES: 500,
+            TTL: 86400000, // 24 hours
+            CONSOLIDATION_THRESHOLD: 50,
+        },
+        LONG_TERM: {
+            MAX_ENTRIES_PER_AGENT: 10000,
+            MIN_IMPORTANCE: 3, // Medium importance
+            ARCHIVAL_AGE: 2592000000, // 30 days
+        },
+        EPISODIC: {
+            MAX_EPISODES_PER_AGENT: 1000,
+            EPISODE_DURATION: 3600000, // 1 hour
+        },
+        SEMANTIC: {
+            MAX_CONCEPTS_PER_AGENT: 5000,
+            MIN_CONFIDENCE: 0.7,
+        },
+    },
+    /** Surprise detection */
+    SURPRISE: {
+        DEFAULT_THRESHOLD: 0.7, // Surprise score threshold
+        ANALYSIS_WINDOW: 100, // Recent memories to analyze
+        TYPES: {
+            SCHEMA_VIOLATION: 'schema_violation',
+            PREDICTION_FAILURE: 'prediction_failure',
+            ANOMALY: 'anomaly',
+            NOVEL_PATTERN: 'novel_pattern',
+            CONTEXT_MISMATCH: 'context_mismatch',
+            PERFORMANCE_DEVIATION: 'performance_deviation',
+            UNEXPECTED_ERROR: 'unexpected_error',
+            UNEXPECTED_SUCCESS: 'unexpected_success',
+        },
+    },
+    /** Consolidation */
+    CONSOLIDATION: {
+        INTERVAL: 3600000, // 1 hour
+        SIMILARITY_THRESHOLD: 0.8,
+        TYPES: {
+            MERGE: 'merge',
+            SUMMARIZE: 'summarize',
+            ABSTRACT: 'abstract',
+            PROMOTE: 'promote',
+            DEMOTE: 'demote',
+            ARCHIVE: 'archive',
+        },
+    },
+    /** Pattern detection */
+    PATTERNS: {
+        MIN_LENGTH: 3, // Minimum pattern elements
+        MIN_CONFIDENCE: 0.6,
+        ANALYSIS_INTERVAL: 7200000, // 2 hours
+    },
+    /** Importance levels */
+    IMPORTANCE: {
+        CRITICAL: 5,
+        HIGH: 4,
+        MEDIUM: 3,
+        LOW: 2,
+        TRIVIAL: 1,
+    },
+};
+/**
+ * Decentralization Constants
+ */
+export const DECENTRALIZATION_CONSTANTS = {
+    /** Network defaults */
+    NETWORK: {
+        DEFAULT_PORT: 7000,
+        MAX_CONNECTIONS: 50,
+        MAX_MESSAGE_SIZE: 1048576, // 1 MB
+    },
+    /** Discovery defaults */
+    DISCOVERY: {
+        INTERVAL: 60000, // 1 minute
+        METHODS: {
+            BOOTSTRAP: 'bootstrap',
+            MULTICAST: 'multicast',
+            DNS: 'dns',
+            TRACKER: 'tracker',
+            GOSSIP: 'gossip',
+            MANUAL: 'manual',
+        },
+    },
+    /** Gossip protocol */
+    GOSSIP: {
+        INTERVAL: 5000, // 5 seconds
+        FANOUT: 3, // Peers per round
+        MAX_HOPS: 7,
+        MESSAGE_TTL: 300000, // 5 minutes
+        TYPES: {
+            PEER_LIST: 'peer_list',
+            STATE_UPDATE: 'state_update',
+            EVENT: 'event',
+            RUMOR: 'rumor',
+            ALERT: 'alert',
+            HEARTBEAT: 'heartbeat',
+        },
+    },
+    /** DHT (Distributed Hash Table) */
+    DHT: {
+        REPLICATION_FACTOR: 3,
+        BUCKET_SIZE: 20, // k-buckets
+        REFRESH_INTERVAL: 3600000, // 1 hour
+    },
+    /** Routing */
+    ROUTING: {
+        UPDATE_INTERVAL: 30000, // 30 seconds
+        ROUTE_TIMEOUT: 300000, // 5 minutes
+        ALGORITHMS: {
+            FLOODING: 'flooding',
+            DISTANCE_VECTOR: 'distance_vector',
+            LINK_STATE: 'link_state',
+            DHT_BASED: 'dht_based',
+        },
+    },
+    /** Consensus */
+    CONSENSUS: {
+        QUORUM_SIZE: 0.67, // 67% agreement
+        PROPOSAL_TIMEOUT: 30000, // 30 seconds
+        PROTOCOLS: {
+            RAFT: 'raft',
+            PAXOS: 'paxos',
+            PBFT: 'pbft',
+            GOSSIP_BASED: 'gossip_based',
+            CRDT: 'crdt',
+        },
+    },
+    /** Health monitoring */
+    HEALTH: {
+        PING_INTERVAL: 10000, // 10 seconds
+        PING_TIMEOUT: 5000, // 5 seconds
+        UNHEALTHY_THRESHOLD: 3, // Failed pings
+        BAN_DURATION: 3600000, // 1 hour
+    },
+    /** Security */
+    SECURITY: {
+        MIN_REPUTATION: 0.5,
+        TRUST_MODELS: {
+            FULL_TRUST: 'full_trust',
+            WEB_OF_TRUST: 'web_of_trust',
+            REPUTATION_BASED: 'reputation_based',
+        },
+    },
+    /** Message priorities */
+    MESSAGE_PRIORITY: {
+        CRITICAL: 5,
+        HIGH: 4,
+        NORMAL: 3,
+        LOW: 2,
+        BACKGROUND: 1,
+    },
+    /** Peer statuses */
+    PEER_STATUS: {
+        CONNECTED: 'connected',
+        CONNECTING: 'connecting',
+        DISCONNECTED: 'disconnected',
+        ERROR: 'error',
+        BANNED: 'banned',
+    },
+};
+/**
+ * Event names for new features
+ */
+export const ENHANCEMENT_EVENTS = {
+    /** LSP events */
+    LSP: {
+        SERVER_STARTED: 'lsp:server:started',
+        SERVER_STOPPED: 'lsp:server:stopped',
+        SERVER_ERROR: 'lsp:server:error',
+        SERVER_HEALTH_CHECK: 'lsp:server:health_check',
+        DOCUMENT_OPENED: 'lsp:document:opened',
+        DOCUMENT_CLOSED: 'lsp:document:closed',
+        OPERATION_COMPLETED: 'lsp:operation:completed',
+        OPERATION_FAILED: 'lsp:operation:failed',
+    },
+    /** Workflow events */
+    WORKFLOW: {
+        CREATED: 'workflow:created',
+        STARTED: 'workflow:started',
+        STEP_STARTED: 'workflow:step:started',
+        STEP_COMPLETED: 'workflow:step:completed',
+        STEP_FAILED: 'workflow:step:failed',
+        PAUSED: 'workflow:paused',
+        RESUMED: 'workflow:resumed',
+        COMPLETED: 'workflow:completed',
+        FAILED: 'workflow:failed',
+        CANCELLED: 'workflow:cancelled',
+    },
+    /** Memory Strata events */
+    MEMORY_STRATA: {
+        ENTRY_CREATED: 'memory:entry:created',
+        ENTRY_ACCESSED: 'memory:entry:accessed',
+        ENTRY_EXPIRED: 'memory:entry:expired',
+        SURPRISE_DETECTED: 'memory:surprise:detected',
+        CONSOLIDATION_STARTED: 'memory:consolidation:started',
+        CONSOLIDATION_COMPLETED: 'memory:consolidation:completed',
+        PATTERN_DETECTED: 'memory:pattern:detected',
+        TRANSITION: 'memory:transition',
+    },
+    /** Decentralization events */
+    DECENTRALIZATION: {
+        PEER_CONNECTED: 'p2p:peer:connected',
+        PEER_DISCONNECTED: 'p2p:peer:disconnected',
+        PEER_DISCOVERED: 'p2p:peer:discovered',
+        MESSAGE_SENT: 'p2p:message:sent',
+        MESSAGE_RECEIVED: 'p2p:message:received',
+        GOSSIP_PROPAGATED: 'p2p:gossip:propagated',
+        CONSENSUS_REACHED: 'p2p:consensus:reached',
+        PARTITION_DETECTED: 'p2p:partition:detected',
+        PARTITION_HEALED: 'p2p:partition:healed',
+        REPUTATION_UPDATED: 'p2p:reputation:updated',
+    },
+};
+//# sourceMappingURL=EnhancementConstants.js.map