@holoscript/framework 6.0.3

package/dist/agents/index.cjs

@@ -0,0 +1,4790 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agents/index.ts
+var agents_exports = {};
+__export(agents_exports, {
+  AgentManifestBuilder: () => AgentManifestBuilder,
+  AgentRegistry: () => AgentRegistry,
+  AgentWalletRegistry: () => AgentWalletRegistry,
+  BUILTIN_NORMS: () => BUILTIN_NORMS,
+  CapabilityMatcher: () => CapabilityMatcher,
+  CulturalMemory: () => CulturalMemory,
+  DEFAULT_A2A_CONFIG: () => DEFAULT_A2A_CONFIG,
+  DEFAULT_MCP_CONFIG: () => DEFAULT_MCP_CONFIG,
+  DEFAULT_PHASE_TIMINGS: () => DEFAULT_PHASE_TIMINGS,
+  DEFAULT_REALTIME_CONFIG: () => DEFAULT_REALTIME_CONFIG,
+  DEFAULT_REGISTRY_CONFIG: () => DEFAULT_REGISTRY_CONFIG,
+  DEFAULT_SPATIAL_COMM_CONFIG: () => DEFAULT_SPATIAL_COMM_CONFIG,
+  EffectRow: () => EffectRow,
+  FederatedRegistryAdapter: () => FederatedRegistryAdapter,
+  FrameBudgetTracker: () => FrameBudgetTracker,
+  GCounter: () => GCounter,
+  LATENCY_THRESHOLDS: () => LATENCY_THRESHOLDS,
+  LWWRegister: () => LWWRegister,
+  Layer1RealTimeClient: () => Layer1RealTimeClient,
+  Layer2A2AClient: () => Layer2A2AClient,
+  Layer3MCPClient: () => Layer3MCPClient,
+  Layer3MCPServer: () => Layer3MCPServer,
+  NormEngine: () => NormEngine,
+  ORSet: () => ORSet,
+  OrchestratorAgent: () => OrchestratorAgent,
+  PHASE_ORDER: () => PHASE_ORDER,
+  PLATFORM_CAPABILITIES: () => PLATFORM_CAPABILITIES,
+  PROTOCOL_COMPATIBILITY: () => PROTOCOL_COMPATIBILITY,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SPATIAL_MCP_TOOLS: () => SPATIAL_MCP_TOOLS,
+  SkillWorkflowEngine: () => SkillWorkflowEngine,
+  SpatialCommClient: () => SpatialCommClient,
+  TaskDelegationService: () => TaskDelegationService,
+  UDPRealTimeTransport: () => UDPRealTimeTransport,
+  WebRTCRealTimeTransport: () => WebRTCRealTimeTransport,
+  createAgentManifest: () => createManifest,
+  createAgentState: () => createAgentState,
+  createMVCPayload: () => createMVCPayload,
+  criticalMassForChange: () => criticalMassForChange,
+  decodeRealTimeMessage: () => decodeRealTimeMessage,
+  defaultMatcher: () => defaultMatcher,
+  embodimentFor: () => embodimentFor,
+  encodeRealTimeMessage: () => encodeRealTimeMessage,
+  estimatePayloadSize: () => estimatePayloadSize,
+  findAgents: () => findAgents,
+  findBestAgent: () => findBestAgent,
+  getCounter: () => getCounter,
+  getDefaultRegistry: () => getDefaultRegistry,
+  getRegister: () => getRegister,
+  incrementCounter: () => incrementCounter,
+  mergeStates: () => mergeStates,
+  negotiateHandoff: () => negotiateHandoff,
+  platformCategory: () => platformCategory,
+  resetDefaultRegistry: () => resetDefaultRegistry,
+  setRegister: () => setRegister,
+  signOperation: () => signOperation,
+  validateManifest: () => validateManifest,
+  validatePayloadBudget: () => validatePayloadBudget,
+  verifyOperation: () => verifyOperation
+});
+module.exports = __toCommonJS(agents_exports);
+
+// src/agents/AgentTypes.ts
+var PHASE_ORDER = [
+  "INTAKE",
+  "REFLECT",
+  "EXECUTE",
+  "COMPRESS",
+  "REINTAKE",
+  "GROW",
+  "EVOLVE"
+];
+var DEFAULT_PHASE_TIMINGS = {
+  INTAKE: 1e3,
+  REFLECT: 2e3,
+  EXECUTE: 5e3,
+  COMPRESS: 1e3,
+  REINTAKE: 1e3,
+  GROW: 2e3,
+  EVOLVE: 1e3
+};
+
+// src/agents/AgentManifest.ts
+var LATENCY_THRESHOLDS = {
+  instant: 10,
+  fast: 100,
+  medium: 1e3,
+  slow: 1e4,
+  background: Infinity
+};
+var AgentManifestBuilder = class {
+  manifest = {
+    capabilities: [],
+    endpoints: [],
+    trustLevel: "local",
+    status: "unknown"
+  };
+  /**
+   * Set agent identity
+   */
+  identity(id, name, version) {
+    this.manifest.id = id;
+    this.manifest.name = name;
+    this.manifest.version = version;
+    return this;
+  }
+  /**
+   * Set agent description
+   */
+  description(desc) {
+    this.manifest.description = desc;
+    return this;
+  }
+  /**
+   * Set classification
+   */
+  classify(categories, position, section) {
+    this.manifest.categories = categories;
+    this.manifest.position = position;
+    this.manifest.section = section;
+    return this;
+  }
+  /**
+   * Add a capability
+   */
+  addCapability(capability) {
+    this.manifest.capabilities.push(capability);
+    return this;
+  }
+  /**
+   * Add multiple capabilities
+   */
+  addCapabilities(capabilities) {
+    this.manifest.capabilities.push(...capabilities);
+    return this;
+  }
+  /**
+   * Add an endpoint
+   */
+  addEndpoint(endpoint) {
+    this.manifest.endpoints.push(endpoint);
+    return this;
+  }
+  /**
+   * Set spatial scope
+   */
+  spatial(scope) {
+    this.manifest.spatialScope = scope;
+    return this;
+  }
+  /**
+   * Set trust level
+   */
+  trust(level, verification) {
+    this.manifest.trustLevel = level;
+    this.manifest.verification = verification;
+    return this;
+  }
+  /**
+   * Set health check interval
+   */
+  healthCheck(intervalMs) {
+    this.manifest.healthCheckInterval = intervalMs;
+    return this;
+  }
+  /**
+   * Add custom tags
+   */
+  tags(...tags) {
+    this.manifest.tags = [...this.manifest.tags || [], ...tags];
+    return this;
+  }
+  /**
+   * Set metadata
+   */
+  metadata(data) {
+    this.manifest.metadata = { ...this.manifest.metadata, ...data };
+    return this;
+  }
+  /**
+   * Build the manifest
+   */
+  build() {
+    if (!this.manifest.id || !this.manifest.name || !this.manifest.version) {
+      throw new Error("AgentManifest requires id, name, and version");
+    }
+    if (this.manifest.capabilities.length === 0) {
+      throw new Error("AgentManifest requires at least one capability");
+    }
+    if (this.manifest.endpoints.length === 0) {
+      throw new Error("AgentManifest requires at least one endpoint");
+    }
+    const now = Date.now();
+    return {
+      ...this.manifest,
+      registeredAt: now,
+      updatedAt: now,
+      status: "online"
+    };
+  }
+};
+function createManifest() {
+  return new AgentManifestBuilder();
+}
+function validateManifest(manifest) {
+  const errors = [];
+  const warnings = [];
+  if (!manifest.id) errors.push("Missing required field: id");
+  if (!manifest.name) errors.push("Missing required field: name");
+  if (!manifest.version) errors.push("Missing required field: version");
+  if (!manifest.capabilities || manifest.capabilities.length === 0) {
+    errors.push("At least one capability is required");
+  }
+  if (!manifest.endpoints || manifest.endpoints.length === 0) {
+    errors.push("At least one endpoint is required");
+  }
+  manifest.capabilities?.forEach((cap, i) => {
+    if (!cap.type) errors.push(`Capability ${i}: missing type`);
+    if (!cap.domain) errors.push(`Capability ${i}: missing domain`);
+  });
+  manifest.endpoints?.forEach((ep, i) => {
+    if (!ep.protocol) errors.push(`Endpoint ${i}: missing protocol`);
+    if (!ep.address) errors.push(`Endpoint ${i}: missing address`);
+  });
+  if (!manifest.description) {
+    warnings.push("Consider adding a description for better discovery");
+  }
+  if (!manifest.healthCheckInterval) {
+    warnings.push("No health check interval set, agent health may not be tracked");
+  }
+  if (manifest.trustLevel === "untrusted") {
+    warnings.push("Untrusted agents have limited capabilities");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/agents/CapabilityMatcher.ts
+var TRUST_LEVELS = ["local", "verified", "known", "external", "untrusted"];
+function getTrustScore(level) {
+  const index = TRUST_LEVELS.indexOf(level);
+  return index >= 0 ? (TRUST_LEVELS.length - index) / TRUST_LEVELS.length : 0;
+}
+function meetsMinTrust(agentTrust, minTrust) {
+  return TRUST_LEVELS.indexOf(agentTrust) <= TRUST_LEVELS.indexOf(minTrust);
+}
+var LATENCY_ORDER = ["instant", "fast", "medium", "slow", "background"];
+function getLatencyScore(profile) {
+  const index = LATENCY_ORDER.indexOf(profile);
+  return index >= 0 ? (LATENCY_ORDER.length - index) / LATENCY_ORDER.length : 0;
+}
+function meetsMaxLatency(capLatency, maxLatency) {
+  if (!capLatency) return true;
+  return LATENCY_ORDER.indexOf(capLatency) <= LATENCY_ORDER.indexOf(maxLatency);
+}
+function pointInBounds(point, min, max) {
+  return point.x >= min.x && point.x <= max.x && point.y >= min.y && point.y <= max.y && point.z >= min.z && point.z <= max.z;
+}
+function boundsOverlap(a, b) {
+  return a.min.x <= b.max.x && a.max.x >= b.min.x && a.min.y <= b.max.y && a.max.y >= b.min.y && a.min.z <= b.max.z && a.max.z >= b.min.z;
+}
+function matchesSpatialQuery(scope, query) {
+  if (scope?.global) return true;
+  if (!scope) return query.requireGlobal !== true;
+  if (query.point && scope.bounds) {
+    if (!pointInBounds(query.point, scope.bounds.min, scope.bounds.max)) {
+      return false;
+    }
+  }
+  if (query.point && scope.radius) {
+    const dx = query.point.x - scope.radius.center.x;
+    const dy = query.point.y - scope.radius.center.y;
+    const dz = query.point.z - scope.radius.center.z;
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (distance > scope.radius.distance) return false;
+  }
+  if (query.scene && scope.scene && scope.scene !== query.scene) {
+    return false;
+  }
+  if (query.nodes && scope.nodes) {
+    const hasOverlap = query.nodes.some((n) => scope.nodes.includes(n));
+    if (!hasOverlap) return false;
+  }
+  if (query.overlaps && scope.bounds) {
+    if (!boundsOverlap(scope.bounds, query.overlaps)) {
+      return false;
+    }
+  }
+  return true;
+}
+var CapabilityMatcher = class {
+  /**
+   * Check if a capability matches the query
+   */
+  matchCapability(capability, query) {
+    const matchedCriteria = [];
+    let score = 0;
+    let criteriaCount = 0;
+    if (query.type) {
+      criteriaCount++;
+      const types = Array.isArray(query.type) ? query.type : [query.type];
+      if (types.includes(capability.type)) {
+        matchedCriteria.push("type");
+        score += 1;
+      } else {
+        return null;
+      }
+    }
+    if (query.domain) {
+      criteriaCount++;
+      const domains = Array.isArray(query.domain) ? query.domain : [query.domain];
+      if (domains.includes(capability.domain)) {
+        matchedCriteria.push("domain");
+        score += 1;
+      } else {
+        return null;
+      }
+    }
+    if (query.maxLatency && capability.latency) {
+      criteriaCount++;
+      if (meetsMaxLatency(capability.latency, query.maxLatency)) {
+        matchedCriteria.push("latency");
+        score += getLatencyScore(capability.latency);
+      } else {
+        return null;
+      }
+    }
+    if (capability.available === false) {
+      return null;
+    }
+    if (criteriaCount > 0 && matchedCriteria.length === 0) {
+      return null;
+    }
+    const normalizedScore = criteriaCount > 0 ? score / criteriaCount : 1;
+    const priorityBonus = (capability.priority || 0) / 100;
+    return {
+      capability,
+      score: Math.min(normalizedScore + priorityBonus, 1),
+      matchedCriteria
+    };
+  }
+  /**
+   * Check if an agent matches the query
+   */
+  matchAgent(manifest, query) {
+    const reasons = [];
+    if (!query.includeOffline && manifest.status === "offline") {
+      return null;
+    }
+    if (query.minTrust && !meetsMinTrust(manifest.trustLevel, query.minTrust)) {
+      return null;
+    }
+    if (query.spatial && !matchesSpatialQuery(manifest.spatialScope, query.spatial)) {
+      return null;
+    }
+    if (query.tags && query.tags.length > 0) {
+      const agentTags = manifest.tags || [];
+      const hasAllTags = query.tags.every((t) => agentTags.includes(t));
+      if (!hasAllTags) {
+        return null;
+      }
+      reasons.push("tags matched");
+    }
+    const capabilityMatches = [];
+    for (const capability of manifest.capabilities) {
+      const match = this.matchCapability(capability, query);
+      if (match) {
+        capabilityMatches.push(match);
+      }
+    }
+    if (capabilityMatches.length === 0) {
+      return null;
+    }
+    const avgCapabilityScore = capabilityMatches.reduce((sum, m) => sum + m.score, 0) / capabilityMatches.length;
+    const trustScore = getTrustScore(manifest.trustLevel);
+    const overallScore = avgCapabilityScore * 0.7 + trustScore * 0.3;
+    reasons.push(`${capabilityMatches.length} capability match(es)`);
+    reasons.push(`trust: ${manifest.trustLevel}`);
+    if (manifest.status === "online") {
+      reasons.push("online");
+    }
+    return {
+      manifest,
+      score: overallScore,
+      capabilities: capabilityMatches,
+      reasons
+    };
+  }
+  /**
+   * Find all matching agents from a list
+   */
+  findMatches(manifests, query) {
+    const matches = [];
+    for (const manifest of manifests) {
+      const match = this.matchAgent(manifest, query);
+      if (match) {
+        matches.push(match);
+      }
+    }
+    this.sortMatches(matches, query.sortBy || "score", query.sortOrder || "desc");
+    if (query.limit && query.limit > 0) {
+      return matches.slice(0, query.limit);
+    }
+    return matches;
+  }
+  /**
+   * Find the best matching agent
+   */
+  findBest(manifests, query) {
+    const matches = this.findMatches(manifests, { ...query, limit: 1 });
+    return matches.length > 0 ? matches[0] : null;
+  }
+  /**
+   * Sort matches by criteria
+   */
+  sortMatches(matches, sortBy, sortOrder) {
+    const multiplier = sortOrder === "asc" ? 1 : -1;
+    matches.sort((a, b) => {
+      switch (sortBy) {
+        case "latency": {
+          const aLatency = this.getFastestLatency(a.capabilities);
+          const bLatency = this.getFastestLatency(b.capabilities);
+          return multiplier * (LATENCY_ORDER.indexOf(aLatency) - LATENCY_ORDER.indexOf(bLatency));
+        }
+        case "trust":
+          return multiplier * (TRUST_LEVELS.indexOf(a.manifest.trustLevel) - TRUST_LEVELS.indexOf(b.manifest.trustLevel));
+        case "priority": {
+          const aPriority = this.getHighestPriority(a.capabilities);
+          const bPriority = this.getHighestPriority(b.capabilities);
+          return multiplier * (bPriority - aPriority);
+        }
+        case "name":
+          return multiplier * a.manifest.name.localeCompare(b.manifest.name);
+        case "score":
+        default:
+          return multiplier * (a.score - b.score);
+      }
+    });
+  }
+  getFastestLatency(capabilities) {
+    let fastest = "background";
+    for (const cap of capabilities) {
+      if (cap.capability.latency) {
+        const idx = LATENCY_ORDER.indexOf(cap.capability.latency);
+        if (idx < LATENCY_ORDER.indexOf(fastest)) {
+          fastest = cap.capability.latency;
+        }
+      }
+    }
+    return fastest;
+  }
+  getHighestPriority(capabilities) {
+    return Math.max(...capabilities.map((c) => c.capability.priority || 0));
+  }
+};
+var defaultMatcher = new CapabilityMatcher();
+function findAgents(manifests, query) {
+  return defaultMatcher.findMatches(manifests, query);
+}
+function findBestAgent(manifests, query) {
+  return defaultMatcher.findBest(manifests, query);
+}
+
+// src/agents/AgentRegistry.ts
+var import_events = require("events");
+var DEFAULT_REGISTRY_CONFIG = {
+  mode: "central",
+  defaultTTL: 3e5,
+  // 5 minutes
+  healthCheckInterval: 1e4,
+  // 10 seconds
+  offlineThreshold: 3e4,
+  // 30 seconds
+  autoCleanup: true,
+  cleanupInterval: 6e4,
+  // 1 minute
+  maxAgents: 1e3,
+  minTrustForRegistration: "external"
+};
+var AgentRegistry = class extends import_events.EventEmitter {
+  agents = /* @__PURE__ */ new Map();
+  matcher = new CapabilityMatcher();
+  config;
+  healthCheckTimer;
+  cleanupTimer;
+  isShuttingDown = false;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_REGISTRY_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // LIFECYCLE
+  // ==========================================================================
+  /**
+   * Start the registry (begins health checks and cleanup)
+   */
+  start() {
+    if (this.isShuttingDown) {
+      throw new Error("Registry is shutting down");
+    }
+    this.healthCheckTimer = setInterval(() => {
+      this.performHealthCheck();
+    }, this.config.healthCheckInterval);
+    if (this.config.autoCleanup) {
+      this.cleanupTimer = setInterval(() => {
+        this.cleanup();
+      }, this.config.cleanupInterval);
+    }
+  }
+  /**
+   * Stop the registry
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+  /**
+   * Clear all agents and reset
+   */
+  clear() {
+    this.agents.clear();
+  }
+  // ==========================================================================
+  // REGISTRATION
+  // ==========================================================================
+  /**
+   * Register an agent
+   */
+  async register(manifest) {
+    if (this.isShuttingDown) {
+      throw new Error("Registry is shutting down");
+    }
+    const validation = validateManifest(manifest);
+    if (!validation.valid) {
+      throw new Error(`Invalid manifest: ${validation.errors.join(", ")}`);
+    }
+    const trustLevels = ["local", "verified", "known", "external", "untrusted"];
+    const minTrustIndex = trustLevels.indexOf(this.config.minTrustForRegistration);
+    const agentTrustIndex = trustLevels.indexOf(manifest.trustLevel);
+    if (agentTrustIndex > minTrustIndex) {
+      throw new Error(
+        `Trust level ${manifest.trustLevel} does not meet minimum ${this.config.minTrustForRegistration}`
+      );
+    }
+    if (this.agents.size >= this.config.maxAgents && !this.agents.has(manifest.id)) {
+      throw new Error(`Registry full: maximum ${this.config.maxAgents} agents`);
+    }
+    const now = Date.now();
+    const entry = {
+      manifest: {
+        ...manifest,
+        registeredAt: now,
+        updatedAt: now,
+        lastHeartbeat: now,
+        status: "online"
+      },
+      registeredAt: now,
+      lastHeartbeat: now,
+      heartbeatCount: 0,
+      missedHeartbeats: 0,
+      ttl: manifest.healthCheckInterval || this.config.defaultTTL
+    };
+    const isUpdate = this.agents.has(manifest.id);
+    this.agents.set(manifest.id, entry);
+    if (isUpdate) {
+      this.emit("agent:updated", entry.manifest);
+    } else {
+      this.emit("agent:registered", entry.manifest);
+    }
+  }
+  /**
+   * Deregister an agent
+   */
+  async deregister(agentId) {
+    const entry = this.agents.get(agentId);
+    if (entry) {
+      this.agents.delete(agentId);
+      this.emit("agent:deregistered", agentId, "explicit");
+    }
+  }
+  /**
+   * Update an agent's heartbeat
+   */
+  async heartbeat(agentId) {
+    const entry = this.agents.get(agentId);
+    if (!entry) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    const now = Date.now();
+    const wasOffline = entry.manifest.status === "offline";
+    entry.lastHeartbeat = now;
+    entry.heartbeatCount++;
+    entry.missedHeartbeats = 0;
+    entry.manifest.lastHeartbeat = now;
+    entry.manifest.status = "online";
+    if (wasOffline) {
+      this.emit("agent:online", agentId);
+    }
+  }
+  // ==========================================================================
+  // DISCOVERY
+  // ==========================================================================
+  /**
+   * Discover agents matching a capability query
+   */
+  async discover(query) {
+    const manifests = this.getAllManifests();
+    const matches = this.matcher.findMatches(manifests, query);
+    return matches.map((m) => m.manifest);
+  }
+  /**
+   * Discover agents with full match details
+   */
+  async discoverWithScores(query) {
+    const manifests = this.getAllManifests();
+    return this.matcher.findMatches(manifests, query);
+  }
+  /**
+   * Find the best agent for a query
+   */
+  async findBest(query) {
+    const manifests = this.getAllManifests();
+    const match = this.matcher.findBest(manifests, query);
+    return match?.manifest || null;
+  }
+  /**
+   * Get a specific agent by ID
+   */
+  get(agentId) {
+    return this.agents.get(agentId)?.manifest;
+  }
+  /**
+   * Check if an agent is registered
+   */
+  has(agentId) {
+    return this.agents.has(agentId);
+  }
+  /**
+   * Get all registered manifests
+   */
+  getAllManifests() {
+    return Array.from(this.agents.values()).map((e) => e.manifest);
+  }
+  /**
+   * Get count of registered agents
+   */
+  get size() {
+    return this.agents.size;
+  }
+  /**
+   * Get count by status
+   */
+  getStatusCounts() {
+    const counts = {
+      online: 0,
+      offline: 0,
+      degraded: 0,
+      unknown: 0
+    };
+    for (const entry of this.agents.values()) {
+      const status = entry.manifest.status || "unknown";
+      counts[status] = (counts[status] || 0) + 1;
+    }
+    return counts;
+  }
+  // ==========================================================================
+  // HEALTH CHECKS
+  // ==========================================================================
+  /**
+   * Perform health check on all agents
+   */
+  performHealthCheck() {
+    const now = Date.now();
+    for (const [agentId, entry] of this.agents) {
+      const timeSinceHeartbeat = now - entry.lastHeartbeat;
+      if (timeSinceHeartbeat > this.config.offlineThreshold) {
+        const wasOnline = entry.manifest.status === "online";
+        entry.manifest.status = "offline";
+        entry.missedHeartbeats++;
+        if (wasOnline) {
+          this.emit("agent:offline", agentId);
+        }
+      } else if (timeSinceHeartbeat > this.config.healthCheckInterval * 2) {
+        const wasOnline = entry.manifest.status === "online";
+        entry.manifest.status = "degraded";
+        if (wasOnline) {
+          this.emit("agent:degraded", agentId);
+        }
+      }
+    }
+  }
+  /**
+   * Cleanup expired/offline agents
+   */
+  cleanup() {
+    const now = Date.now();
+    let removedCount = 0;
+    for (const [agentId, entry] of this.agents) {
+      const _age = now - entry.registeredAt;
+      const timeSinceHeartbeat = now - entry.lastHeartbeat;
+      if (entry.manifest.status === "offline" && timeSinceHeartbeat > entry.ttl) {
+        this.agents.delete(agentId);
+        this.emit("agent:deregistered", agentId, "ttl-expired");
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      this.emit("registry:cleanup", removedCount);
+    }
+  }
+  // ==========================================================================
+  // QUERIES
+  // ==========================================================================
+  /**
+   * Find agents by trust level
+   */
+  findByTrust(trustLevel) {
+    return this.getAllManifests().filter((m) => m.trustLevel === trustLevel);
+  }
+  /**
+   * Find agents by tag
+   */
+  findByTag(tag) {
+    return this.getAllManifests().filter((m) => m.tags?.includes(tag));
+  }
+  /**
+   * Find online agents
+   */
+  findOnline() {
+    return this.getAllManifests().filter((m) => m.status === "online");
+  }
+  /**
+   * Find agents in a scene
+   */
+  findInScene(scene) {
+    return this.getAllManifests().filter(
+      (m) => m.spatialScope?.scene === scene || m.spatialScope?.global
+    );
+  }
+  // ==========================================================================
+  // SERIALIZATION
+  // ==========================================================================
+  /**
+   * Export registry state
+   */
+  export() {
+    return {
+      agents: this.getAllManifests(),
+      config: this.config,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Import registry state
+   */
+  async import(data) {
+    for (const manifest of data.agents) {
+      await this.register(manifest);
+    }
+  }
+};
+var defaultRegistry = null;
+function getDefaultRegistry(config) {
+  if (!defaultRegistry) {
+    defaultRegistry = new AgentRegistry(config);
+  }
+  return defaultRegistry;
+}
+function resetDefaultRegistry() {
+  if (defaultRegistry) {
+    defaultRegistry.stop();
+    defaultRegistry.clear();
+    defaultRegistry = null;
+  }
+}
+
+// src/agents/FederatedRegistryAdapter.ts
+var DEFAULT_CONFIG = {
+  seedUrls: [],
+  pollIntervalMs: 6e4,
+  maxRemoteAgents: 100,
+  trustRemoteAs: "external",
+  timeout: 5e3
+};
+var TAG_TO_TYPE = {
+  parsing: "analyze",
+  validation: "validate",
+  compilation: "transform",
+  generation: "generate",
+  rendering: "render",
+  analysis: "analyze",
+  optimization: "optimize",
+  storage: "store",
+  retrieval: "retrieve",
+  orchestration: "orchestrate",
+  detection: "detect",
+  communication: "communicate"
+};
+var TAG_TO_DOMAIN = {
+  spatial: "spatial",
+  "3d": "spatial",
+  vr: "spatial",
+  ar: "spatial",
+  nlp: "nlp",
+  language: "nlp",
+  vision: "vision",
+  blockchain: "blockchain",
+  web3: "blockchain",
+  audio: "audio",
+  video: "video",
+  physics: "physics",
+  network: "networking",
+  security: "security",
+  trading: "trading",
+  social: "social",
+  gaming: "gaming"
+};
+var FederatedRegistryAdapter = class {
+  registry;
+  config;
+  pollTimer;
+  remoteAgentIds = /* @__PURE__ */ new Set();
+  lastPollResults = /* @__PURE__ */ new Map();
+  constructor(registry, config = {}) {
+    this.registry = registry;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  // ===========================================================================
+  // CORE: FETCH & REGISTER
+  // ===========================================================================
+  /**
+   * Fetch a remote agent card and register it into the local registry.
+   * Returns the converted manifest on success, null on failure.
+   */
+  async fetchAndRegister(url) {
+    try {
+      const card = await this.fetchAgentCard(url);
+      if (!card || !card.id || !card.name) {
+        this.lastPollResults.set(url, { timestamp: Date.now(), success: false });
+        return null;
+      }
+      if (this.remoteAgentIds.size >= this.config.maxRemoteAgents && !this.remoteAgentIds.has(card.id)) {
+        this.lastPollResults.set(url, { timestamp: Date.now(), success: false });
+        return null;
+      }
+      const manifest = this.a2aCardToManifest(card, url);
+      await this.registry.register(manifest);
+      this.remoteAgentIds.add(card.id);
+      this.lastPollResults.set(url, { timestamp: Date.now(), success: true });
+      return manifest;
+    } catch {
+      this.lastPollResults.set(url, { timestamp: Date.now(), success: false });
+      return null;
+    }
+  }
+  /**
+   * Poll all seed URLs once. Returns summary of results.
+   */
+  async pollAll() {
+    let added = 0;
+    let updated = 0;
+    const failed = [];
+    const results = await Promise.allSettled(
+      this.config.seedUrls.map(async (url) => {
+        const wasKnown = this.isKnownUrl(url);
+        const manifest = await this.fetchAndRegister(url);
+        if (manifest) {
+          if (wasKnown) {
+            updated++;
+          } else {
+            added++;
+          }
+        } else {
+          failed.push(url);
+        }
+      })
+    );
+    return { added, updated, failed };
+  }
+  // ===========================================================================
+  // POLLING LIFECYCLE
+  // ===========================================================================
+  /**
+   * Start periodic polling of seed URLs.
+   */
+  startPolling() {
+    if (this.pollTimer) return;
+    this.pollTimer = setInterval(() => {
+      void this.pollAll();
+    }, this.config.pollIntervalMs);
+  }
+  /**
+   * Stop periodic polling.
+   */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = void 0;
+    }
+  }
+  /**
+   * Whether polling is currently active.
+   */
+  get isPolling() {
+    return this.pollTimer !== void 0;
+  }
+  // ===========================================================================
+  // CONVERSION: A2A AgentCard → AgentManifest
+  // ===========================================================================
+  /**
+   * Convert an A2A AgentCard to an AgentManifest.
+   */
+  a2aCardToManifest(card, sourceUrl) {
+    const capabilities = this.extractCapabilities(card);
+    const endpoint = this.extractEndpoint(card);
+    return {
+      id: card.id,
+      name: card.name,
+      version: card.version || "0.0.0",
+      description: card.description,
+      capabilities,
+      endpoints: [endpoint],
+      trustLevel: this.config.trustRemoteAs,
+      tags: ["remote", "a2a", ...card.provider?.organization ? [card.provider.organization] : []],
+      status: "online",
+      metadata: {
+        sourceUrl,
+        a2aEndpoint: card.endpoint,
+        provider: card.provider,
+        a2aCapabilities: card.capabilities,
+        skillCount: card.skills?.length ?? 0
+      }
+    };
+  }
+  // ===========================================================================
+  // FEDERATED DISCOVERY
+  // ===========================================================================
+  /**
+   * Discover agents across local registry + remote seeds.
+   * Ensures all seed URLs are polled before querying.
+   */
+  async discoverFederated(query) {
+    if (this.remoteAgentIds.size === 0 && this.config.seedUrls.length > 0) {
+      await this.pollAll();
+    }
+    return this.registry.discoverWithScores(query);
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Get all remote agent IDs tracked by this adapter.
+   */
+  getRemoteAgentIds() {
+    return Array.from(this.remoteAgentIds);
+  }
+  /**
+   * Get the number of remote agents currently tracked.
+   */
+  get remoteAgentCount() {
+    return this.remoteAgentIds.size;
+  }
+  /**
+   * Get poll results for a specific URL.
+   */
+  getPollResult(url) {
+    return this.lastPollResults.get(url);
+  }
+  /**
+   * Add a seed URL dynamically (does not trigger immediate poll).
+   */
+  addSeedUrl(url) {
+    if (!this.config.seedUrls.includes(url)) {
+      this.config.seedUrls.push(url);
+    }
+  }
+  /**
+   * Remove a seed URL and optionally deregister its agent.
+   */
+  async removeSeedUrl(url, deregister = true) {
+    this.config.seedUrls = this.config.seedUrls.filter((u) => u !== url);
+    if (deregister) {
+      for (const agentId of this.remoteAgentIds) {
+        const manifest = this.registry.get(agentId);
+        if (manifest?.metadata?.sourceUrl === url) {
+          await this.registry.deregister(agentId);
+          this.remoteAgentIds.delete(agentId);
+          break;
+        }
+      }
+    }
+  }
+  // ===========================================================================
+  // PRIVATE HELPERS
+  // ===========================================================================
+  /**
+   * Fetch an agent card from a URL.
+   */
+  async fetchAgentCard(url) {
+    const fetchFn = this.config.fetchFn || globalThis.fetch;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetchFn(url, {
+        signal: controller.signal,
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const data = await response.json();
+      return data;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Extract capabilities from an A2A AgentCard's skills.
+   */
+  extractCapabilities(card) {
+    if (!card.skills || card.skills.length === 0) {
+      return [{ type: "custom", domain: "general", name: card.name }];
+    }
+    const capMap = /* @__PURE__ */ new Map();
+    for (const skill of card.skills) {
+      const tags = skill.tags || [];
+      const type = this.deriveType(tags);
+      const domain = this.deriveDomain(tags);
+      const key = `${type}:${domain}`;
+      if (!capMap.has(key)) {
+        capMap.set(key, {
+          type,
+          domain,
+          name: skill.name,
+          description: skill.description,
+          available: true
+        });
+      }
+    }
+    return Array.from(capMap.values());
+  }
+  /**
+   * Extract endpoint from an A2A AgentCard.
+   */
+  extractEndpoint(card) {
+    const url = card.endpoint || "";
+    const isSecure = url.startsWith("https");
+    return {
+      protocol: isSecure ? "https" : "http",
+      address: url,
+      primary: true,
+      formats: ["json"]
+    };
+  }
+  /**
+   * Derive capability type from A2A skill tags.
+   */
+  deriveType(tags) {
+    for (const tag of tags) {
+      const mapped = TAG_TO_TYPE[tag.toLowerCase()];
+      if (mapped) return mapped;
+    }
+    return "custom";
+  }
+  /**
+   * Derive capability domain from A2A skill tags.
+   */
+  deriveDomain(tags) {
+    for (const tag of tags) {
+      const mapped = TAG_TO_DOMAIN[tag.toLowerCase()];
+      if (mapped) return mapped;
+    }
+    return "general";
+  }
+  /**
+   * Check if a URL has been successfully polled before.
+   */
+  isKnownUrl(url) {
+    const result = this.lastPollResults.get(url);
+    return !!result?.success;
+  }
+};
+
+// src/agents/TaskDelegationService.ts
+var import_crypto = require("crypto");
+var CANONICAL_TASK_BRIDGE_SCHEMA = "holoscript.task-bridge.v1";
+function createCanonicalTaskEnvelope(task) {
+  return {
+    schema: CANONICAL_TASK_BRIDGE_SCHEMA,
+    task
+  };
+}
+function canonicalTaskToA2ASendMessage(envelope, requestId, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    jsonrpc: "2.0",
+    id: requestId,
+    method: "a2a.sendMessage",
+    params: {
+      message: {
+        role: "user",
+        parts: [
+          {
+            type: "data",
+            mimeType: "application/json",
+            data: {
+              schema: envelope.schema,
+              task: envelope.task,
+              skillId: envelope.task.skillId,
+              arguments: envelope.task.input,
+              idempotencyKey: envelope.task.idempotency_key
+            }
+          }
+        ],
+        timestamp
+      }
+    }
+  };
+}
+var DEFAULT_CONFIG2 = {
+  defaultTimeout: 3e4,
+  maxHistory: 1e3
+};
+var TaskDelegationService = class {
+  registry;
+  adapter;
+  config;
+  history = [];
+  traceHistory = [];
+  requestHistory = /* @__PURE__ */ new Map();
+  constructor(registry, adapter, config = {}) {
+    this.registry = registry;
+    this.adapter = adapter;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  // ===========================================================================
+  // DELEGATION
+  // ===========================================================================
+  /**
+   * Delegate a task to a specific agent by ID.
+   */
+  async delegateTo(request) {
+    const startTime = Date.now();
+    const taskId = (0, import_crypto.randomUUID)();
+    const timeout = request.timeout ?? this.config.defaultTimeout;
+    const maxRetries = request.retries ?? 0;
+    this.requestHistory.set(taskId, { ...request, arguments: { ...request.arguments } });
+    this.emitTrace(taskId, "start", {
+      targetAgentId: request.targetAgentId,
+      skillId: request.skillId,
+      timeout,
+      maxRetries
+    });
+    const manifest = this.registry.get(request.targetAgentId);
+    if (!manifest) {
+      const result2 = {
+        taskId,
+        status: "rejected",
+        error: `Agent not found: ${request.targetAgentId}`,
+        durationMs: Date.now() - startTime,
+        delegatedTo: { agentId: request.targetAgentId, endpoint: "unknown" }
+      };
+      this.addToHistory(result2);
+      this.emitTrace(taskId, "rejected", { reason: result2.error });
+      return result2;
+    }
+    const endpoint = this.getPrimaryEndpoint(manifest);
+    const delegatedTo = { agentId: manifest.id, endpoint: endpoint?.address || "local" };
+    let lastError = "";
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      this.emitTrace(taskId, "attempt", { attempt, maxRetries });
+      if (attempt > 0) {
+        const delay = Math.min(1e3 * Math.pow(2, attempt - 1) + Math.random() * 200, 1e4);
+        this.emitTrace(taskId, "retry", { attempt, delayMs: delay });
+        await this.sleep(delay);
+      }
+      try {
+        const result2 = await this.executeWithTimeout(
+          () => this.executeOnAgent(manifest, request.skillId, request.arguments, taskId, attempt),
+          timeout
+        );
+        const delegationResult = {
+          taskId,
+          status: "completed",
+          result: result2,
+          durationMs: Date.now() - startTime,
+          delegatedTo
+        };
+        this.addToHistory(delegationResult);
+        this.emitTrace(taskId, "success", { attempt });
+        return delegationResult;
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+        if (lastError === "TIMEOUT") {
+          const result2 = {
+            taskId,
+            status: "timeout",
+            error: `Delegation timed out after ${timeout}ms`,
+            durationMs: Date.now() - startTime,
+            delegatedTo
+          };
+          this.addToHistory(result2);
+          this.emitTrace(taskId, "timeout", { attempt, timeoutMs: timeout });
+          return result2;
+        }
+        this.emitTrace(taskId, "failure", { attempt, error: lastError });
+      }
+    }
+    const result = {
+      taskId,
+      status: "failed",
+      error: lastError || "Unknown error",
+      durationMs: Date.now() - startTime,
+      delegatedTo
+    };
+    this.addToHistory(result);
+    this.emitTrace(taskId, "failure", { retriesExhausted: true, error: result.error });
+    return result;
+  }
+  /**
+   * Auto-delegate: find the best agent for a capability then delegate.
+   */
+  async autoDelegate(query, skillId, args, options) {
+    const bestAgent = await this.registry.findBest({
+      ...query,
+      includeOffline: false
+    });
+    if (!bestAgent) {
+      const startTime = Date.now();
+      const result = {
+        taskId: (0, import_crypto.randomUUID)(),
+        status: "rejected",
+        error: `No agent found matching query: ${JSON.stringify(query)}`,
+        durationMs: Date.now() - startTime,
+        delegatedTo: { agentId: "none", endpoint: "none" }
+      };
+      this.addToHistory(result);
+      return result;
+    }
+    return this.delegateTo({
+      targetAgentId: bestAgent.id,
+      skillId,
+      arguments: args,
+      timeout: options?.timeout,
+      retries: options?.retries
+    });
+  }
+  /**
+   * Get the status of a previously delegated task from history.
+   */
+  getStatus(taskId) {
+    return this.history.find((r) => r.taskId === taskId);
+  }
+  /**
+   * Get the full delegation history.
+   */
+  getDelegationHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get observability trace events for delegations (optionally filtered by taskId).
+   */
+  getTraceHistory(taskId) {
+    if (!taskId) return [...this.traceHistory];
+    return this.traceHistory.filter((event) => event.taskId === taskId);
+  }
+  /**
+   * Replay a previously delegated task using its original request payload.
+   */
+  async replay(taskId, overrides = {}) {
+    const original = this.requestHistory.get(taskId);
+    if (!original) {
+      throw new Error(`Replay unavailable for taskId: ${taskId}`);
+    }
+    const replayRequest = {
+      ...original,
+      ...overrides,
+      arguments: {
+        ...original.arguments,
+        ...overrides.arguments ?? {}
+      }
+    };
+    this.emitTrace(taskId, "replay_requested", {
+      targetAgentId: replayRequest.targetAgentId,
+      skillId: replayRequest.skillId
+    });
+    try {
+      const replayResult = await this.delegateTo(replayRequest);
+      this.emitTrace(taskId, "replay_completed", { replayTaskId: replayResult.taskId });
+      return replayResult;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emitTrace(taskId, "replay_failed", { error: message });
+      throw error;
+    }
+  }
+  /**
+   * Get delegation stats.
+   */
+  getStats() {
+    return {
+      total: this.history.length,
+      completed: this.history.filter((r) => r.status === "completed").length,
+      failed: this.history.filter((r) => r.status === "failed").length,
+      timeout: this.history.filter((r) => r.status === "timeout").length,
+      rejected: this.history.filter((r) => r.status === "rejected").length
+    };
+  }
+  // ===========================================================================
+  // PRIVATE HELPERS
+  // ===========================================================================
+  /**
+   * Execute a skill on an agent (local or remote).
+   */
+  async executeOnAgent(manifest, skillId, args, taskId, attempt) {
+    const endpoint = this.getPrimaryEndpoint(manifest);
+    if (!endpoint || endpoint.protocol === "local") {
+      if (this.config.localExecutor) {
+        return this.config.localExecutor(skillId, args);
+      }
+      throw new Error(`No local executor configured for agent ${manifest.id}`);
+    }
+    if (endpoint.protocol === "http" || endpoint.protocol === "https") {
+      return this.executeRemote(endpoint.address, skillId, args, taskId, attempt);
+    }
+    throw new Error(`Unsupported endpoint protocol: ${endpoint.protocol}`);
+  }
+  /**
+   * Execute via remote A2A JSON-RPC.
+   */
+  async executeRemote(endpointUrl, skillId, args, taskId, attempt) {
+    const fetchFn = this.config.fetchFn || globalThis.fetch;
+    const idempotencyKey = this.config.idempotencyKeyFactory?.({
+      taskId,
+      attempt,
+      endpointUrl,
+      skillId
+    }) ?? `hs-delegation-${taskId}-attempt-${attempt}`;
+    const envelope = createCanonicalTaskEnvelope({
+      id: taskId,
+      intent: skillId,
+      skillId,
+      input: args,
+      idempotency_key: idempotencyKey,
+      timeout: this.config.defaultTimeout
+    });
+    const jsonRpcRequest = canonicalTaskToA2ASendMessage(envelope, (0, import_crypto.randomUUID)());
+    if (this.config.transportAdapter) {
+      return this.config.transportAdapter.send({
+        endpointUrl,
+        requestBody: jsonRpcRequest,
+        idempotencyKey,
+        fetchFn
+      });
+    }
+    const response = await fetchFn(endpointUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Idempotency-Key": idempotencyKey
+      },
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      throw new Error(`Remote agent returned HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message);
+    }
+    return data.result;
+  }
+  /**
+   * Execute a function with a timeout.
+   */
+  async executeWithTimeout(fn, timeoutMs) {
+    return Promise.race([
+      fn(),
+      new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("TIMEOUT")), timeoutMs);
+      })
+    ]);
+  }
+  /**
+   * Get the primary endpoint from a manifest.
+   */
+  getPrimaryEndpoint(manifest) {
+    return manifest.endpoints.find((e) => e.primary) || manifest.endpoints[0];
+  }
+  /**
+   * Add a result to history with LRU eviction.
+   */
+  addToHistory(result) {
+    this.history.push(result);
+    while (this.history.length > this.config.maxHistory) {
+      const evicted = this.history.shift();
+      if (evicted) {
+        this.requestHistory.delete(evicted.taskId);
+      }
+    }
+  }
+  /**
+   * Emit and store delegation observability traces.
+   */
+  emitTrace(taskId, phase, metadata) {
+    const event = {
+      taskId,
+      phase,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...metadata ? { metadata } : {}
+    };
+    this.traceHistory.push(event);
+    this.config.traceHook?.(event);
+  }
+  /**
+   * Sleep utility.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/agents/SkillWorkflowEngine.ts
+var SkillWorkflowEngine = class {
+  // ===========================================================================
+  // VALIDATION
+  // ===========================================================================
+  /**
+   * Validate a workflow definition.
+   */
+  validate(definition, availableSkills) {
+    const errors = [];
+    const warnings = [];
+    const stepIds = new Set(definition.steps.map((s) => s.id));
+    if (definition.steps.length === 0) {
+      errors.push("Workflow must have at least one step");
+      return { valid: false, errors, warnings, executionPlan: { groups: [], estimatedSteps: 0 } };
+    }
+    if (stepIds.size !== definition.steps.length) {
+      errors.push("Duplicate step IDs detected");
+    }
+    for (const step of definition.steps) {
+      if (!step.id) {
+        errors.push('Step missing required "id" field');
+      }
+      if (!step.skillId) {
+        errors.push(`Step "${step.id}": missing required "skillId" field`);
+      } else if (availableSkills && !availableSkills.includes(step.skillId)) {
+        errors.push(`Step "${step.id}": skill "${step.skillId}" not found in available skills`);
+      }
+      if (step.dependsOn) {
+        for (const depId of step.dependsOn) {
+          if (!stepIds.has(depId)) {
+            errors.push(`Step "${step.id}": dependency "${depId}" does not exist`);
+          }
+        }
+      }
+      for (const [paramName, input] of Object.entries(step.inputs || {})) {
+        if (input.type === "ref") {
+          if (!stepIds.has(input.stepId)) {
+            errors.push(
+              `Step "${step.id}": input "${paramName}" references non-existent step "${input.stepId}"`
+            );
+          }
+          if (!step.dependsOn || !step.dependsOn.includes(input.stepId)) {
+            warnings.push(
+              `Step "${step.id}": input "${paramName}" references step "${input.stepId}" which is not in dependsOn \u2014 adding implicit dependency`
+            );
+          }
+        }
+      }
+      if (step.onError === "fallback" && !step.fallbackSkillId) {
+        warnings.push(`Step "${step.id}": onError='fallback' but no fallbackSkillId specified`);
+      }
+    }
+    const cycleCheck = this.detectCycles(definition.steps);
+    if (cycleCheck) {
+      errors.push(`Cycle detected: ${cycleCheck}`);
+    }
+    const groups = errors.length === 0 ? this.buildExecutionGroups(definition.steps) : [];
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      executionPlan: {
+        groups,
+        estimatedSteps: definition.steps.length
+      }
+    };
+  }
+  // ===========================================================================
+  // EXECUTION
+  // ===========================================================================
+  /**
+   * Execute a workflow using the provided executor function.
+   */
+  async execute(definition, executor, onProgress) {
+    const startTime = Date.now();
+    const stepResults = [];
+    const stepOutputs = /* @__PURE__ */ new Map();
+    const context = definition.context || {};
+    const groups = this.buildExecutionGroups(definition.steps);
+    const stepMap = new Map(definition.steps.map((s) => [s.id, s]));
+    let hasFailed = false;
+    for (const group of groups) {
+      const groupResults = await Promise.all(
+        group.map(async (stepId) => {
+          const step = stepMap.get(stepId);
+          if (hasFailed && step.onError !== "skip") {
+            const result = {
+              stepId,
+              status: "skipped",
+              output: {},
+              durationMs: 0,
+              error: "Skipped due to previous failure"
+            };
+            return result;
+          }
+          onProgress?.(stepId, "starting");
+          const resolvedInputs = this.resolveInputs(step, stepOutputs, context);
+          const stepStart = Date.now();
+          try {
+            const output = await this.executeStep(step, resolvedInputs, executor);
+            stepOutputs.set(stepId, output);
+            onProgress?.(stepId, "completed");
+            return {
+              stepId,
+              status: "completed",
+              output,
+              durationMs: Date.now() - stepStart
+            };
+          } catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            onProgress?.(stepId, "failed");
+            if (step.onError === "skip") {
+              stepOutputs.set(stepId, {});
+              return {
+                stepId,
+                status: "skipped",
+                output: {},
+                durationMs: Date.now() - stepStart,
+                error
+              };
+            }
+            hasFailed = true;
+            return {
+              stepId,
+              status: "failed",
+              output: {},
+              durationMs: Date.now() - stepStart,
+              error
+            };
+          }
+        })
+      );
+      stepResults.push(...groupResults);
+    }
+    const completedCount = stepResults.filter((r) => r.status === "completed").length;
+    let status;
+    if (completedCount === definition.steps.length) {
+      status = "completed";
+    } else if (completedCount > 0) {
+      status = "partial";
+    } else {
+      status = "failed";
+    }
+    return {
+      workflowId: definition.id,
+      status,
+      stepResults,
+      totalDurationMs: Date.now() - startTime
+    };
+  }
+  // ===========================================================================
+  // PRIVATE HELPERS
+  // ===========================================================================
+  /**
+   * Execute a single step with optional fallback.
+   */
+  async executeStep(step, resolvedInputs, executor) {
+    try {
+      if (step.timeout) {
+        return await Promise.race([
+          executor(step.skillId, resolvedInputs),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error(`Step "${step.id}" timed out after ${step.timeout}ms`)),
+              step.timeout
+            )
+          )
+        ]);
+      }
+      return await executor(step.skillId, resolvedInputs);
+    } catch (err) {
+      if (step.onError === "fallback" && step.fallbackSkillId) {
+        return executor(step.fallbackSkillId, resolvedInputs);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Resolve step inputs from literal values, step outputs, or context.
+   */
+  resolveInputs(step, stepOutputs, context) {
+    const resolved = {};
+    for (const [paramName, input] of Object.entries(step.inputs || {})) {
+      switch (input.type) {
+        case "literal":
+          resolved[paramName] = input.value;
+          break;
+        case "ref": {
+          const outputs = stepOutputs.get(input.stepId);
+          resolved[paramName] = outputs?.[input.outputKey];
+          break;
+        }
+        case "context":
+          resolved[paramName] = context[input.key];
+          break;
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Detect cycles in the step dependency graph.
+   * Returns a cycle description string, or null if no cycles.
+   */
+  detectCycles(steps) {
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const adjList = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      const deps = [...step.dependsOn || []];
+      for (const input of Object.values(step.inputs || {})) {
+        if (input.type === "ref" && !deps.includes(input.stepId)) {
+          deps.push(input.stepId);
+        }
+      }
+      adjList.set(step.id, deps);
+    }
+    const dfs = (nodeId, path) => {
+      if (inStack.has(nodeId)) {
+        return path.concat(nodeId).join(" \u2192 ");
+      }
+      if (visited.has(nodeId)) return null;
+      visited.add(nodeId);
+      inStack.add(nodeId);
+      for (const dep of adjList.get(nodeId) || []) {
+        const cycle = dfs(dep, [...path, nodeId]);
+        if (cycle) return cycle;
+      }
+      inStack.delete(nodeId);
+      return null;
+    };
+    for (const step of steps) {
+      if (!visited.has(step.id)) {
+        const cycle = dfs(step.id, []);
+        if (cycle) return cycle;
+      }
+    }
+    return null;
+  }
+  /**
+   * Build parallel execution groups via topological sort.
+   * Each group contains steps that can run concurrently.
+   */
+  buildExecutionGroups(steps) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const dependents = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      if (!inDegree.has(step.id)) inDegree.set(step.id, 0);
+      if (!dependents.has(step.id)) dependents.set(step.id, []);
+      const allDeps = this.getAllDependencies(step);
+      for (const dep of allDeps) {
+        inDegree.set(step.id, (inDegree.get(step.id) || 0) + 1);
+        if (!dependents.has(dep)) dependents.set(dep, []);
+        dependents.get(dep).push(step.id);
+      }
+    }
+    const groups = [];
+    let ready = [...inDegree.entries()].filter(([, deg]) => deg === 0).map(([id]) => id);
+    while (ready.length > 0) {
+      groups.push([...ready]);
+      const nextReady = [];
+      for (const id of ready) {
+        for (const dependent of dependents.get(id) || []) {
+          const newDeg = (inDegree.get(dependent) || 1) - 1;
+          inDegree.set(dependent, newDeg);
+          if (newDeg === 0) {
+            nextReady.push(dependent);
+          }
+        }
+      }
+      ready = nextReady;
+    }
+    return groups;
+  }
+  /**
+   * Get all dependencies for a step (explicit + implicit from ref inputs).
+   */
+  getAllDependencies(step) {
+    const deps = new Set(step.dependsOn || []);
+    for (const input of Object.values(step.inputs || {})) {
+      if (input.type === "ref") {
+        deps.add(input.stepId);
+      }
+    }
+    return Array.from(deps);
+  }
+};
+
+// src/protocol/implementations.ts
+var BaseAgent = class {
+  /**
+   * Execute a complete 7-phase cycle
+   */
+  async runCycle(task, context = {}) {
+    const startedAt = Date.now();
+    const cycleId = `cycle_${startedAt}_${Math.random().toString(36).slice(2, 8)}`;
+    const phases = [];
+    const runPhase = async (phase, fn, input) => {
+      const start = Date.now();
+      try {
+        const result = await fn.call(this, input);
+        result.durationMs = Date.now() - start;
+        phases.push(result);
+        return result;
+      } catch (err) {
+        const failResult = {
+          phase,
+          status: "failure",
+          data: err instanceof Error ? err.message : String(err),
+          durationMs: Date.now() - start,
+          timestamp: Date.now()
+        };
+        phases.push(failResult);
+        return failResult;
+      }
+    };
+    const intakeResult = await runPhase(0 /* INTAKE */, this.intake, { task, ...context });
+    const reflectResult = await runPhase(1 /* REFLECT */, this.reflect, intakeResult.data);
+    const executeResult = await runPhase(2 /* EXECUTE */, this.execute, reflectResult.data);
+    const compressResult = await runPhase(
+      3 /* COMPRESS */,
+      this.compress,
+      executeResult.data
+    );
+    const reintakeResult = await runPhase(
+      4 /* REINTAKE */,
+      this.reintake,
+      compressResult.data
+    );
+    const growResult = await runPhase(5 /* GROW */, this.grow, reintakeResult.data);
+    await runPhase(6 /* EVOLVE */, this.evolve, growResult.data);
+    const failed = phases.some((p) => p.status === "failure");
+    return {
+      cycleId,
+      task,
+      domain: this.identity.domain,
+      phases,
+      status: failed ? "partial" : "complete",
+      totalDurationMs: Date.now() - startedAt,
+      startedAt,
+      completedAt: Date.now()
+    };
+  }
+};
+
+// src/agents/OrchestratorAgent.ts
+var OrchestratorAgent = class extends BaseAgent {
+  identity;
+  registry;
+  adapter;
+  delegator;
+  workflowEngine;
+  config;
+  /** Learned delegation patterns (GROW phase) */
+  patterns = /* @__PURE__ */ new Map();
+  /** Routing preferences (EVOLVE phase) */
+  preferences = /* @__PURE__ */ new Map();
+  // skillId → preferred agentId
+  /** Last discovered agents */
+  lastDiscovery = [];
+  constructor(config) {
+    super();
+    this.config = config;
+    this.identity = {
+      id: `orchestrator-${config.name.toLowerCase().replace(/\s+/g, "-")}`,
+      name: config.name,
+      domain: config.domain,
+      version: "1.0.0",
+      capabilities: ["orchestrate", "delegate", "discover", "workflow"]
+    };
+    this.registry = getDefaultRegistry();
+    this.adapter = new FederatedRegistryAdapter(this.registry, {
+      seedUrls: config.seedUrls || [],
+      pollIntervalMs: config.discoveryIntervalMs || 6e4,
+      fetchFn: config.fetchFn
+    });
+    this.delegator = new TaskDelegationService(this.registry, this.adapter, {
+      localExecutor: config.localExecutor
+    });
+    this.workflowEngine = new SkillWorkflowEngine();
+  }
+  // ===========================================================================
+  // PHASE 0: INTAKE — Discover available agents
+  // ===========================================================================
+  async intake(input) {
+    const startTime = Date.now();
+    const data = input;
+    if (this.config.autoDiscovery !== false) {
+      await this.adapter.pollAll();
+    }
+    const allAgents = this.registry.getAllManifests();
+    const onlineAgents = allAgents.filter((a) => a.status === "online");
+    return {
+      phase: 0 /* INTAKE */,
+      status: "success",
+      data: {
+        task: data.task || "orchestrate",
+        context: data,
+        totalAgents: allAgents.length,
+        onlineAgents: onlineAgents.length,
+        remoteAgents: this.adapter.remoteAgentCount,
+        agents: onlineAgents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          capabilities: a.capabilities.map((c) => `${c.type}:${c.domain}`)
+        }))
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 1: REFLECT — Match capabilities to task requirements
+  // ===========================================================================
+  async reflect(data) {
+    const startTime = Date.now();
+    const intakeData = data;
+    const task = intakeData.task || "";
+    const query = this.taskToQuery(task, intakeData.context);
+    this.lastDiscovery = await this.registry.discoverWithScores(query);
+    const preferredAgents = this.getPreferredAgents(task);
+    return {
+      phase: 1 /* REFLECT */,
+      status: "success",
+      data: {
+        task,
+        matchingAgents: this.lastDiscovery.length,
+        topAgent: this.lastDiscovery[0] ? { id: this.lastDiscovery[0].manifest.id, score: this.lastDiscovery[0].score } : null,
+        preferredAgents,
+        query
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 2: EXECUTE — Delegate tasks or run workflows
+  // ===========================================================================
+  async execute(plan) {
+    const startTime = Date.now();
+    const reflectData = plan;
+    const task = reflectData.task || "";
+    let result = null;
+    let executionType = "none";
+    if (this.lastDiscovery.length > 0) {
+      const bestAgent = this.lastDiscovery[0].manifest;
+      result = await this.delegator.delegateTo({
+        targetAgentId: bestAgent.id,
+        skillId: task,
+        arguments: reflectData.query || {}
+      });
+      executionType = "delegation";
+    }
+    return {
+      phase: 2 /* EXECUTE */,
+      status: "success",
+      data: {
+        executionType,
+        result,
+        task
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 3: COMPRESS — Summarize results
+  // ===========================================================================
+  async compress(results) {
+    const startTime = Date.now();
+    const execData = results;
+    const result = execData.result;
+    return {
+      phase: 3 /* COMPRESS */,
+      status: "success",
+      data: {
+        summary: {
+          executionType: execData.executionType,
+          status: result?.status || "no-execution",
+          task: execData.task,
+          durationMs: result?.durationMs
+        }
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 4: REINTAKE — Check delegation results
+  // ===========================================================================
+  async reintake(compressed) {
+    const startTime = Date.now();
+    const summary = compressed.summary;
+    const stats = this.delegator.getStats();
+    return {
+      phase: 4 /* REINTAKE */,
+      status: "success",
+      data: {
+        delegationStats: stats,
+        lastResult: summary,
+        registryHealth: this.registry.getStatusCounts()
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 5: GROW — Learn patterns from delegations
+  // ===========================================================================
+  async grow(learnings) {
+    const startTime = Date.now();
+    const data = learnings;
+    const lastResult = data.lastResult;
+    if (lastResult?.status === "completed") {
+      const key = `${lastResult.task}`;
+      const existing = this.patterns.get(key);
+      if (existing) {
+        existing.successCount++;
+        existing.avgDurationMs = (existing.avgDurationMs + (lastResult.durationMs || 0)) / 2;
+        existing.lastUsed = Date.now();
+      } else {
+        this.patterns.set(key, {
+          agentId: "unknown",
+          skillId: key,
+          successCount: 1,
+          failureCount: 0,
+          avgDurationMs: lastResult.durationMs || 0,
+          lastUsed: Date.now()
+        });
+      }
+    }
+    return {
+      phase: 5 /* GROW */,
+      status: "success",
+      data: {
+        totalPatterns: this.patterns.size,
+        newPattern: lastResult?.task || null
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // PHASE 6: EVOLVE — Optimize routing preferences
+  // ===========================================================================
+  async evolve(adaptations) {
+    const startTime = Date.now();
+    for (const [skillId, pattern] of this.patterns) {
+      if (pattern.successCount > pattern.failureCount) {
+        this.preferences.set(skillId, pattern.agentId);
+      }
+    }
+    return {
+      phase: 6 /* EVOLVE */,
+      status: "success",
+      data: {
+        totalPreferences: this.preferences.size,
+        totalPatterns: this.patterns.size
+      },
+      durationMs: Date.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  // ===========================================================================
+  // CONVENIENCE METHODS
+  // ===========================================================================
+  /**
+   * Delegate a task without running a full cycle.
+   */
+  async delegateTask(skillId, args) {
+    const preferredAgentId = this.preferences.get(skillId);
+    if (preferredAgentId && this.registry.has(preferredAgentId)) {
+      return this.delegator.delegateTo({
+        targetAgentId: preferredAgentId,
+        skillId,
+        arguments: args
+      });
+    }
+    return this.delegator.autoDelegate({}, skillId, args);
+  }
+  /**
+   * Run a workflow without running a full cycle.
+   */
+  async runWorkflow(definition) {
+    const executor = this.config.localExecutor ? async (skillId, inputs) => {
+      const result = await this.config.localExecutor(skillId, inputs);
+      return typeof result === "object" && result !== null ? result : { result };
+    } : async (skillId, inputs) => {
+      return { skillId, inputs, note: "No executor configured" };
+    };
+    return this.workflowEngine.execute(definition, executor);
+  }
+  /**
+   * Get all discovered agents.
+   */
+  getDiscoveredAgents() {
+    return this.registry.getAllManifests();
+  }
+  /**
+   * Get learned patterns.
+   */
+  getPatterns() {
+    return Array.from(this.patterns.values());
+  }
+  /**
+   * Stop polling and cleanup.
+   */
+  shutdown() {
+    this.adapter.stopPolling();
+  }
+  // ===========================================================================
+  // PRIVATE HELPERS
+  // ===========================================================================
+  taskToQuery(task, context) {
+    const query = { includeOffline: false };
+    if (context?.type) query.type = context.type;
+    if (context?.domain) query.domain = context.domain;
+    if (context?.tags) query.tags = context.tags;
+    return query;
+  }
+  getPreferredAgents(task) {
+    const preferred = [];
+    const agentId = this.preferences.get(task);
+    if (agentId) preferred.push(agentId);
+    return preferred;
+  }
+};
+
+// src/agents/AgentWalletRegistry.ts
+var AgentWalletRegistry = class _AgentWalletRegistry {
+  static instance;
+  wallets = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_AgentWalletRegistry.instance) {
+      _AgentWalletRegistry.instance = new _AgentWalletRegistry();
+    }
+    return _AgentWalletRegistry.instance;
+  }
+  /**
+   * Registers a new agent wallet mapping
+   */
+  registerWallet(agentId, walletAddress, networkId = 8453) {
+    const wallet = {
+      agentId,
+      walletAddress,
+      networkId,
+      balanceThreshold: 1e-3
+      // 0.001 ETH
+    };
+    this.wallets.set(agentId, wallet);
+    return wallet;
+  }
+  /**
+   * Retrieves an agent's registered wallet
+   */
+  getWallet(agentId) {
+    return this.wallets.get(agentId);
+  }
+  /**
+   * Removes an agent's wallet from the registry
+   */
+  unregisterWallet(agentId) {
+    return this.wallets.delete(agentId);
+  }
+  /**
+   * Authorizes an agent transaction using EIP-712 signature fallback
+   * (Placeholder for Coinbase AgentKit KMS signing)
+   */
+  async authorizeTransaction(agentId, payload) {
+    const wallet = this.getWallet(agentId);
+    if (!wallet) {
+      throw new Error(`[AgentWalletRegistry] No wallet registered for agent ${agentId}`);
+    }
+    const mockHash = "0x" + Buffer.from(JSON.stringify(payload)).toString("hex").slice(0, 64);
+    return mockHash;
+  }
+};
+
+// src/agents/AuthenticatedCRDT.ts
+function computeSignature(payload, signer, timestamp) {
+  const data = JSON.stringify({ payload, signer: signer.id, timestamp });
+  let hash = 0;
+  for (let i = 0; i < data.length; i++) {
+    hash = (hash << 5) - hash + data.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function signOperation(payload, signer, scopeTag, timestamp) {
+  return {
+    payload,
+    signer,
+    timestamp,
+    signature: computeSignature(payload, signer, timestamp),
+    scopeTag
+  };
+}
+function verifyOperation(op) {
+  if (op.signer.revoked) return { valid: false, reason: "Signer DID revoked" };
+  if (!op.signer.scope.includes(op.scopeTag) && !op.signer.scope.includes("*")) {
+    return { valid: false, reason: `Signer lacks scope '${op.scopeTag}'` };
+  }
+  const expected = computeSignature(op.payload, op.signer, op.timestamp);
+  if (op.signature !== expected) return { valid: false, reason: "Signature mismatch" };
+  return { valid: true };
+}
+var LWWRegister = class {
+  value;
+  timestamp;
+  lastSigner;
+  history = [];
+  constructor(initialValue) {
+    this.value = initialValue;
+    this.timestamp = 0;
+    this.lastSigner = null;
+  }
+  /** Get current value */
+  get() {
+    return this.value;
+  }
+  /** Get last write timestamp */
+  getTimestamp() {
+    return this.timestamp;
+  }
+  /** Set value with a signed operation */
+  set(op) {
+    const verification = verifyOperation(op);
+    if (!verification.valid) return { accepted: false, reason: verification.reason };
+    if (op.timestamp <= this.timestamp) return { accepted: false, reason: "Stale timestamp" };
+    this.value = op.payload;
+    this.timestamp = op.timestamp;
+    this.lastSigner = op.signer;
+    this.history.push(op);
+    return { accepted: true };
+  }
+  /** Merge with another register (LWW semantics) */
+  merge(other) {
+    if (other.timestamp > this.timestamp) {
+      this.value = other.value;
+      this.timestamp = other.timestamp;
+      this.lastSigner = other.lastSigner;
+    }
+  }
+  /** Get operation history */
+  getHistory() {
+    return [...this.history];
+  }
+};
+var GCounter = class _GCounter {
+  counts = /* @__PURE__ */ new Map();
+  // nodeId → count
+  /** Increment for a specific node */
+  increment(nodeId, amount = 1) {
+    this.counts.set(nodeId, (this.counts.get(nodeId) || 0) + amount);
+  }
+  /** Get the total value */
+  value() {
+    let total = 0;
+    for (const v of this.counts.values()) total += v;
+    return total;
+  }
+  /** Get the count for a specific node */
+  nodeValue(nodeId) {
+    return this.counts.get(nodeId) || 0;
+  }
+  /** Merge with another counter (take max per node) */
+  merge(other) {
+    for (const [nodeId, count] of other.counts) {
+      this.counts.set(nodeId, Math.max(this.counts.get(nodeId) || 0, count));
+    }
+  }
+  /** Export state */
+  toJSON() {
+    const obj = {};
+    for (const [k, v] of this.counts) obj[k] = v;
+    return obj;
+  }
+  /** Import state */
+  static fromJSON(data) {
+    const counter = new _GCounter();
+    for (const [k, v] of Object.entries(data)) counter.counts.set(k, v);
+    return counter;
+  }
+};
+var ORSet = class {
+  elements = /* @__PURE__ */ new Map();
+  // tag → element
+  tombstones = /* @__PURE__ */ new Set();
+  // removed tags
+  tagCounter = 0;
+  /** Add an element with a signed operation */
+  add(value, signer, timestamp) {
+    if (signer.revoked) return "";
+    const tag = `${signer.id}_${timestamp}_${this.tagCounter++}`;
+    this.elements.set(tag, { value, tag, signer, timestamp });
+    return tag;
+  }
+  /** Remove an element by value (removes all copies) */
+  remove(value, _signer) {
+    let removed = 0;
+    for (const [tag, elem] of this.elements) {
+      if (this.valueEquals(elem.value, value)) {
+        this.tombstones.add(tag);
+        this.elements.delete(tag);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /** Check if the set contains a value */
+  has(value) {
+    for (const elem of this.elements.values()) {
+      if (this.valueEquals(elem.value, value)) return true;
+    }
+    return false;
+  }
+  /** Get all current values (deduplicated) */
+  values() {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const elem of this.elements.values()) {
+      const key = JSON.stringify(elem.value);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(elem.value);
+      }
+    }
+    return result;
+  }
+  /** Size of the set (unique values) */
+  get size() {
+    return this.values().length;
+  }
+  /** Merge with another OR-Set (adds win over concurrent removes) */
+  merge(other) {
+    for (const [tag, elem] of other.elements) {
+      if (!this.tombstones.has(tag) && !this.elements.has(tag)) {
+        if (!elem.signer.revoked) {
+          this.elements.set(tag, elem);
+        }
+      }
+    }
+    for (const tag of other.tombstones) {
+      this.tombstones.add(tag);
+      this.elements.delete(tag);
+    }
+  }
+  valueEquals(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+};
+function createAgentState(agentDID) {
+  return {
+    agentDID,
+    registers: /* @__PURE__ */ new Map(),
+    counters: /* @__PURE__ */ new Map(),
+    sets: /* @__PURE__ */ new Map(),
+    lastSync: 0
+  };
+}
+function setRegister(state, key, value, signer, timestamp) {
+  if (!state.registers.has(key)) {
+    state.registers.set(key, new LWWRegister(void 0));
+  }
+  const op = signOperation(value, signer, `state:${key}`, timestamp);
+  return state.registers.get(key).set(op);
+}
+function getRegister(state, key) {
+  return state.registers.get(key)?.get();
+}
+function incrementCounter(state, key, nodeId, amount = 1) {
+  if (!state.counters.has(key)) state.counters.set(key, new GCounter());
+  state.counters.get(key).increment(nodeId, amount);
+}
+function getCounter(state, key) {
+  return state.counters.get(key)?.value() ?? 0;
+}
+function mergeStates(local, remote) {
+  for (const [key, reg] of remote.registers) {
+    if (local.registers.has(key)) {
+      local.registers.get(key).merge(reg);
+    } else {
+      local.registers.set(key, reg);
+    }
+  }
+  for (const [key, counter] of remote.counters) {
+    if (local.counters.has(key)) {
+      local.counters.get(key).merge(counter);
+    } else {
+      local.counters.set(key, counter);
+    }
+  }
+  for (const [key, set] of remote.sets) {
+    if (local.sets.has(key)) {
+      local.sets.get(key).merge(set);
+    } else {
+      local.sets.set(key, set);
+    }
+  }
+  local.lastSync = Math.max(local.lastSync, remote.lastSync);
+}
+
+// src/agents/CrossRealityHandoff.ts
+var PLATFORM_CAPABILITIES = {};
+var embodimentFor = (platform) => {
+  if (platform === "quest3" || platform === "pcvr") return "Avatar3D";
+  if (platform === "android-auto") return "VoiceHUD";
+  return "UI2D";
+};
+var platformCategory = (platform) => {
+  if (platform.includes("android-auto")) return "automotive";
+  if (platform.includes("android") || platform.includes("ios")) return "mobile";
+  if (platform.includes("quest") || platform.includes("pcvr")) return "vr";
+  return "desktop";
+};
+function negotiateHandoff(source, target) {
+  const gained = [];
+  const lost = [];
+  const boolCaps = [
+    "spatialTracking",
+    "handTracking",
+    "eyeTracking",
+    "haptics",
+    "spatialAudio",
+    "gpu3D",
+    "arCamera",
+    "gps",
+    "npu",
+    "webxrSupport"
+  ];
+  for (const cap of boolCaps) {
+    const srcHas = !!source.capabilities[cap];
+    const tgtHas = !!target.capabilities[cap];
+    if (!srcHas && tgtHas) gained.push(cap);
+    if (srcHas && !tgtHas) lost.push(cap);
+  }
+  const srcCat = platformCategory(source.platform);
+  const tgtCat = platformCategory(target.platform);
+  let latency = 200;
+  if (srcCat === tgtCat) latency = 100;
+  if (tgtCat === "automotive") latency = 500;
+  const feasible = target.available;
+  return {
+    sourceDevice: source,
+    targetDevice: target,
+    gained,
+    lost,
+    transition: { from: source.embodiment, to: target.embodiment },
+    estimatedLatencyMs: latency,
+    feasible,
+    reason: feasible ? void 0 : "Target device not available"
+  };
+}
+function createMVCPayload(agentDID, sessionId, source, data) {
+  const trimmedDecisions = data.decisions.slice(-10);
+  const trimmedEvidence = data.evidence.sort((a, b) => b.relevance - a.relevance).slice(0, 15);
+  return {
+    version: "1.0",
+    agentDID,
+    sessionId,
+    decisions: trimmedDecisions,
+    task: data.task,
+    preferences: data.preferences,
+    spatial: data.spatial,
+    evidence: trimmedEvidence,
+    handoff: {
+      sourceDevice: source.deviceId,
+      sourcePlatform: source.platform,
+      sourceEmbodiment: embodimentFor(source.platform),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function estimatePayloadSize(payload) {
+  return new TextEncoder().encode(JSON.stringify(payload)).length;
+}
+function validatePayloadBudget(payload) {
+  const BUDGET = 10 * 1024;
+  const size = estimatePayloadSize(payload);
+  return { valid: size <= BUDGET, sizeBytes: size, budgetBytes: BUDGET };
+}
+
+// src/agents/CulturalMemory.ts
+var DEFAULT_CONFIG3 = {
+  episodicCapacity: 100,
+  episodicDecayRate: 0.01,
+  stigmergicCapacity: 500,
+  traceDecayRate: 5e-3,
+  consolidationThreshold: 5,
+  sopRetentionThreshold: 0.3
+};
+var CulturalMemory = class {
+  config;
+  episodic = /* @__PURE__ */ new Map();
+  // agentId → memories
+  stigmergic = /* @__PURE__ */ new Map();
+  // zoneId → traces
+  sops = /* @__PURE__ */ new Map();
+  // sopId → SOP
+  currentTick = 0;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+  }
+  // ── Episodic Memory ──────────────────────────────────────────────────────
+  /**
+   * Record an episodic memory for an agent.
+   */
+  record(agentId, event, opts = {}) {
+    const memories = this.episodic.get(agentId) || [];
+    const memory = {
+      id: `ep_${agentId}_${this.currentTick}_${memories.length}`,
+      agentId,
+      event,
+      participants: opts.participants || [],
+      valence: opts.valence ?? 0,
+      importance: opts.importance ?? 0.5,
+      timestamp: this.currentTick,
+      strength: 1,
+      normId: opts.normId,
+      tags: opts.tags || []
+    };
+    memories.push(memory);
+    if (memories.length > this.config.episodicCapacity) {
+      memories.sort((a, b) => b.strength * b.importance - a.strength * a.importance);
+      memories.length = this.config.episodicCapacity;
+    }
+    this.episodic.set(agentId, memories);
+    return memory;
+  }
+  /**
+   * Recall memories for an agent, optionally filtered.
+   */
+  recall(agentId, filter) {
+    const memories = this.episodic.get(agentId) || [];
+    return memories.filter((m) => {
+      if (filter?.minStrength && m.strength < filter.minStrength) return false;
+      if (filter?.normId && m.normId !== filter.normId) return false;
+      if (filter?.tags && !filter.tags.some((t) => m.tags.includes(t))) return false;
+      return true;
+    }).sort((a, b) => b.strength * b.importance - a.strength * a.importance);
+  }
+  /**
+   * Get the number of memories for an agent.
+   */
+  memoryCount(agentId) {
+    return (this.episodic.get(agentId) || []).length;
+  }
+  // ── Stigmergic Memory ────────────────────────────────────────────────────
+  /**
+   * Leave a stigmergic trace in the environment.
+   */
+  leaveTrace(creatorId, zoneId, label, position, opts = {}) {
+    const traces = this.stigmergic.get(zoneId) || [];
+    const intensity = opts.intensity ?? opts.initialIntensity ?? 1;
+    const trace = {
+      id: `st_${zoneId}_${this.currentTick}_${traces.length}`,
+      creatorId,
+      position,
+      zoneId,
+      type: opts.type || "marker",
+      label,
+      intensity,
+      initialIntensity: intensity,
+      decayRate: opts.decayRate ?? this.config.traceDecayRate,
+      radius: opts.radius ?? 10,
+      timestamp: this.currentTick,
+      reinforcements: 0
+    };
+    traces.push(trace);
+    if (traces.length > this.config.stigmergicCapacity) {
+      traces.sort((a, b) => b.intensity - a.intensity);
+      traces.length = this.config.stigmergicCapacity;
+    }
+    this.stigmergic.set(zoneId, traces);
+    return trace;
+  }
+  /**
+   * Perceive nearby traces from a position.
+   */
+  perceiveTraces(zoneId, position) {
+    const traces = this.stigmergic.get(zoneId) || [];
+    return traces.filter((t) => {
+      const dx = t.position.x - position.x;
+      const dy = t.position.y - position.y;
+      const dz = t.position.z - position.z;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return dist <= t.radius && t.intensity > 0.01;
+    }).sort((a, b) => b.intensity - a.intensity);
+  }
+  /**
+   * Reinforce a trace (another agent validates it).
+   * Increases intensity and slows decay.
+   */
+  reinforceTrace(traceId, zoneId) {
+    const traces = this.stigmergic.get(zoneId) || [];
+    const trace = traces.find((t) => t.id === traceId);
+    if (!trace) return false;
+    trace.reinforcements++;
+    trace.intensity = Math.min(trace.initialIntensity * 2, trace.intensity + 0.1);
+    trace.decayRate *= 0.95;
+    return true;
+  }
+  /**
+   * Get all traces in a zone.
+   */
+  zoneTraces(zoneId) {
+    return (this.stigmergic.get(zoneId) || []).filter((t) => t.intensity > 0.01);
+  }
+  // ── Semantic SOPs ────────────────────────────────────────────────────────
+  /**
+   * Attempt to consolidate episodic memories into a semantic SOP.
+   * Finds repeated patterns (same normId, high frequency) and forms SOPs.
+   */
+  consolidate(agentId) {
+    const memories = this.episodic.get(agentId) || [];
+    const newSops = [];
+    const byNorm = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      if (m.normId) {
+        const group = byNorm.get(m.normId) || [];
+        group.push(m);
+        byNorm.set(m.normId, group);
+      }
+    }
+    for (const [normId, episodes] of byNorm) {
+      if (episodes.length < this.config.consolidationThreshold) continue;
+      const existing = this.sops.get(`sop_${agentId}_${normId}`);
+      if (existing) {
+        existing.episodeCount = episodes.length;
+        existing.confidence = Math.min(
+          1,
+          episodes.length / (this.config.consolidationThreshold * 3)
+        );
+        existing.updatedAt = this.currentTick;
+        continue;
+      }
+      const avgValence = episodes.reduce((s, e) => s + e.valence, 0) / episodes.length;
+      const sop = {
+        id: `sop_${agentId}_${normId}`,
+        normId,
+        description: `Learned behavior for norm '${normId}' from ${episodes.length} experiences (avg valence: ${avgValence.toFixed(2)})`,
+        conditions: [...new Set(episodes.flatMap((e) => e.tags))],
+        actions: avgValence > 0 ? ["comply", "reinforce"] : ["avoid", "report"],
+        confidence: Math.min(1, episodes.length / (this.config.consolidationThreshold * 3)),
+        episodeCount: episodes.length,
+        createdAt: this.currentTick,
+        updatedAt: this.currentTick
+      };
+      this.sops.set(sop.id, sop);
+      newSops.push(sop);
+    }
+    return newSops;
+  }
+  /**
+   * Get all SOPs for an agent.
+   */
+  getSOPs(agentId) {
+    const prefix = `sop_${agentId}_`;
+    return [...this.sops.values()].filter((s) => s.id.startsWith(prefix));
+  }
+  /**
+   * Get a specific SOP by agent and norm.
+   */
+  getSOP(agentId, normId) {
+    return this.sops.get(`sop_${agentId}_${normId}`);
+  }
+  // ── Tick / Lifecycle ─────────────────────────────────────────────────────
+  /**
+   * Advance one tick: decay memories and traces, prune dead entries.
+   */
+  tick() {
+    this.currentTick++;
+    let decayedMemories = 0;
+    let evaporatedTraces = 0;
+    for (const [agentId, memories] of this.episodic) {
+      for (const m of memories) {
+        m.strength *= 1 - this.config.episodicDecayRate;
+      }
+      const before = memories.length;
+      const alive = memories.filter((m) => m.strength > 0.01);
+      decayedMemories += before - alive.length;
+      this.episodic.set(agentId, alive);
+    }
+    for (const [zoneId, traces] of this.stigmergic) {
+      for (const t of traces) {
+        t.intensity -= t.decayRate;
+      }
+      const before = traces.length;
+      const alive = traces.filter((t) => t.intensity > 0.01);
+      evaporatedTraces += before - alive.length;
+      this.stigmergic.set(zoneId, alive);
+    }
+    for (const [id, sop] of this.sops) {
+      if (sop.confidence < this.config.sopRetentionThreshold) {
+        this.sops.delete(id);
+      }
+    }
+    return { decayedMemories, evaporatedTraces };
+  }
+  /**
+   * Get current tick.
+   */
+  getTick() {
+    return this.currentTick;
+  }
+  /**
+   * Get global statistics.
+   */
+  stats() {
+    let totalMemories = 0;
+    let totalTraces = 0;
+    for (const mems of this.episodic.values()) totalMemories += mems.length;
+    for (const traces of this.stigmergic.values()) totalTraces += traces.length;
+    return {
+      agents: this.episodic.size,
+      totalMemories,
+      totalTraces,
+      totalSOPs: this.sops.size,
+      zones: this.stigmergic.size
+    };
+  }
+  /**
+   * Export full state for persistence / cross-session continuity.
+   */
+  exportState() {
+    const episodic = {};
+    for (const [k, v] of this.episodic) episodic[k] = v;
+    const stigmergic = {};
+    for (const [k, v] of this.stigmergic) stigmergic[k] = v;
+    return { episodic, stigmergic, sops: [...this.sops.values()], tick: this.currentTick };
+  }
+  /**
+   * Import state from persistence.
+   */
+  importState(state) {
+    for (const [k, v] of Object.entries(state.episodic)) this.episodic.set(k, v);
+    for (const [k, v] of Object.entries(state.stigmergic)) this.stigmergic.set(k, v);
+    for (const sop of state.sops) this.sops.set(sop.id, sop);
+    this.currentTick = state.tick;
+  }
+};
+
+// src/agents/NormEngine.ts
+var BUILTIN_NORMS = [
+  {
+    id: "no_griefing",
+    name: "No Griefing",
+    category: "safety",
+    description: "Do not cause harm to others",
+    enforcement: "hard",
+    scope: "world",
+    activationThreshold: 0.1,
+    strength: "strong",
+    forbiddenEffects: ["agent:kill", "inventory:steal"]
+  },
+  {
+    id: "resource_sharing",
+    name: "Resource Sharing",
+    category: "cooperation",
+    description: "Share resources when abundant",
+    enforcement: "soft",
+    scope: "world",
+    activationThreshold: 0.5,
+    strength: "moderate",
+    forbiddenEffects: ["inventory:hoard", "inventory:horde"]
+  },
+  {
+    id: "fair_trade",
+    name: "Fair Trade",
+    category: "economy",
+    description: "Trade at mutually agreeable values",
+    enforcement: "soft",
+    scope: "world",
+    activationThreshold: 0.3,
+    strength: "weak",
+    forbiddenEffects: ["trade:scam", "trade:extort"]
+  }
+];
+function criticalMassForChange(norm, populationSize) {
+  if (norm.strength === "strong") return populationSize * 0.5;
+  if (norm.strength === "moderate") return populationSize * 0.25;
+  return populationSize * 0.02;
+}
+var EffectRow = class {
+  effects;
+  constructor(effects) {
+    this.effects = new Set(effects);
+  }
+  has(effect) {
+    return this.effects.has(effect);
+  }
+};
+var DEFAULT_CONFIG4 = {
+  activationThreshold: 0.3,
+  complianceReward: 0.05,
+  violationPenalty: 0.15,
+  proposalThreshold: 0.6,
+  enableMetanorms: true
+};
+var NormEngine = class {
+  config;
+  norms = /* @__PURE__ */ new Map();
+  agents = /* @__PURE__ */ new Map();
+  proposals = /* @__PURE__ */ new Map();
+  violationLog = [];
+  adoptionHistory = [];
+  currentTick = 0;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG4, ...config };
+    for (const norm of BUILTIN_NORMS) {
+      this.norms.set(norm.id, norm);
+    }
+  }
+  // ── C: Creation ──────────────────────────────────────────────────────────
+  /**
+   * Register a custom norm.
+   */
+  registerNorm(norm) {
+    this.norms.set(norm.id, norm);
+  }
+  /**
+   * Agent proposes a new norm.
+   */
+  proposeNorm(proposerId, norm) {
+    const proposal = {
+      id: `prop_${this.currentTick}_${proposerId}`,
+      proposerId,
+      norm,
+      votes: /* @__PURE__ */ new Map(),
+      timestamp: this.currentTick,
+      status: "pending"
+    };
+    this.proposals.set(proposal.id, proposal);
+    const state = this.getOrCreateAgent(proposerId);
+    state.proposed.add(proposal.id);
+    return proposal;
+  }
+  /**
+   * Vote on a pending proposal.
+   */
+  vote(proposalId, agentId, approve) {
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal || proposal.status !== "pending") return false;
+    proposal.votes.set(agentId, approve);
+    const totalAgents = this.agents.size;
+    if (totalAgents === 0) return true;
+    const approvals = [...proposal.votes.values()].filter((v) => v).length;
+    const ratio = approvals / totalAgents;
+    if (ratio >= this.config.proposalThreshold) {
+      proposal.status = "adopted";
+      this.norms.set(proposal.norm.id, proposal.norm);
+    } else if (proposal.votes.size >= totalAgents) {
+      proposal.status = "rejected";
+    }
+    return true;
+  }
+  // ── R: Representation ────────────────────────────────────────────────────
+  /**
+   * Get a norm by ID.
+   */
+  getNorm(normId) {
+    return this.norms.get(normId);
+  }
+  /**
+   * List all registered norms.
+   */
+  listNorms() {
+    return [...this.norms.values()];
+  }
+  // ── S: Spreading ─────────────────────────────────────────────────────────
+  /**
+   * Agent adopts a norm.
+   */
+  adopt(agentId, normId) {
+    if (!this.norms.has(normId)) return false;
+    const state = this.getOrCreateAgent(agentId);
+    state.adopted.add(normId);
+    state.compliance.set(normId, 1);
+    return true;
+  }
+  /**
+   * Agent abandons a norm.
+   */
+  abandon(agentId, normId) {
+    const state = this.agents.get(agentId);
+    if (!state) return false;
+    state.adopted.delete(normId);
+    state.compliance.delete(normId);
+    return true;
+  }
+  /**
+   * Get adoption rate for a norm (0-1).
+   */
+  adoptionRate(normId) {
+    if (this.agents.size === 0) return 0;
+    let adopters = 0;
+    for (const state of this.agents.values()) {
+      if (state.adopted.has(normId)) adopters++;
+    }
+    return adopters / this.agents.size;
+  }
+  /**
+   * Check if a norm is active (adoption > threshold).
+   */
+  isActive(normId) {
+    const norm = this.norms.get(normId);
+    if (!norm) return false;
+    return this.adoptionRate(normId) >= (norm.activationThreshold || this.config.activationThreshold);
+  }
+  // ── E: Evaluation ────────────────────────────────────────────────────────
+  /**
+   * Check if an agent's intended effects comply with active norms.
+   * Returns violations found.
+   */
+  evaluate(agentId, effects, zoneId) {
+    const violations = [];
+    const effectRow = new EffectRow(effects);
+    for (const norm of this.norms.values()) {
+      if (!this.isActive(norm.id)) continue;
+      if (norm.scope === "zone" && !zoneId) continue;
+      if (norm.forbiddenEffects) {
+        for (const forbidden of norm.forbiddenEffects) {
+          if (effectRow.has(forbidden)) {
+            violations.push({
+              normId: norm.id,
+              agentId,
+              effect: forbidden,
+              timestamp: this.currentTick,
+              severity: norm.enforcement,
+              witnessed: this.witnessesIn(zoneId)
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+  // ── C: Compliance ────────────────────────────────────────────────────────
+  /**
+   * Record that an agent complied with a norm.
+   */
+  recordCompliance(agentId, normId) {
+    const state = this.getOrCreateAgent(agentId);
+    const current = state.compliance.get(normId) || 0.5;
+    state.compliance.set(normId, Math.min(1, current + this.config.complianceReward));
+    state.violations.delete(normId);
+  }
+  /**
+   * Record that an agent violated a norm.
+   */
+  recordViolation(violation) {
+    const state = this.getOrCreateAgent(violation.agentId);
+    const current = state.compliance.get(violation.normId) || 0.5;
+    state.compliance.set(violation.normId, Math.max(0, current - this.config.violationPenalty));
+    state.violations.add(violation.normId);
+    this.violationLog.push(violation);
+    if (this.config.enableMetanorms) {
+      for (const witnessId of violation.witnessed) {
+        const witnessState = this.getOrCreateAgent(witnessId);
+        witnessState.enforcementCount++;
+      }
+    }
+  }
+  /**
+   * Get compliance score for an agent on a norm.
+   */
+  getCompliance(agentId, normId) {
+    return this.agents.get(agentId)?.compliance.get(normId) ?? 0.5;
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Register an agent in the norm engine.
+   */
+  registerAgent(agentId, adoptNorms) {
+    const state = this.getOrCreateAgent(agentId);
+    if (adoptNorms) {
+      for (const normId of adoptNorms) this.adopt(agentId, normId);
+    }
+    return state;
+  }
+  /**
+   * Advance one tick: record adoption history, snapshot state.
+   */
+  tick() {
+    this.currentTick++;
+    for (const norm of this.norms.values()) {
+      this.adoptionHistory.push({
+        normId: norm.id,
+        tick: this.currentTick,
+        rate: this.adoptionRate(norm.id)
+      });
+    }
+  }
+  /**
+   * Get adoption curve data for a norm.
+   */
+  adoptionCurve(normId) {
+    return this.adoptionHistory.filter((h) => h.normId === normId);
+  }
+  /**
+   * Get the cultural health score for the whole population (0-1).
+   * High = norms well-adopted, low violations. Low = cultural breakdown.
+   */
+  culturalHealth() {
+    if (this.agents.size === 0) return 1;
+    let totalCompliance = 0;
+    let count = 0;
+    for (const state of this.agents.values()) {
+      for (const score of state.compliance.values()) {
+        totalCompliance += score;
+        count++;
+      }
+    }
+    return count > 0 ? totalCompliance / count : 1;
+  }
+  /**
+   * Get statistics.
+   */
+  stats() {
+    return {
+      norms: this.norms.size,
+      agents: this.agents.size,
+      activeNorms: [...this.norms.keys()].filter((id) => this.isActive(id)).length,
+      violations: this.violationLog.length,
+      proposals: this.proposals.size,
+      culturalHealth: this.culturalHealth()
+    };
+  }
+  // ── Internal ─────────────────────────────────────────────────────────────
+  getOrCreateAgent(agentId) {
+    let state = this.agents.get(agentId);
+    if (!state) {
+      state = {
+        agentId,
+        adopted: /* @__PURE__ */ new Set(),
+        compliance: /* @__PURE__ */ new Map(),
+        violations: /* @__PURE__ */ new Set(),
+        proposed: /* @__PURE__ */ new Set(),
+        enforcementCount: 0
+      };
+      this.agents.set(agentId, state);
+    }
+    return state;
+  }
+  witnessesIn(zoneId) {
+    return [...this.agents.keys()].slice(0, 5);
+  }
+};
+
+// src/agents/spatial-comms/ProtocolTypes.ts
+var DEFAULT_REALTIME_CONFIG = {
+  binary: true,
+  maxMessageSize: 512,
+  // 512 bytes max
+  targetLatency: 1,
+  // <1ms target
+  messagesPerSecond: 90,
+  // 90fps coordination
+  compression: false,
+  // No compression for minimal latency
+  udpPort: 9001
+};
+var DEFAULT_A2A_CONFIG = {
+  endpoint: "http://localhost:3002/a2a",
+  timeout: 5e3,
+  // 5 seconds
+  maxRetries: 3,
+  retryBackoffBase: 100,
+  // 100ms, 200ms, 400ms
+  requireAck: true,
+  enableBatching: true,
+  batchSize: 10
+};
+var DEFAULT_MCP_CONFIG = {
+  endpoint: "http://localhost:5567",
+  apiKey: process.env.MCP_API_KEY || "",
+  timeout: 3e4
+  // 30 seconds
+};
+var DEFAULT_SPATIAL_COMM_CONFIG = {
+  layer1: DEFAULT_REALTIME_CONFIG,
+  layer2: DEFAULT_A2A_CONFIG,
+  layer3: DEFAULT_MCP_CONFIG
+};
+var PROTOCOL_VERSION = "1.0.0";
+var PROTOCOL_COMPATIBILITY = {
+  version: PROTOCOL_VERSION,
+  minVersion: "1.0.0",
+  maxVersion: "1.x.x"
+};
+
+// src/agents/spatial-comms/Layer1RealTime.ts
+var import_events2 = require("events");
+var HEADER_SIZE = 12;
+function encodeRealTimeMessage(message) {
+  const agentIdBytes = Buffer.from(message.agent_id, "utf-8");
+  const agentIdLen = agentIdBytes.length;
+  let typeCode;
+  switch (message.type) {
+    case "position_sync":
+      typeCode = 1 /* POSITION_SYNC */;
+      break;
+    case "frame_budget":
+      typeCode = 2 /* FRAME_BUDGET */;
+      break;
+    case "spatial_conflict":
+      typeCode = 3 /* SPATIAL_CONFLICT */;
+      break;
+    case "performance_metric":
+      typeCode = 4 /* PERFORMANCE_METRIC */;
+      break;
+    default:
+      throw new Error(
+        `Unknown message type: ${message.type}`
+      );
+  }
+  if (message.type === "position_sync") {
+    const msg = message;
+    const bodySize = agentIdLen + 12 + 16 + 12 + (msg.velocity ? 12 : 0);
+    const buffer = Buffer.allocUnsafe(HEADER_SIZE + bodySize);
+    let offset = 0;
+    buffer.writeUInt8(typeCode, offset);
+    offset += 1;
+    buffer.writeUInt8(agentIdLen, offset);
+    offset += 1;
+    buffer.writeBigInt64BE(BigInt(msg.timestamp), offset);
+    offset += 8;
+    buffer.writeUInt16BE(0, offset);
+    offset += 2;
+    agentIdBytes.copy(buffer, offset);
+    offset += agentIdLen;
+    buffer.writeFloatBE(msg.position[0], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.position[1], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.position[2], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.rotation[0], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.rotation[1], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.rotation[2], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.rotation[3], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.scale[0], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.scale[1], offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.scale[2], offset);
+    offset += 4;
+    if (msg.velocity) {
+      buffer.writeFloatBE(msg.velocity[0], offset);
+      offset += 4;
+      buffer.writeFloatBE(msg.velocity[1], offset);
+      offset += 4;
+      buffer.writeFloatBE(msg.velocity[2], offset);
+      offset += 4;
+    }
+    return buffer;
+  } else if (message.type === "frame_budget") {
+    const msg = message;
+    const bodySize = agentIdLen + 17;
+    const buffer = Buffer.allocUnsafe(HEADER_SIZE + bodySize);
+    let offset = 0;
+    buffer.writeUInt8(typeCode, offset);
+    offset += 1;
+    buffer.writeUInt8(agentIdLen, offset);
+    offset += 1;
+    buffer.writeBigInt64BE(BigInt(msg.timestamp), offset);
+    offset += 8;
+    buffer.writeUInt16BE(0, offset);
+    offset += 2;
+    agentIdBytes.copy(buffer, offset);
+    offset += agentIdLen;
+    buffer.writeFloatBE(msg.frame_time_ms, offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.budget_remaining_ms, offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.target_fps, offset);
+    offset += 4;
+    buffer.writeFloatBE(msg.actual_fps, offset);
+    offset += 4;
+    const qualityCode = { high: 0, medium: 1, low: 2, minimal: 3 }[msg.quality_level];
+    buffer.writeUInt8(qualityCode, offset);
+    offset += 1;
+    return buffer;
+  } else {
+    const json = JSON.stringify(message);
+    const jsonBytes = Buffer.from(json, "utf-8");
+    const buffer = Buffer.allocUnsafe(HEADER_SIZE + agentIdLen + jsonBytes.length);
+    let offset = 0;
+    buffer.writeUInt8(typeCode, offset);
+    offset += 1;
+    buffer.writeUInt8(agentIdLen, offset);
+    offset += 1;
+    buffer.writeBigInt64BE(BigInt(message.timestamp), offset);
+    offset += 8;
+    buffer.writeUInt16BE(0, offset);
+    offset += 2;
+    agentIdBytes.copy(buffer, offset);
+    offset += agentIdLen;
+    jsonBytes.copy(buffer, offset);
+    return buffer;
+  }
+}
+function decodeRealTimeMessage(buffer) {
+  let offset = 0;
+  const typeCode = buffer.readUInt8(offset);
+  offset += 1;
+  const agentIdLen = buffer.readUInt8(offset);
+  offset += 1;
+  const timestamp = Number(buffer.readBigInt64BE(offset));
+  offset += 8;
+  offset += 2;
+  const agentId = buffer.toString("utf-8", offset, offset + agentIdLen);
+  offset += agentIdLen;
+  if (typeCode === 1 /* POSITION_SYNC */) {
+    const px = buffer.readFloatBE(offset);
+    offset += 4;
+    const py = buffer.readFloatBE(offset);
+    offset += 4;
+    const pz = buffer.readFloatBE(offset);
+    offset += 4;
+    const position = [px, py, pz];
+    const rx = buffer.readFloatBE(offset);
+    offset += 4;
+    const ry = buffer.readFloatBE(offset);
+    offset += 4;
+    const rz = buffer.readFloatBE(offset);
+    offset += 4;
+    const rw = buffer.readFloatBE(offset);
+    offset += 4;
+    const rotation = [rx, ry, rz, rw];
+    const sx = buffer.readFloatBE(offset);
+    offset += 4;
+    const sy = buffer.readFloatBE(offset);
+    offset += 4;
+    const sz = buffer.readFloatBE(offset);
+    offset += 4;
+    const scale = [sx, sy, sz];
+    let velocity;
+    if (offset < buffer.length) {
+      const vx = buffer.readFloatBE(offset);
+      offset += 4;
+      const vy = buffer.readFloatBE(offset);
+      offset += 4;
+      const vz = buffer.readFloatBE(offset);
+      offset += 4;
+      velocity = [vx, vy, vz];
+    }
+    return {
+      type: "position_sync",
+      agent_id: agentId,
+      timestamp,
+      position,
+      rotation,
+      scale,
+      velocity
+    };
+  } else if (typeCode === 2 /* FRAME_BUDGET */) {
+    const frame_time_ms = buffer.readFloatBE(offset);
+    offset += 4;
+    const budget_remaining_ms = buffer.readFloatBE(offset);
+    offset += 4;
+    const target_fps = buffer.readFloatBE(offset);
+    offset += 4;
+    const actual_fps = buffer.readFloatBE(offset);
+    offset += 4;
+    const qualityCode = buffer.readUInt8(offset);
+    offset += 1;
+    const qualityLevels = [
+      "high",
+      "medium",
+      "low",
+      "minimal"
+    ];
+    const quality_level = qualityLevels[qualityCode] ?? "medium";
+    return {
+      type: "frame_budget",
+      agent_id: agentId,
+      timestamp,
+      frame_time_ms,
+      budget_remaining_ms,
+      target_fps,
+      actual_fps,
+      quality_level
+    };
+  } else {
+    const json = buffer.toString("utf-8", offset);
+    return JSON.parse(json);
+  }
+}
+var UDPRealTimeTransport = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dgram.Socket dynamically imported at runtime
+  socket;
+  port;
+  targetHost = "localhost";
+  constructor(port) {
+    this.port = port;
+  }
+  async init() {
+    const dgram = await import("dgram");
+    this.socket = dgram.createSocket("udp4");
+    return new Promise((resolve, reject) => {
+      this.socket.bind(this.port, () => {
+        this.socket.setBroadcast(true);
+        resolve();
+      });
+      this.socket.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async send(buffer, _targetAgent) {
+    if (!this.socket) throw new Error("Transport not initialized");
+    return new Promise((resolve, reject) => {
+      this.socket.send(buffer, this.port, this.targetHost, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async broadcast(buffer) {
+    if (!this.socket) throw new Error("Transport not initialized");
+    return new Promise((resolve, reject) => {
+      this.socket.send(buffer, this.port, "255.255.255.255", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async close() {
+    if (this.socket) {
+      return new Promise((resolve) => {
+        this.socket.close(() => resolve());
+      });
+    }
+  }
+  onMessage(callback) {
+    if (!this.socket) throw new Error("Transport not initialized");
+    this.socket.on("message", callback);
+  }
+};
+var WebRTCRealTimeTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  dataChannel;
+  peerConnection;
+  async init(remoteDescription) {
+    this.peerConnection = new RTCPeerConnection(this.config);
+    this.dataChannel = this.peerConnection.createDataChannel("realtime", {
+      ordered: false,
+      // Unordered for minimal latency
+      maxRetransmits: 0
+      // No retransmits (UDP-like)
+    });
+    this.dataChannel.bufferedAmountLowThreshold = 0;
+    if (remoteDescription) {
+      await this.peerConnection.setRemoteDescription(remoteDescription);
+    }
+  }
+  async send(buffer, _targetAgent) {
+    if (!this.dataChannel || this.dataChannel.readyState !== "open") {
+      throw new Error("Data channel not ready");
+    }
+    this.dataChannel.send(new Uint8Array(buffer));
+  }
+  async broadcast(buffer) {
+    return this.send(buffer);
+  }
+  async close() {
+    if (this.dataChannel) {
+      this.dataChannel.close();
+    }
+    if (this.peerConnection) {
+      this.peerConnection.close();
+    }
+  }
+  onMessage(callback) {
+    if (!this.dataChannel) throw new Error("Data channel not initialized");
+    this.dataChannel.onmessage = (event) => {
+      const buffer = Buffer.from(event.data);
+      callback(buffer);
+    };
+  }
+  async createOffer() {
+    if (!this.peerConnection) throw new Error("Peer connection not initialized");
+    const offer = await this.peerConnection.createOffer();
+    await this.peerConnection.setLocalDescription(offer);
+    return offer;
+  }
+  async createAnswer() {
+    if (!this.peerConnection) throw new Error("Peer connection not initialized");
+    const answer = await this.peerConnection.createAnswer();
+    await this.peerConnection.setLocalDescription(answer);
+    return answer;
+  }
+};
+var Layer1RealTimeClient = class extends import_events2.EventEmitter {
+  config;
+  transport;
+  agentId;
+  messageCount = 0;
+  lastMessageTime = 0;
+  _messageBuffer = [];
+  constructor(agentId, config) {
+    super();
+    this.agentId = agentId;
+    this.config = { ...DEFAULT_REALTIME_CONFIG, ...config };
+  }
+  /**
+   * Initialize transport and start listening
+   */
+  async init(useWebRTC = false) {
+    if (useWebRTC) {
+      const transport = new WebRTCRealTimeTransport(
+        this.config.webrtc?.iceServers ? { iceServers: this.config.webrtc.iceServers } : {}
+      );
+      await transport.init();
+      this.transport = transport;
+      transport.onMessage((buffer) => {
+        this.handleIncomingMessage(buffer);
+      });
+    } else {
+      const transport = new UDPRealTimeTransport(this.config.udpPort || 9001);
+      await transport.init();
+      this.transport = transport;
+      transport.onMessage((buffer) => {
+        this.handleIncomingMessage(buffer);
+      });
+    }
+  }
+  /**
+   * Send real-time message
+   */
+  async send(message, targetAgent) {
+    if (!this.transport) throw new Error("Transport not initialized");
+    const fullMessage = {
+      ...message,
+      agent_id: this.agentId,
+      timestamp: this.getMicroseconds()
+    };
+    const buffer = this.config.binary ? encodeRealTimeMessage(fullMessage) : Buffer.from(JSON.stringify(fullMessage), "utf-8");
+    if (buffer.length > this.config.maxMessageSize) {
+      throw new Error(`Message size ${buffer.length} exceeds max ${this.config.maxMessageSize}`);
+    }
+    await this.enforceRateLimit();
+    if (targetAgent) {
+      await this.transport.send(buffer, targetAgent);
+    } else {
+      await this.transport.broadcast(buffer);
+    }
+    this.messageCount++;
+    this.lastMessageTime = Date.now();
+  }
+  /**
+   * Send position sync message
+   */
+  async sendPositionSync(position, rotation, scale, velocity) {
+    await this.send({
+      type: "position_sync",
+      position,
+      rotation,
+      scale,
+      velocity
+    });
+  }
+  /**
+   * Send frame budget message
+   */
+  async sendFrameBudget(frameTimeMs, budgetRemainingMs, targetFps, actualFps, qualityLevel) {
+    await this.send({
+      type: "frame_budget",
+      frame_time_ms: frameTimeMs,
+      budget_remaining_ms: budgetRemainingMs,
+      target_fps: targetFps,
+      actual_fps: actualFps,
+      quality_level: qualityLevel
+    });
+  }
+  /**
+   * Close transport
+   */
+  async close() {
+    if (this.transport) {
+      await this.transport.close();
+    }
+  }
+  /**
+   * Handle incoming message
+   */
+  handleIncomingMessage(buffer) {
+    try {
+      const message = this.config.binary ? decodeRealTimeMessage(buffer) : JSON.parse(buffer.toString("utf-8"));
+      this.emit("message", message);
+      this.emit(message.type, message);
+      const latency = (this.getMicroseconds() - message.timestamp) / 1e3;
+      this.emit("latency", latency);
+      if (latency > this.config.targetLatency) {
+        this.emit("latency_warning", { message, latency });
+      }
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Enforce rate limiting
+   */
+  async enforceRateLimit() {
+    const now = Date.now();
+    const timeSinceLastMessage = now - this.lastMessageTime;
+    const minInterval = 1e3 / this.config.messagesPerSecond;
+    if (timeSinceLastMessage < minInterval) {
+      const delay = minInterval - timeSinceLastMessage;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  /**
+   * Get current time in microseconds
+   */
+  getMicroseconds() {
+    const hrTime = process.hrtime ? process.hrtime() : [Date.now() / 1e3, 0];
+    return hrTime[0] * 1e6 + Math.floor(hrTime[1] / 1e3);
+  }
+};
+
+// src/agents/spatial-comms/Layer2A2A.ts
+var import_events3 = require("events");
+var MessageQueue = class {
+  queue = /* @__PURE__ */ new Map();
+  retryTimers = /* @__PURE__ */ new Map();
+  /**
+   * Add message to queue
+   */
+  add(message, maxRetries, backoffBase) {
+    return new Promise((resolve, reject) => {
+      this.queue.set(message.message_id, {
+        message,
+        attempt: 0,
+        maxRetries,
+        backoffBase,
+        resolve,
+        reject
+      });
+    });
+  }
+  /**
+   * Get message from queue
+   */
+  get(messageId) {
+    return this.queue.get(messageId);
+  }
+  /**
+   * Remove message from queue
+   */
+  remove(messageId) {
+    const timer = this.retryTimers.get(messageId);
+    if (timer) {
+      clearTimeout(timer);
+      this.retryTimers.delete(messageId);
+    }
+    this.queue.delete(messageId);
+  }
+  /**
+   * Schedule retry for message
+   */
+  scheduleRetry(messageId, callback) {
+    const queued = this.queue.get(messageId);
+    if (!queued) return;
+    queued.attempt++;
+    const delay = queued.backoffBase * Math.pow(2, queued.attempt - 1);
+    const timer = setTimeout(() => {
+      this.retryTimers.delete(messageId);
+      callback();
+    }, delay);
+    this.retryTimers.set(messageId, timer);
+  }
+  /**
+   * Check if message should retry
+   */
+  shouldRetry(messageId) {
+    const queued = this.queue.get(messageId);
+    if (!queued) return false;
+    return queued.attempt < queued.maxRetries;
+  }
+  /**
+   * Get queue size
+   */
+  get size() {
+    return this.queue.size;
+  }
+  /**
+   * Clear all queued messages
+   */
+  clear() {
+    for (const timer of this.retryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.retryTimers.clear();
+    this.queue.clear();
+  }
+};
+var SpatialClaimManager = class {
+  claims = /* @__PURE__ */ new Map();
+  /**
+   * Add spatial claim
+   */
+  addClaim(claim) {
+    this.claims.set(claim.claim_id, claim);
+  }
+  /**
+   * Remove spatial claim
+   */
+  removeClaim(claimId) {
+    this.claims.delete(claimId);
+  }
+  /**
+   * Get claims by agent
+   */
+  getClaimsByAgent(agentId) {
+    return Array.from(this.claims.values()).filter((c) => c.agent_id === agentId);
+  }
+  /**
+   * Check for conflicts with new claim
+   */
+  checkConflicts(newClaim) {
+    const conflicts = [];
+    for (const existingClaim of this.claims.values()) {
+      if (existingClaim.agent_id === newClaim.agent_id) continue;
+      if (this.boundingBoxesOverlap(newClaim.bounding_box, existingClaim.bounding_box)) {
+        if (newClaim.exclusive || existingClaim.exclusive) {
+          conflicts.push(existingClaim);
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Check if two bounding boxes overlap
+   */
+  boundingBoxesOverlap(box1, box2) {
+    return box1.min[0] <= box2.max[0] && box1.max[0] >= box2.min[0] && box1.min[1] <= box2.max[1] && box1.max[1] >= box2.min[1] && box1.min[2] <= box2.max[2] && box1.max[2] >= box2.min[2];
+  }
+  /**
+   * Cleanup expired claims
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [claimId, claim] of this.claims) {
+      if (claim.expires_at && claim.expires_at < now) {
+        this.claims.delete(claimId);
+      }
+    }
+  }
+  /**
+   * Get all claims
+   */
+  getAllClaims() {
+    return Array.from(this.claims.values());
+  }
+  /**
+   * Clear all claims
+   */
+  clear() {
+    this.claims.clear();
+  }
+};
+var Layer2A2AClient = class extends import_events3.EventEmitter {
+  config;
+  agentId;
+  messageQueue = new MessageQueue();
+  claimManager = new SpatialClaimManager();
+  messageHandlers = /* @__PURE__ */ new Map();
+  batchBuffer = [];
+  batchTimer;
+  constructor(agentId, config) {
+    super();
+    this.agentId = agentId;
+    this.config = { ...DEFAULT_A2A_CONFIG, ...config };
+    setInterval(() => {
+      this.claimManager.cleanup();
+    }, 6e4);
+  }
+  /**
+   * Send A2A message with retry
+   */
+  async send(message) {
+    const fullMessage = {
+      ...message,
+      message_id: this.generateMessageId(),
+      from_agent: this.agentId,
+      timestamp: Date.now()
+    };
+    if (this.config.enableBatching) {
+      return this.addToBatch(fullMessage);
+    }
+    return this.sendMessage(fullMessage);
+  }
+  /**
+   * Send task assignment
+   */
+  async assignTask(toAgent, task) {
+    return this.send({
+      type: "task_assignment",
+      to_agent: toAgent,
+      task
+    });
+  }
+  /**
+   * Send task completion
+   */
+  async completeTask(taskId, success, result, error, performanceMetrics) {
+    return this.send({
+      type: "task_complete",
+      task_id: taskId,
+      success,
+      result,
+      error,
+      performance_metrics: performanceMetrics
+    });
+  }
+  /**
+   * Claim spatial region
+   */
+  async claimSpatialRegion(claimId, boundingBox, priority, durationMs, exclusive = true) {
+    const claim = {
+      claim_id: claimId,
+      agent_id: this.agentId,
+      bounding_box: boundingBox,
+      priority,
+      exclusive,
+      expires_at: durationMs ? Date.now() + durationMs : void 0
+    };
+    const conflicts = this.claimManager.checkConflicts(claim);
+    if (conflicts.length > 0) {
+      this.emit("spatial_conflict", {
+        claim,
+        conflicts
+      });
+      const hasHigherPriority = conflicts.some((c) => {
+        const priorities = ["low", "medium", "high", "critical"];
+        return priorities.indexOf(c.priority) >= priorities.indexOf(priority);
+      });
+      if (hasHigherPriority) {
+        return {
+          message_id: this.generateMessageId(),
+          success: false,
+          error: "Spatial conflict with higher priority claim",
+          data: { conflicts },
+          timestamp: Date.now()
+        };
+      }
+    }
+    this.claimManager.addClaim(claim);
+    return this.send({
+      type: "spatial_claim",
+      claim_id: claimId,
+      bounding_box: boundingBox,
+      priority,
+      duration_ms: durationMs,
+      exclusive
+    });
+  }
+  /**
+   * Resolve spatial conflict
+   */
+  async resolveConflict(conflictId, involvedAgents, strategy, resolutionParams) {
+    return this.send({
+      type: "conflict_resolution",
+      conflict_id: conflictId,
+      strategy,
+      involved_agents: involvedAgents,
+      resolution_params: resolutionParams
+    });
+  }
+  /**
+   * Request resource
+   */
+  async requestResource(resourceId, resourceType, amount, priority = "medium") {
+    return this.send({
+      type: "resource_request",
+      resource_id: resourceId,
+      resource_type: resourceType,
+      amount,
+      priority
+    });
+  }
+  /**
+   * Release resource
+   */
+  async releaseResource(resourceId) {
+    return this.send({
+      type: "resource_release",
+      resource_id: resourceId
+    });
+  }
+  /**
+   * Perform agent handshake
+   */
+  async handshake(toAgent, capabilities, protocolVersion) {
+    return this.send({
+      type: "agent_handshake",
+      to_agent: toAgent,
+      capabilities,
+      protocol_version: protocolVersion
+    });
+  }
+  /**
+   * Register message handler
+   */
+  onMessage(messageType, handler) {
+    this.messageHandlers.set(messageType, handler);
+  }
+  /**
+   * Handle incoming message
+   */
+  async handleIncoming(message) {
+    this.emit("message", message);
+    this.emit(message.type, message);
+    const handler = this.messageHandlers.get(message.type);
+    if (handler) {
+      return handler(message);
+    }
+    return {
+      message_id: message.message_id,
+      success: true,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get spatial claims for this agent
+   */
+  getMyClaims() {
+    return this.claimManager.getClaimsByAgent(this.agentId);
+  }
+  /**
+   * Get all spatial claims
+   */
+  getAllClaims() {
+    return this.claimManager.getAllClaims();
+  }
+  /**
+   * Send message with retry logic
+   */
+  async sendMessage(message) {
+    const responsePromise = this.messageQueue.add(
+      message,
+      this.config.maxRetries,
+      this.config.retryBackoffBase
+    );
+    this.attemptSend(message);
+    return responsePromise;
+  }
+  /**
+   * Attempt to send message
+   */
+  async attemptSend(message) {
+    try {
+      const response = await this.httpRequest(message);
+      const queued = this.messageQueue.get(message.message_id);
+      if (!queued) return;
+      queued.resolve(response);
+      this.messageQueue.remove(message.message_id);
+      this.emit("message_sent", { message, response });
+    } catch (error) {
+      const queued = this.messageQueue.get(message.message_id);
+      if (!queued) return;
+      if (this.messageQueue.shouldRetry(message.message_id)) {
+        this.emit("retry", { message, attempt: queued.attempt });
+        this.messageQueue.scheduleRetry(message.message_id, () => {
+          this.attemptSend(message);
+        });
+      } else {
+        queued.reject(error);
+        this.messageQueue.remove(message.message_id);
+        this.emit("message_failed", { message, error });
+      }
+    }
+  }
+  /**
+   * HTTP/2 request
+   */
+  async httpRequest(message) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Add message to batch
+   */
+  addToBatch(message) {
+    this.batchBuffer.push(message);
+    const responsePromise = new Promise((resolve, reject) => {
+      this.messageQueue.add(message, this.config.maxRetries, this.config.retryBackoffBase).then(resolve).catch(reject);
+    });
+    if (!this.batchTimer) {
+      this.batchTimer = setTimeout(() => {
+        this.flushBatch();
+      }, 10);
+    }
+    if (this.batchBuffer.length >= this.config.batchSize) {
+      this.flushBatch();
+    }
+    return responsePromise;
+  }
+  /**
+   * Flush batch of messages
+   */
+  flushBatch() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = void 0;
+    }
+    if (this.batchBuffer.length === 0) return;
+    const batch = this.batchBuffer.splice(0);
+    for (const message of batch) {
+      this.attemptSend(message);
+    }
+  }
+  /**
+   * Generate unique message ID
+   */
+  generateMessageId() {
+    return `${this.agentId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Get queue statistics
+   */
+  getQueueStats() {
+    return {
+      queueSize: this.messageQueue.size,
+      claimCount: this.getAllClaims().length
+    };
+  }
+  /**
+   * Shutdown client
+   */
+  async shutdown() {
+    this.flushBatch();
+    this.claimManager.clear();
+    this.messageQueue.clear();
+    this.emit("shutdown");
+  }
+};
+
+// src/agents/spatial-comms/Layer3MCP.ts
+var import_events4 = require("events");
+var SPATIAL_MCP_TOOLS = [
+  {
+    name: "create_world",
+    description: "Create a new VR world with multi-agent support",
+    parameters: {
+      type: "object",
+      properties: {
+        world_spec: {
+          type: "object",
+          description: "World specification including dimensions, features, and agent roles"
+        }
+      },
+      required: ["world_spec"]
+    }
+  },
+  {
+    name: "get_world_status",
+    description: "Get current status of a VR world including agent activity and performance",
+    parameters: {
+      type: "object",
+      properties: {
+        world_id: {
+          type: "string",
+          description: "ID of the world to query"
+        }
+      },
+      required: ["world_id"]
+    }
+  },
+  {
+    name: "export_world",
+    description: "Export VR world to specified format",
+    parameters: {
+      type: "object",
+      properties: {
+        world_id: {
+          type: "string",
+          description: "ID of the world to export"
+        },
+        format: {
+          type: "string",
+          enum: ["gltf", "fbx", "usdz", "vrm", "json", "holoscript"],
+          description: "Export format"
+        }
+      },
+      required: ["world_id", "format"]
+    }
+  },
+  {
+    name: "get_agent_registry",
+    description: "Get all registered agents in the spatial communication system",
+    parameters: {
+      type: "object",
+      properties: {
+        filter: {
+          type: "object",
+          description: "Optional filter criteria (status, role, etc.)"
+        }
+      }
+    }
+  },
+  {
+    name: "get_performance_metrics",
+    description: "Get real-time performance metrics for agents and system",
+    parameters: {
+      type: "object",
+      properties: {
+        world_id: {
+          type: "string",
+          description: "Optional world ID to filter metrics"
+        },
+        agent_id: {
+          type: "string",
+          description: "Optional agent ID to filter metrics"
+        }
+      }
+    }
+  },
+  {
+    name: "set_global_config",
+    description: "Set global configuration for spatial communication system",
+    parameters: {
+      type: "object",
+      properties: {
+        config: {
+          type: "object",
+          description: "Configuration object with settings to update"
+        }
+      },
+      required: ["config"]
+    }
+  },
+  {
+    name: "trigger_event",
+    description: "Trigger a system-wide event for agent coordination",
+    parameters: {
+      type: "object",
+      properties: {
+        event_type: {
+          type: "string",
+          description: "Type of event to trigger"
+        },
+        event_data: {
+          type: "object",
+          description: "Event payload data"
+        }
+      },
+      required: ["event_type"]
+    }
+  }
+];
+var Layer3MCPClient = class extends import_events4.EventEmitter {
+  config;
+  agentId;
+  constructor(agentId, config) {
+    super();
+    this.agentId = agentId;
+    this.config = { ...DEFAULT_MCP_CONFIG, ...config };
+  }
+  /**
+   * Execute MCP command
+   */
+  async execute(command, params) {
+    const request = {
+      command,
+      params
+    };
+    try {
+      const response = await this.sendMCPRequest(request);
+      this.emit("command_success", { command, params, response });
+      return response;
+    } catch (error) {
+      this.emit("command_error", { command, params, error });
+      throw error;
+    }
+  }
+  /**
+   * Create new VR world
+   */
+  async createWorld(worldSpec) {
+    const response = await this.execute("create_world", { world_spec: worldSpec });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to create world");
+    }
+    return response.data;
+  }
+  /**
+   * Get world status
+   */
+  async getWorldStatus(worldId) {
+    const response = await this.execute("get_world_status", { world_id: worldId });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to get world status");
+    }
+    return response.data;
+  }
+  /**
+   * Export world
+   */
+  async exportWorld(worldId, format) {
+    const response = await this.execute("export_world", { world_id: worldId, format });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to export world");
+    }
+    return response.data;
+  }
+  /**
+   * Get agent registry
+   */
+  async getAgentRegistry(filter) {
+    const response = await this.execute("get_agent_registry", { filter });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to get agent registry");
+    }
+    return response.data;
+  }
+  /**
+   * Get performance metrics
+   */
+  async getPerformanceMetrics(options) {
+    const response = await this.execute("get_performance_metrics", options || {});
+    if (!response.success) {
+      throw new Error(response.error || "Failed to get performance metrics");
+    }
+    return response.data;
+  }
+  /**
+   * Set global configuration
+   */
+  async setGlobalConfig(config) {
+    const response = await this.execute("set_global_config", { config });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to set global config");
+    }
+  }
+  /**
+   * Trigger system event
+   */
+  async triggerEvent(eventType, eventData) {
+    const response = await this.execute("trigger_event", {
+      event_type: eventType,
+      event_data: eventData
+    });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to trigger event");
+    }
+  }
+  /**
+   * Call MCP tool directly
+   */
+  async callTool(server, tool, args) {
+    try {
+      const response = await this.mcpToolCall(server, tool, args);
+      this.emit("tool_call_success", { server, tool, args, response });
+      return {
+        success: true,
+        data: response,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      this.emit("tool_call_error", { server, tool, args, error });
+      return {
+        success: false,
+        error: error.message,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * Get available MCP tools
+   */
+  getAvailableTools() {
+    return SPATIAL_MCP_TOOLS;
+  }
+  /**
+   * Send MCP request
+   */
+  async sendMCPRequest(request) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(`${this.config.endpoint}/mcp/command`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-mcp-api-key": this.config.apiKey,
+          "x-agent-id": this.agentId
+        },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`MCP HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Call MCP tool via orchestrator
+   */
+  async mcpToolCall(server, tool, args) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(`${this.config.endpoint}/tools/call`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-mcp-api-key": this.config.apiKey
+        },
+        body: JSON.stringify({
+          server,
+          tool,
+          args
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`MCP Tool Call HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var Layer3MCPServer = class extends import_events4.EventEmitter {
+  handlers = /* @__PURE__ */ new Map();
+  worlds = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+    this.registerDefaultHandlers();
+  }
+  /**
+   * Register command handler
+   */
+  registerHandler(command, handler) {
+    this.handlers.set(command, handler);
+  }
+  /**
+   * Handle incoming MCP request
+   */
+  async handleRequest(request, context) {
+    try {
+      const handler = this.handlers.get(request.command);
+      if (!handler) {
+        return {
+          success: false,
+          error: `Unknown command: ${request.command}`,
+          timestamp: Date.now()
+        };
+      }
+      const data = await handler(request.params, context);
+      this.emit("command_handled", { request, context, data });
+      return {
+        success: true,
+        data,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      this.emit("command_error", { request, context, error });
+      return {
+        success: false,
+        error: error.message,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * Register default handlers
+   */
+  registerDefaultHandlers() {
+    this.registerHandler("create_world", async (params, context) => {
+      const worldSpec = params.world_spec;
+      const worldId = worldSpec.world_id || `world-${Date.now()}`;
+      const status = {
+        world_id: worldId,
+        name: worldSpec.name,
+        status: "initializing",
+        active_agents: [],
+        performance: {
+          current_fps: worldSpec.target_fps,
+          target_fps: worldSpec.target_fps,
+          frame_time_avg_ms: 1e3 / worldSpec.target_fps,
+          frame_time_max_ms: 1e3 / worldSpec.target_fps,
+          quality_level: "high"
+        },
+        spatial_conflicts: 0,
+        resource_utilization: {
+          cpu_percent: 0,
+          memory_mb: 0,
+          gpu_percent: 0
+        },
+        uptime_ms: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.worlds.set(worldId, status);
+      this.emit("world_created", { worldId, worldSpec, context });
+      return { world_id: worldId, status };
+    });
+    this.registerHandler("get_world_status", async (params, context) => {
+      const worldId = params.world_id;
+      const status = this.worlds.get(worldId);
+      if (!status) {
+        throw new Error(`World not found: ${worldId}`);
+      }
+      return status;
+    });
+    this.registerHandler("export_world", async (params, context) => {
+      const worldId = params.world_id;
+      const format = params.format;
+      const world = this.worlds.get(worldId);
+      if (!world) {
+        throw new Error(`World not found: ${worldId}`);
+      }
+      this.emit("world_exported", { worldId, format, context });
+      return {
+        url: `https://hololand.io/exports/${worldId}.${format}`,
+        size: 1024 * 1024 * 10
+        // 10MB
+      };
+    });
+    this.registerHandler("get_agent_registry", async (params, context) => {
+      const filter = params.filter;
+      const agents = [];
+      for (const world of this.worlds.values()) {
+        for (const agent of world.active_agents) {
+          if (filter) {
+            if (filter.status && agent.status !== filter.status) continue;
+            if (filter.role && agent.role !== filter.role) continue;
+            if (filter.world_id && world.world_id !== filter.world_id) continue;
+          }
+          agents.push({
+            ...agent,
+            world_id: world.world_id,
+            capabilities: []
+          });
+        }
+      }
+      return {
+        agents,
+        total: agents.length
+      };
+    });
+    this.registerHandler("get_performance_metrics", async (params, context) => {
+      const worldId = params.world_id;
+      const agentId = params.agent_id;
+      const metrics = {
+        timestamp: Date.now(),
+        agents: [],
+        system: {
+          total_fps: 90,
+          target_fps: 90,
+          frame_time_avg_ms: 11.1,
+          frame_time_max_ms: 15,
+          quality_level: "high",
+          cpu_percent: 45,
+          memory_mb: 2048,
+          gpu_percent: 60
+        }
+      };
+      for (const world of this.worlds.values()) {
+        if (worldId && world.world_id !== worldId) continue;
+        for (const agent of world.active_agents) {
+          if (agentId && agent.agent_id !== agentId) continue;
+          metrics.agents.push({
+            agent_id: agent.agent_id,
+            role: agent.role,
+            frame_time_avg_ms: 10,
+            frame_time_max_ms: 12,
+            messages_sent: 0,
+            messages_received: 0,
+            spatial_conflicts: 0
+          });
+        }
+      }
+      return metrics;
+    });
+    this.registerHandler("set_global_config", async (params, context) => {
+      const config = params.config;
+      this.emit("config_updated", { config, context });
+      return { success: true };
+    });
+    this.registerHandler("trigger_event", async (params, context) => {
+      const eventType = params.event_type;
+      const eventData = params.event_data;
+      this.emit("system_event", { eventType, eventData, context });
+      return { success: true };
+    });
+  }
+  /**
+   * Get all worlds
+   */
+  getWorlds() {
+    return Array.from(this.worlds.values());
+  }
+  /**
+   * Update world status
+   */
+  updateWorld(worldId, updates) {
+    const world = this.worlds.get(worldId);
+    if (world) {
+      Object.assign(world, updates);
+      this.emit("world_updated", { worldId, updates });
+    }
+  }
+};
+
+// src/agents/spatial-comms/SpatialCommClient.ts
+var import_events5 = require("events");
+var FrameBudgetTracker = class {
+  targetFps;
+  targetFrameTimeMs;
+  frameTimeSamples = [];
+  maxSamples = 60;
+  // Track last 60 frames
+  qualityLevel = "high";
+  constructor(targetFps = 90) {
+    this.targetFps = targetFps;
+    this.targetFrameTimeMs = 1e3 / targetFps;
+  }
+  /**
+   * Record frame time
+   */
+  recordFrameTime(frameTimeMs) {
+    this.frameTimeSamples.push(frameTimeMs);
+    if (this.frameTimeSamples.length > this.maxSamples) {
+      this.frameTimeSamples.shift();
+    }
+    this.autoAdjustQuality();
+  }
+  /**
+   * Get average frame time
+   */
+  getAverageFrameTime() {
+    if (this.frameTimeSamples.length === 0) return this.targetFrameTimeMs;
+    const sum = this.frameTimeSamples.reduce((a, b) => a + b, 0);
+    return sum / this.frameTimeSamples.length;
+  }
+  /**
+   * Get maximum frame time
+   */
+  getMaxFrameTime() {
+    if (this.frameTimeSamples.length === 0) return this.targetFrameTimeMs;
+    return Math.max(...this.frameTimeSamples);
+  }
+  /**
+   * Get current FPS
+   */
+  getCurrentFps() {
+    const avgFrameTime = this.getAverageFrameTime();
+    return 1e3 / avgFrameTime;
+  }
+  /**
+   * Get budget remaining for current frame
+   */
+  getBudgetRemaining() {
+    const avgFrameTime = this.getAverageFrameTime();
+    return Math.max(0, this.targetFrameTimeMs - avgFrameTime);
+  }
+  /**
+   * Check if within budget
+   */
+  isWithinBudget() {
+    return this.getAverageFrameTime() <= this.targetFrameTimeMs * 1.1;
+  }
+  /**
+   * Get current quality level
+   */
+  getQualityLevel() {
+    return this.qualityLevel;
+  }
+  /**
+   * Set quality level
+   */
+  setQualityLevel(level) {
+    this.qualityLevel = level;
+  }
+  /**
+   * Auto-adjust quality based on performance
+   */
+  autoAdjustQuality() {
+    const avgFrameTime = this.getAverageFrameTime();
+    const targetFrameTime = this.targetFrameTimeMs;
+    if (avgFrameTime > targetFrameTime * 1.3) {
+      this.qualityLevel = "minimal";
+    } else if (avgFrameTime > targetFrameTime * 1.2) {
+      this.qualityLevel = "low";
+    } else if (avgFrameTime > targetFrameTime * 1.1) {
+      this.qualityLevel = "medium";
+    } else {
+      this.qualityLevel = "high";
+    }
+  }
+  /**
+   * Get frame budget stats
+   */
+  getStats() {
+    return {
+      targetFps: this.targetFps,
+      currentFps: this.getCurrentFps(),
+      avgFrameTimeMs: this.getAverageFrameTime(),
+      maxFrameTimeMs: this.getMaxFrameTime(),
+      budgetRemainingMs: this.getBudgetRemaining(),
+      qualityLevel: this.qualityLevel,
+      withinBudget: this.isWithinBudget()
+    };
+  }
+  /**
+   * Reset tracker
+   */
+  reset() {
+    this.frameTimeSamples = [];
+    this.qualityLevel = "high";
+  }
+};
+var SpatialCommClient = class extends import_events5.EventEmitter {
+  agentId;
+  config;
+  // Layer clients
+  layer1;
+  layer2;
+  layer3;
+  // Frame budget tracker
+  frameBudget;
+  // State
+  initialized = false;
+  currentWorldId;
+  constructor(agentId, config) {
+    super();
+    this.agentId = agentId;
+    this.config = {
+      layer1: { ...DEFAULT_SPATIAL_COMM_CONFIG.layer1, ...config?.layer1 || {} },
+      layer2: { ...DEFAULT_SPATIAL_COMM_CONFIG.layer2, ...config?.layer2 || {} },
+      layer3: { ...DEFAULT_SPATIAL_COMM_CONFIG.layer3, ...config?.layer3 || {} }
+    };
+    this.frameBudget = new FrameBudgetTracker(this.config.layer1.targetLatency);
+  }
+  /**
+   * Initialize all layers
+   */
+  async init(options) {
+    if (this.initialized) {
+      throw new Error("Client already initialized");
+    }
+    this.layer1 = new Layer1RealTimeClient(this.agentId, this.config.layer1);
+    await this.layer1.init(options?.useWebRTC);
+    this.layer1.on("message", (msg) => this.emit("layer1:message", msg));
+    this.layer1.on("latency_warning", (data) => this.emit("layer1:latency_warning", data));
+    this.layer2 = new Layer2A2AClient(this.agentId, this.config.layer2);
+    this.layer2.on("message", (msg) => this.emit("layer2:message", msg));
+    this.layer2.on("spatial_conflict", (data) => this.emit("layer2:spatial_conflict", data));
+    this.layer2.on("retry", (data) => this.emit("layer2:retry", data));
+    this.layer3 = new Layer3MCPClient(this.agentId, this.config.layer3);
+    this.layer3.on("command_success", (data) => this.emit("layer3:command_success", data));
+    this.layer3.on("command_error", (data) => this.emit("layer3:command_error", data));
+    this.initialized = true;
+    this.emit("initialized", { agentId: this.agentId });
+  }
+  // ==========================================================================
+  // LAYER 1: REAL-TIME OPERATIONS
+  // ==========================================================================
+  /**
+   * Send position sync (Layer 1)
+   */
+  async syncPosition(position, rotation, scale, velocity) {
+    if (!this.layer1) throw new Error("Layer 1 not initialized");
+    await this.layer1.sendPositionSync(position, rotation, scale, velocity);
+  }
+  /**
+   * Send frame budget update (Layer 1)
+   */
+  async sendFrameBudget() {
+    if (!this.layer1) throw new Error("Layer 1 not initialized");
+    const stats = this.frameBudget.getStats();
+    await this.layer1.sendFrameBudget(
+      stats.avgFrameTimeMs,
+      stats.budgetRemainingMs,
+      stats.targetFps,
+      stats.currentFps,
+      stats.qualityLevel
+    );
+  }
+  /**
+   * Record frame time (updates budget tracker)
+   */
+  recordFrameTime(frameTimeMs) {
+    this.frameBudget.recordFrameTime(frameTimeMs);
+    if (!this.frameBudget.isWithinBudget()) {
+      this.emit("budget_warning", this.frameBudget.getStats());
+    }
+  }
+  /**
+   * Get frame budget stats
+   */
+  getFrameBudgetStats() {
+    return this.frameBudget.getStats();
+  }
+  // ==========================================================================
+  // LAYER 2: COORDINATION OPERATIONS
+  // ==========================================================================
+  /**
+   * Assign task to agent (Layer 2)
+   */
+  async assignTask(toAgent, task) {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    return this.layer2.assignTask(toAgent, task);
+  }
+  /**
+   * Complete task (Layer 2)
+   */
+  async completeTask(taskId, success, result, error) {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    const stats = this.frameBudget.getStats();
+    return this.layer2.completeTask(taskId, success, result, error, {
+      duration_ms: 0,
+      // Would be tracked separately
+      frame_time_avg_ms: stats.avgFrameTimeMs,
+      frame_time_max_ms: stats.maxFrameTimeMs,
+      quality_level: stats.qualityLevel
+    });
+  }
+  /**
+   * Claim spatial region (Layer 2)
+   */
+  async claimSpatialRegion(claimId, boundingBox, priority, durationMs, exclusive = true) {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    return this.layer2.claimSpatialRegion(claimId, boundingBox, priority, durationMs, exclusive);
+  }
+  /**
+   * Request resource (Layer 2)
+   */
+  async requestResource(resourceId, resourceType, amount, priority = "medium") {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    return this.layer2.requestResource(resourceId, resourceType, amount, priority);
+  }
+  /**
+   * Release resource (Layer 2)
+   */
+  async releaseResource(resourceId) {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    return this.layer2.releaseResource(resourceId);
+  }
+  /**
+   * Get spatial claims (Layer 2)
+   */
+  getMyClaims() {
+    if (!this.layer2) throw new Error("Layer 2 not initialized");
+    return this.layer2.getMyClaims();
+  }
+  // ==========================================================================
+  // LAYER 3: METADATA OPERATIONS
+  // ==========================================================================
+  /**
+   * Create world (Layer 3)
+   */
+  async createWorld(worldSpec) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    const result = await this.layer3.createWorld(worldSpec);
+    this.currentWorldId = result.world_id;
+    return result;
+  }
+  /**
+   * Get world status (Layer 3)
+   */
+  async getWorldStatus(worldId) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    const id = worldId || this.currentWorldId;
+    if (!id) throw new Error("No world ID specified");
+    return this.layer3.getWorldStatus(id);
+  }
+  /**
+   * Export world (Layer 3)
+   */
+  async exportWorld(format, worldId) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    const id = worldId || this.currentWorldId;
+    if (!id) throw new Error("No world ID specified");
+    return this.layer3.exportWorld(id, format);
+  }
+  /**
+   * Get agent registry (Layer 3)
+   */
+  async getAgentRegistry(filter) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    return this.layer3.getAgentRegistry(filter);
+  }
+  /**
+   * Get performance metrics (Layer 3)
+   */
+  async getPerformanceMetrics(options) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    return this.layer3.getPerformanceMetrics(options);
+  }
+  /**
+   * Set global configuration (Layer 3)
+   */
+  async setGlobalConfig(config) {
+    if (!this.layer3) throw new Error("Layer 3 not initialized");
+    return this.layer3.setGlobalConfig(config);
+  }
+  // ==========================================================================
+  // LIFECYCLE
+  // ==========================================================================
+  /**
+   * Shutdown client
+   */
+  async shutdown() {
+    if (!this.initialized) return;
+    if (this.layer3) {
+    }
+    if (this.layer2) {
+      await this.layer2.shutdown();
+    }
+    if (this.layer1) {
+      await this.layer1.close();
+    }
+    this.initialized = false;
+    this.emit("shutdown");
+  }
+  /**
+   * Get client status
+   */
+  getStatus() {
+    return {
+      agentId: this.agentId,
+      initialized: this.initialized,
+      currentWorldId: this.currentWorldId,
+      frameBudget: this.frameBudget.getStats(),
+      queueStats: this.layer2?.getQueueStats() || { queueSize: 0, claimCount: 0 }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentManifestBuilder,
+  AgentRegistry,
+  AgentWalletRegistry,
+  BUILTIN_NORMS,
+  CapabilityMatcher,
+  CulturalMemory,
+  DEFAULT_A2A_CONFIG,
+  DEFAULT_MCP_CONFIG,
+  DEFAULT_PHASE_TIMINGS,
+  DEFAULT_REALTIME_CONFIG,
+  DEFAULT_REGISTRY_CONFIG,
+  DEFAULT_SPATIAL_COMM_CONFIG,
+  EffectRow,
+  FederatedRegistryAdapter,
+  FrameBudgetTracker,
+  GCounter,
+  LATENCY_THRESHOLDS,
+  LWWRegister,
+  Layer1RealTimeClient,
+  Layer2A2AClient,
+  Layer3MCPClient,
+  Layer3MCPServer,
+  NormEngine,
+  ORSet,
+  OrchestratorAgent,
+  PHASE_ORDER,
+  PLATFORM_CAPABILITIES,
+  PROTOCOL_COMPATIBILITY,
+  PROTOCOL_VERSION,
+  SPATIAL_MCP_TOOLS,
+  SkillWorkflowEngine,
+  SpatialCommClient,
+  TaskDelegationService,
+  UDPRealTimeTransport,
+  WebRTCRealTimeTransport,
+  createAgentManifest,
+  createAgentState,
+  createMVCPayload,
+  criticalMassForChange,
+  decodeRealTimeMessage,
+  defaultMatcher,
+  embodimentFor,
+  encodeRealTimeMessage,
+  estimatePayloadSize,
+  findAgents,
+  findBestAgent,
+  getCounter,
+  getDefaultRegistry,
+  getRegister,
+  incrementCounter,
+  mergeStates,
+  negotiateHandoff,
+  platformCategory,
+  resetDefaultRegistry,
+  setRegister,
+  signOperation,
+  validateManifest,
+  validatePayloadBudget,
+  verifyOperation
+});