@holoscript/framework 6.0.3 → 6.0.4

package/dist/agents/index.js

@@ -1,4695 +0,0 @@
-// 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
-import { EventEmitter } from "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 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
-import { randomUUID } from "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 = 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: 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, 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
-import { EventEmitter as EventEmitter2 } from "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 EventEmitter2 {
-  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
-import { EventEmitter as EventEmitter3 } from "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 EventEmitter3 {
-  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
-import { EventEmitter as EventEmitter4 } from "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 EventEmitter4 {
-  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 EventEmitter4 {
-  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
-import { EventEmitter as EventEmitter5 } from "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 EventEmitter5 {
-  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 }
-    };
-  }
-};
-export {
-  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,
-  createManifest as createAgentManifest,
-  createAgentState,
-  createMVCPayload,
-  criticalMassForChange,
-  decodeRealTimeMessage,
-  defaultMatcher,
-  embodimentFor,
-  encodeRealTimeMessage,
-  estimatePayloadSize,
-  findAgents,
-  findBestAgent,
-  getCounter,
-  getDefaultRegistry,
-  getRegister,
-  incrementCounter,
-  mergeStates,
-  negotiateHandoff,
-  platformCategory,
-  resetDefaultRegistry,
-  setRegister,
-  signOperation,
-  validateManifest,
-  validatePayloadBudget,
-  verifyOperation
-};