nexus-agents 10.2.0 → 11.0.1

package/dist/{chunk-QRC3QLUQ.js → chunk-HL3EHBKJ.js}

@@ -1,17 +1,18 @@
 import {
   ensureGatewayDiscovered,
+  gatewayDiscoveryGeneration,
   gatewayDiscoveryStatus,
   getAvailabilityCache
-} from "./chunk-LXYT2P2Y.js";
+} from "./chunk-WILZPMEM.js";
 import {
   extractSystemPrompt
 } from "./chunk-QZUG667L.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-XSAUVC6D.js";
+} from "./chunk-NLFCAEEK.js";
 import {
   nexusMkdtempSync
-} from "./chunk-JPFRRNRR.js";
+} from "./chunk-U7HL7FGS.js";
 import {
   AdapterModelError,
   BaseAdapter,
@@ -19,22 +20,23 @@ import {
   createStream,
   planOptionalParams,
   readGatewayTransport,
+  readOpenAICompatEndpoint,
   readOpenAICompatEnv,
   requireApiKey,
   validateApiKeyPresence,
   validateOpenAICompatBaseUrl,
   withGatewayUsageRecording
-} from "./chunk-KLSNDPU6.js";
+} from "./chunk-NZA7EIZO.js";
 import {
   hostnameOf,
   readCustomApiSurface,
   readDirectOpenAiSurface,
   readGatewayEnv,
   redactApiKey
-} from "./chunk-KASBBKAQ.js";
+} from "./chunk-OYAHRYFI.js";
 import {
   probeCli
-} from "./chunk-TW6PJYTP.js";
+} from "./chunk-C73VZSC5.js";
 import {
   BaseCliAdapter,
   ClaudeCliAdapter,
@@ -46,15 +48,18 @@ import {
   getTimeoutForTask,
   listModelsForCli,
   spawnCwd
-} from "./chunk-23QA6GQD.js";
+} from "./chunk-LAUBKK25.js";
 import {
-  getCliCircuitBreakerSnapshot
-} from "./chunk-SX2XWCGA.js";
+  getCliCircuitBreakerSnapshot,
+  getDefaultCliCircuitBreakerRegistry
+} from "./chunk-YIZ25Y4C.js";
 import {
   sanitizeOutput
-} from "./chunk-QM5W3T3O.js";
+} from "./chunk-A7XALVN3.js";
 import {
+  CircularBuffer,
   CliCircuitBreaker,
+  ConfigError,
   DEFAULT_CIRCUIT_BREAKER_CONFIG,
   ErrorCode,
   FALLBACK_CONTEXT_WINDOW,
@@ -64,9 +69,11 @@ import {
   ModelError,
   PROVIDER_ENV_KEYS,
   RETRY_AFTER_CONTEXT_KEY,
+  UNRESOLVED_MODEL_ID,
   accessModeConflict,
   apiArmId,
   asRecord,
+  breakerKeys,
   buildCliCapabilityProfiles,
   buildGatewaySlotRouterArm,
   buildModelInfo,
@@ -81,36 +88,54 @@ import {
   extractNumberField,
   findCanonicalModel,
   findInTreeByCli,
+  gatewayCostGap,
+  gatewaySlotEndpointOf,
   getCliModelName,
   getDefaultModelForCli,
   getErrorMessage,
+  getInTreeCapabilitiesMatrix,
+  getRandomProvider,
   getTimeProvider,
   getTokenEstimator,
   hasGatewaySlotCatalog,
+  isCallerCancelled,
   isCallerInputCliError,
   isCliAdmitted,
   isCliDisabled,
+  isCliName,
+  isDurableCapacityError,
   isDynamicModelsEnabled,
+  isEndpointArmId,
+  isGatewayArmId,
   isHostUnavailableCliError,
   isRateLimitLikeError,
   isRateLimitText,
   isReadOnlyAnalysis,
   isRecord,
+  mapModelErrorToCategory,
   ok,
+  recordRateLimitEvent,
   resolveCliAlias,
   resolveCliModelName,
+  resolveGatewayCostDeclaration,
   resolveGatewayDefault,
   resolveGatewaySlot,
   resolveRetryAfterMs,
   toModelTokenUsage,
+  toRateLimitError,
   unenforcedAccessModeRefusal,
   warnIfGatewayCostUndeclared,
   withEnforcedAccessMode
-} from "./chunk-WKFPKPEM.js";
+} from "./chunk-EBOAFTOG.js";
+import {
+  parseBoolEnv
+} from "./chunk-CH6IBWXH.js";
 import {
   CLI_NAMES,
   CLI_SUBPROCESS_TIMEOUTS,
   CODEX_MCP_TIMEOUTS,
+  TASK_SPECIALIZATION_MATRIX,
+  detectTaskCategory,
   resolveClassGuardMs
 } from "./chunk-4PN3UVZV.js";
 
@@ -235,7 +260,7 @@ var CliToModelAdapter = class {
    * adapter default stays the honest report.
    */
   reportedForwardedModel(forwarded) {
-    if (forwarded === void 0) return void 0;
+    if (forwarded === void 0 || !isCliName(this.cliAdapter.name)) return void 0;
     return findCanonicalModel(this.cliAdapter.name, forwarded)?.id;
   }
   /**
@@ -1630,6 +1655,1019 @@ async function createAutoAdapter(config = {}) {
   }
 }
 
+// src/agents/collaboration/event-bus-helpers.ts
+import { randomUUID } from "node:crypto";
+var DEFAULT_MAX_HISTORY_SIZE = 1e3;
+var MAX_SUBSCRIPTIONS = 500;
+var MAX_TOPIC_PATTERN_LENGTH = 200;
+function patternToRegex(pattern) {
+  if (pattern.length > MAX_TOPIC_PATTERN_LENGTH) {
+    throw new Error(`Topic pattern exceeds maximum length of ${String(MAX_TOPIC_PATTERN_LENGTH)}`);
+  }
+  if (pattern === "*") {
+    return /^.+$/;
+  }
+  const WILDCARD_PLACEHOLDER = "\0WILDCARD\0";
+  const withPlaceholder = pattern.replace(/\*/g, WILDCARD_PLACEHOLDER);
+  const escaped = withPlaceholder.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withWildcards = escaped.replace(new RegExp(WILDCARD_PLACEHOLDER, "g"), "[^.]+");
+  return new RegExp(`^${withWildcards}$`);
+}
+function topicMatchesPattern(topic, regex) {
+  return regex.test(topic);
+}
+function generateEventId() {
+  return `evt-${String(getTimeProvider().now())}-${randomUUID().slice(0, 8)}`;
+}
+function generateSubscriptionId() {
+  return `sub-${String(getTimeProvider().now())}-${randomUUID().slice(0, 8)}`;
+}
+function applyHistoryFilters(history, filter) {
+  let result = history;
+  if (filter.topic !== void 0 && filter.topic !== "") {
+    const regex = patternToRegex(filter.topic);
+    result = result.filter((e) => topicMatchesPattern(e.topic, regex));
+  }
+  if (filter.sessionId !== void 0 && filter.sessionId !== "") {
+    result = result.filter((e) => e.sessionId === filter.sessionId);
+  }
+  if (filter.correlationId !== void 0 && filter.correlationId !== "") {
+    result = result.filter((e) => e.correlationId === filter.correlationId);
+  }
+  return applyTimestampFilters(result, filter);
+}
+function applyTimestampFilters(result, filter) {
+  let filtered = result;
+  if (filter.after !== void 0 && filter.after !== "") {
+    const afterTimestamp = filter.after;
+    filtered = filtered.filter((e) => e.timestamp > afterTimestamp);
+  }
+  if (filter.before !== void 0 && filter.before !== "") {
+    const beforeTimestamp = filter.before;
+    filtered = filtered.filter((e) => e.timestamp < beforeTimestamp);
+  }
+  return filtered;
+}
+function applyHistoryLimit(result, filter) {
+  if (filter.limit !== void 0 && filter.limit > 0) {
+    return result.slice(-filter.limit);
+  }
+  return result;
+}
+function enrichEvent(event) {
+  return {
+    ...event,
+    eventId: event.eventId || generateEventId(),
+    timestamp: event.timestamp || getTimeProvider().nowIso()
+  };
+}
+function countMatchingSubscribers(topic, subscriptions) {
+  let count = 0;
+  for (const record of subscriptions.values()) {
+    if (topicMatchesPattern(topic, record.regex)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+// src/agents/collaboration/event-bus.ts
+var CollaborationEventBus = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  history;
+  asyncHandling;
+  logger;
+  stats = {
+    eventsEmitted: 0,
+    subscriptionsCreated: 0,
+    activeSubscriptions: 0,
+    historySize: 0,
+    errorCount: 0
+  };
+  constructor(options = {}) {
+    const maxHistorySize = options.maxHistorySize ?? DEFAULT_MAX_HISTORY_SIZE;
+    this.history = new CircularBuffer(maxHistorySize);
+    this.asyncHandling = options.asyncHandling ?? false;
+    this.logger = options.logger;
+  }
+  /**
+   * Emit an event synchronously to all matching subscribers.
+   */
+  emit(event) {
+    const enrichedEvent = enrichEvent(event);
+    this.addToHistory(enrichedEvent);
+    this.stats.eventsEmitted++;
+    this.logger?.debug("Event emitted", {
+      topic: enrichedEvent.topic,
+      eventId: enrichedEvent.eventId,
+      subscriberCount: countMatchingSubscribers(enrichedEvent.topic, this.subscriptions)
+    });
+    for (const record of this.subscriptions.values()) {
+      if (topicMatchesPattern(enrichedEvent.topic, record.regex)) {
+        this.invokeListener(record, enrichedEvent);
+      }
+    }
+  }
+  /**
+   * Emit an event and wait for all async handlers to complete.
+   */
+  async emitAsync(event) {
+    const enrichedEvent = enrichEvent(event);
+    this.addToHistory(enrichedEvent);
+    this.stats.eventsEmitted++;
+    this.logger?.debug("Async event emitted", {
+      topic: enrichedEvent.topic,
+      eventId: enrichedEvent.eventId
+    });
+    const promises = [];
+    for (const record of this.subscriptions.values()) {
+      if (topicMatchesPattern(enrichedEvent.topic, record.regex)) {
+        promises.push(this.invokeListenerAsync(record, enrichedEvent));
+      }
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Subscribe to events matching a topic pattern.
+   */
+  subscribe(pattern, listener) {
+    if (this.subscriptions.size >= MAX_SUBSCRIPTIONS) {
+      throw new Error(
+        `Maximum subscription limit reached (${String(MAX_SUBSCRIPTIONS)}). Unsubscribe from unused patterns before adding new ones.`
+      );
+    }
+    const id = generateSubscriptionId();
+    const regex = patternToRegex(pattern);
+    const record = {
+      id,
+      pattern,
+      regex,
+      listener
+    };
+    this.subscriptions.set(id, record);
+    this.stats.subscriptionsCreated++;
+    this.stats.activeSubscriptions = this.subscriptions.size;
+    this.logger?.debug("Subscription created", { id, pattern });
+    return {
+      id,
+      pattern,
+      unsubscribe: () => {
+        this.unsubscribe(id);
+      }
+    };
+  }
+  /**
+   * Unsubscribe from events.
+   */
+  unsubscribe(subscriptionId) {
+    const existed = this.subscriptions.delete(subscriptionId);
+    if (existed) {
+      this.stats.activeSubscriptions = this.subscriptions.size;
+      this.logger?.debug("Subscription removed", { subscriptionId });
+    }
+  }
+  /**
+   * Get event history matching filter criteria.
+   */
+  getHistory(filter) {
+    const historyArray = this.history.toArray();
+    if (filter === void 0) {
+      return historyArray;
+    }
+    const filtered = applyHistoryFilters(historyArray, filter);
+    return applyHistoryLimit(filtered, filter);
+  }
+  /**
+   * Clear event history.
+   */
+  clearHistory() {
+    this.history.clear();
+    this.stats.historySize = 0;
+    this.logger?.debug("History cleared");
+  }
+  /**
+   * Get event bus statistics.
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Check if a topic pattern has any subscribers.
+   */
+  hasSubscribers(pattern) {
+    const regex = patternToRegex(pattern);
+    for (const record of this.subscriptions.values()) {
+      if (topicMatchesPattern(pattern, record.regex) || topicMatchesPattern(record.pattern, regex)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Add event to history, maintaining size limit via O(1) circular buffer.
+   * @see Issue #407 - Performance optimization
+   */
+  addToHistory(event) {
+    this.history.push(event);
+    this.stats.historySize = this.history.size;
+  }
+  /**
+   * Invoke a listener synchronously with error isolation.
+   */
+  invokeListener(record, event) {
+    try {
+      const result = record.listener(event);
+      if (this.asyncHandling && result instanceof Promise) {
+        result.catch((error) => {
+          this.handleListenerError(record, event, error);
+        });
+      }
+    } catch (error) {
+      this.handleListenerError(record, event, error);
+    }
+  }
+  /**
+   * Invoke a listener asynchronously.
+   */
+  async invokeListenerAsync(record, event) {
+    try {
+      await record.listener(event);
+    } catch (error) {
+      this.handleListenerError(record, event, error);
+    }
+  }
+  /**
+   * Handle listener errors without disrupting other listeners.
+   */
+  handleListenerError(record, event, error) {
+    this.stats.errorCount++;
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    this.logger?.error("Event listener error", errorObj, {
+      subscriptionId: record.id,
+      pattern: record.pattern,
+      eventTopic: event.topic,
+      eventId: event.eventId
+    });
+  }
+};
+var globalBus = null;
+function getGlobalEventBus(options) {
+  globalBus ??= new CollaborationEventBus(options);
+  return globalBus;
+}
+function createEvent(topic, payload, options) {
+  return {
+    eventId: generateEventId(),
+    timestamp: getTimeProvider().nowIso(),
+    topic,
+    payload,
+    sessionId: options?.sessionId,
+    correlationId: options?.correlationId
+  };
+}
+
+// src/agents/collaboration/event-bus-topics.ts
+var EventTopics = {
+  // Session events
+  SESSION_CREATED: "session.created",
+  SESSION_STATUS_CHANGED: "session.status_changed",
+  SESSION_PARTICIPANT_JOINED: "session.participant_joined",
+  SESSION_RESULT_SUBMITTED: "session.result_submitted",
+  SESSION_FINALIZED: "session.finalized",
+  SESSION_ALL: "session.*",
+  // Message events
+  MESSAGE_SENT: "message.sent",
+  MESSAGE_RECEIVED: "message.received",
+  MESSAGE_ALL: "message.*",
+  // Agent events
+  AGENT_TASK_DELEGATED: "agent.task_delegated",
+  AGENT_RESULT_BROADCAST: "agent.result_broadcast",
+  AGENT_ALL: "agent.*",
+  // Consensus events
+  CONSENSUS_VOTE_REQUESTED: "consensus.vote_requested",
+  CONSENSUS_VOTE_CAST: "consensus.vote_cast",
+  CONSENSUS_REACHED: "consensus.reached",
+  CONSENSUS_ALL: "consensus.*",
+  // Protocol events
+  PROTOCOL_STARTED: "protocol.started",
+  PROTOCOL_ITERATION: "protocol.iteration",
+  PROTOCOL_COMPLETED: "protocol.completed",
+  PROTOCOL_ALL: "protocol.*",
+  // Aegean phase events (Issue #216)
+  AEGEAN_ROUND_STARTED: "protocol.aegean.round_started",
+  AEGEAN_VOTE_COLLECTED: "protocol.aegean.vote_collected",
+  AEGEAN_QUORUM_DETECTED: "protocol.aegean.quorum_detected",
+  AEGEAN_ALL: "protocol.aegean.*",
+  // Reflexion phase events (Issue #216)
+  REFLEXION_CRITIQUE_STARTED: "protocol.reflexion.critique_started",
+  REFLEXION_CRITIQUE_COMPLETED: "protocol.reflexion.critique_completed",
+  REFLEXION_SYNTHESIS: "protocol.reflexion.synthesis",
+  REFLEXION_ALL: "protocol.reflexion.*",
+  // Trinity phase events (Issue #216)
+  TRINITY_PHASE_STARTED: "protocol.trinity.phase_started",
+  TRINITY_PHASE_COMPLETED: "protocol.trinity.phase_completed",
+  TRINITY_ALL: "protocol.trinity.*",
+  // Byzantine detection events (Issue #218)
+  BYZANTINE_WEIGHT_UPDATED: "byzantine.weight_updated",
+  BYZANTINE_PATTERN_DETECTED: "byzantine.pattern_detected",
+  BYZANTINE_AGENT_FLAGGED: "byzantine.agent_flagged",
+  BYZANTINE_COLLUSION_SUSPECTED: "byzantine.collusion_suspected",
+  BYZANTINE_ALL: "byzantine.*",
+  // Wildcard
+  ALL: "*"
+};
+
+// src/adapters/resilient-adapter.ts
+function createResilientAdapter(config) {
+  return new ResilientAdapter(config);
+}
+var ResilientAdapter = class {
+  logger;
+  currentAdapter;
+  currentSelection;
+  hasEverDetected = false;
+  health;
+  preferredCli;
+  failoverCallbacks = /* @__PURE__ */ new Set();
+  circuitBreakerRegistry;
+  circuitListener;
+  disposed = false;
+  defaultCliTimeoutMs;
+  /** Inflight detection promise for coalescing concurrent calls (Issue #1423). */
+  detectionPromise;
+  /** The {@link gatewayDiscoveryGeneration} the current selection was made under (#6659). */
+  detectedAtGeneration = 0;
+  constructor(config) {
+    this.logger = config?.logger ?? createLogger({ component: "resilient-adapter" });
+    this.preferredCli = config?.preferredCli;
+    this.defaultCliTimeoutMs = config?.defaultCliTimeoutMs;
+    if (config?.circuitBreakerRegistry !== void 0) {
+      this.attachCircuitBreakerRegistry(config.circuitBreakerRegistry);
+    }
+  }
+  // --- IModelAdapter properties (forwarded) ---
+  /**
+   * Before detection a CLI-pinned proxy identifies as the CLI it was asked
+   * for (`cli-<name>`, the id its detected `CliToModelAdapter` will carry);
+   * an unpinned proxy stays `resilient-proxy`.
+   *
+   * #6119: the voter fallover (#3587) keys seats by this id and skips a seat
+   * whose key equals the fallback's. When codex never detected, the pinned
+   * seat and the unpinned default were BOTH `resilient-proxy`, so the seat was
+   * read as "already on the fallback" and errored instead of falling over.
+   */
+  get providerId() {
+    if (this.currentAdapter !== void 0) return this.currentAdapter.providerId;
+    return this.preferredCli === void 0 ? "resilient-proxy" : `cli-${this.preferredCli}`;
+  }
+  get modelId() {
+    return this.currentAdapter?.modelId ?? UNRESOLVED_MODEL_ID;
+  }
+  get capabilities() {
+    return this.currentAdapter?.capabilities ?? [];
+  }
+  /**
+   * The gateway arm of the adapter currently serving this proxy, when a
+   * gateway model serves it (#6604 family slots); otherwise undefined. A
+   * telemetry writer handed this proxy reads it (`isGatewayModelAdapter`) to
+   * price the call by the gateway's `NEXUS_GATEWAY_COST` declaration instead
+   * of a list price.
+   */
+  get gatewayArm() {
+    const arm = this.currentAdapter?.gatewayArm;
+    return typeof arm === "string" && isEndpointArmId(arm) ? arm : void 0;
+  }
+  // --- IModelAdapter methods ---
+  async complete(request) {
+    const adapter = await this.ensureAdapter();
+    if (adapter === void 0) {
+      return err(new ModelError("No model adapter available"));
+    }
+    const result = await adapter.complete(request);
+    if (!result.ok) {
+      if (isRateLimitLikeError(result.error)) {
+        const rlError = toRateLimitError(result.error, adapter.providerId);
+        recordRateLimitEvent({
+          provider: adapter.providerId,
+          timestamp: getTimeProvider().now(),
+          retryAfterMs: rlError.retryAfterMs
+        });
+        this.logger.warn("Rate limit detected", {
+          provider: adapter.providerId,
+          retryAfterMs: rlError.retryAfterMs
+        });
+      }
+      this.recordBreakerFailure(adapter, result.error);
+    }
+    return result;
+  }
+  async *stream(request) {
+    const adapter = await this.ensureAdapter();
+    if (adapter === void 0) {
+      throw new ModelError("No model adapter available");
+    }
+    yield* adapter.stream(request);
+  }
+  async countTokens(text) {
+    const adapter = await this.ensureAdapter();
+    if (adapter === void 0) {
+      return 0;
+    }
+    return adapter.countTokens(text);
+  }
+  validateConfig() {
+    if (this.currentAdapter !== void 0) {
+      return this.currentAdapter.validateConfig();
+    }
+    return ok(void 0);
+  }
+  // --- IResilientAdapter methods ---
+  getHealth() {
+    return this.health;
+  }
+  async refresh() {
+    this.currentAdapter = void 0;
+    this.currentSelection = void 0;
+    this.detectionPromise = void 0;
+    await this.ensureAdapter();
+  }
+  setPreferredCli(cli) {
+    this.preferredCli = cli;
+    this.currentAdapter = void 0;
+    this.currentSelection = void 0;
+  }
+  onFailover(cb) {
+    this.failoverCallbacks.add(cb);
+    return () => {
+      this.failoverCallbacks.delete(cb);
+    };
+  }
+  /**
+   * Attach a circuit breaker registry for automatic failover.
+   * When the current adapter's circuit opens, the cached adapter
+   * is cleared so the next call triggers re-detection.
+   */
+  /** The registry arming failover, or undefined if this adapter is unarmed (#4659). */
+  getCircuitBreakerRegistry() {
+    return this.circuitBreakerRegistry;
+  }
+  attachCircuitBreakerRegistry(registry) {
+    this.detachCircuitBreakerRegistry();
+    this.circuitBreakerRegistry = registry;
+    this.circuitListener = (event) => {
+      this.handleCircuitStateChange(event);
+    };
+    registry.addGlobalStateChangeListener(this.circuitListener);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.detachCircuitBreakerRegistry();
+    this.failoverCallbacks.clear();
+  }
+  // --- Private methods ---
+  async ensureAdapter() {
+    if (this.currentAdapter === void 0) {
+      await ensureGatewayDiscovered();
+    } else {
+      void ensureGatewayDiscovered();
+    }
+    if (this.currentAdapter !== void 0 && this.detectedAtGeneration !== gatewayDiscoveryGeneration()) {
+      this.currentAdapter = void 0;
+      this.currentSelection = void 0;
+      this.hasEverDetected = false;
+    }
+    if (this.currentAdapter !== void 0) {
+      return this.currentAdapter;
+    }
+    this.detectionPromise ??= this.detectAdapter().finally(() => {
+      this.detectionPromise = void 0;
+    });
+    return this.detectionPromise;
+  }
+  async detectAdapter() {
+    const generation = gatewayDiscoveryGeneration();
+    try {
+      this.logger.info("Detecting model adapter (lazy)");
+      const config = {
+        logger: this.logger,
+        ...this.preferredCli !== void 0 && { preferredCli: this.preferredCli },
+        ...this.defaultCliTimeoutMs !== void 0 && {
+          defaultCliTimeoutMs: this.defaultCliTimeoutMs
+        }
+      };
+      const selection = await createAutoAdapter(config);
+      this.applySelection(selection);
+      this.detectedAtGeneration = generation;
+      return this.currentAdapter;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      this.logger.warn("No model adapter available", { error: message });
+      this.health = {
+        source: "api",
+        state: "unavailable",
+        selectedAt: /* @__PURE__ */ new Date(),
+        failoverCount: this.health?.failoverCount ?? 0,
+        lastError: message
+      };
+      return void 0;
+    }
+  }
+  applySelection(selection) {
+    const isFailover = this.hasEverDetected;
+    const outgoingHealth = this.health;
+    this.currentAdapter = selection.adapter;
+    this.currentSelection = selection;
+    this.hasEverDetected = true;
+    const source = mapSelectionSource(selection);
+    const failoverCount = (this.health?.failoverCount ?? 0) + (isFailover ? 1 : 0);
+    this.health = {
+      source,
+      state: "healthy",
+      selectedAt: /* @__PURE__ */ new Date(),
+      failoverCount,
+      ...selection.modelVerified !== void 0 && { modelVerified: selection.modelVerified }
+    };
+    this.logger.info("Adapter selected", {
+      source: selection.source,
+      name: selection.name,
+      model: selection.adapter.modelId,
+      provider: selection.adapter.providerId,
+      failover: isFailover
+    });
+    if (isFailover) {
+      this.emitFailover(
+        outgoingHealth === void 0 ? void 0 : { ...outgoingHealth, failoverCount }
+      );
+    }
+  }
+  /**
+   * Record a direct-API failure to the circuit breaker so API adapters get the
+   * same degradation/failover learning that CLI subprocess failures get (#3423).
+   *
+   * The shared internal key policy preserves selected CLI slots, prefixes API
+   * vendor names, and isolates gateway endpoints by slot (#7070).
+   *
+   * A CLI selection is NOT recorded here (#6712). Its CLI adapter's retry loop
+   * (`executeCliRetryLoop`) has already recorded the failure in the same
+   * registry under its route key, with the category taken from
+   * the CliError code. Recording it again counted every CLI failure twice (the
+   * second time usually as `unknown`), so the breaker opened at about half its
+   * configured threshold. Only a direct-API selection, which has no inner
+   * recorder, is recorded by this layer.
+   *
+   * Rate-limit failures are deliberately skipped here: they are already recorded
+   * by the `recordRateLimitEvent` telemetry branch in `complete()`, and the
+   * breaker counts rate limits as failures by default
+   * (`countRateLimitsAsFailures`), so recording them again would double-count.
+   *
+   * Security (#3422 constraint): the logged payload carries only `provider` and
+   * `category` — never `error.message`, the request, or the ModelError object,
+   * any of which could embed credentials.
+   */
+  recordBreakerFailure(adapter, error) {
+    if (this.circuitBreakerRegistry === void 0 || this.currentSelection === void 0) {
+      return;
+    }
+    if (this.currentSelection.source === "cli") return;
+    if (isCallerCancelled(error)) return;
+    const category = mapModelErrorToCategory(error);
+    const breaker = this.circuitBreakerRegistry.getArmBreaker(
+      breakerKeys.forArm({
+        name: this.currentSelection.name,
+        model: adapter.modelId,
+        gatewayArm: this.gatewayArm
+      })
+    );
+    if (isDurableCapacityError(error)) {
+      breaker.recordFailure(category);
+      this.logger.warn("Durable capacity cap recorded to circuit breaker", {
+        provider: adapter.providerId,
+        category
+      });
+      return;
+    }
+    if (category === "rate_limit" || isRateLimitLikeError(error)) {
+      return;
+    }
+    breaker.recordFailure(category);
+    this.logger.warn("API failure recorded to circuit breaker", {
+      provider: adapter.providerId,
+      category
+    });
+  }
+  handleCircuitStateChange(event) {
+    if (event.newState !== "open") return;
+    const selection = this.currentSelection;
+    if (selection === void 0 || breakerKeys.forArm({
+      name: selection.name,
+      model: this.currentAdapter?.modelId,
+      gatewayArm: this.gatewayArm
+    }) !== event.armId) {
+      return;
+    }
+    this.logger.warn("Current adapter circuit opened, clearing cache for re-detection", {
+      cli: event.cliName,
+      reason: event.reason
+    });
+    this.currentAdapter = void 0;
+    this.currentSelection = void 0;
+    if (this.health !== void 0) {
+      this.health = {
+        ...this.health,
+        state: "degraded",
+        lastError: event.reason
+      };
+    }
+  }
+  /**
+   * Emit the failover signal describing the adapter we failed AWAY FROM (#4670).
+   *
+   * This used to read `this.health`, which `applySelection` had just replaced
+   * with the incoming adapter's `state: 'healthy'`. So every `adapter.failover`
+   * payload said healthy, `unhealthyCliFrom` (`observability/failover-signals.ts`)
+   * returned undefined for all of them, and `signal.swarm_unhealthy` was never
+   * produced by this — the more reliable of its two producers.
+   *
+   * An undefined outgoing health emits NOTHING rather than falling back to the
+   * current one. Falling back would silently restore the old behaviour, and a
+   * failover whose prior state we cannot describe is not evidence that the
+   * prior adapter was healthy.
+   */
+  emitFailover(outgoingHealth) {
+    const info = outgoingHealth;
+    if (info === void 0) return;
+    for (const cb of this.failoverCallbacks) {
+      try {
+        cb(info);
+      } catch (error) {
+        this.logger.debug("Failover callback error", { error: getErrorMessage(error) });
+      }
+    }
+    try {
+      const eventBus = getGlobalEventBus();
+      eventBus.emit({
+        eventId: `failover-${getTimeProvider().now().toString(36)}-${getRandomProvider().random().toString(36).slice(2, 8)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        topic: "adapter.failover",
+        payload: info
+      });
+    } catch (error) {
+      this.logger.debug("CollaborationEventBus emit failed during failover", {
+        error: getErrorMessage(error)
+      });
+    }
+  }
+  detachCircuitBreakerRegistry() {
+    if (this.circuitBreakerRegistry !== void 0 && this.circuitListener !== void 0) {
+      this.circuitBreakerRegistry.removeGlobalStateChangeListener(this.circuitListener);
+    }
+    this.circuitBreakerRegistry = void 0;
+    this.circuitListener = void 0;
+  }
+};
+function mapSelectionSource(selection) {
+  if (selection.source === "cli") {
+    return selection.name;
+  }
+  return "api";
+}
+
+// src/adapters/model-bound-adapter.ts
+var ModelBoundAdapter = class {
+  constructor(slot, boundModel) {
+    this.slot = slot;
+    this.boundModel = boundModel;
+  }
+  slot;
+  boundModel;
+  get providerId() {
+    return this.slot.providerId;
+  }
+  get modelId() {
+    return this.slot.modelId;
+  }
+  get capabilities() {
+    return this.slot.capabilities;
+  }
+  bind(request) {
+    return request.model !== void 0 ? request : { ...request, model: this.boundModel };
+  }
+  complete(request) {
+    return this.slot.complete(this.bind(request));
+  }
+  stream(request) {
+    return this.slot.stream(this.bind(request));
+  }
+  countTokens(text) {
+    return this.slot.countTokens(text);
+  }
+  validateConfig() {
+    return this.slot.validateConfig();
+  }
+  getHealth() {
+    return this.slot.getHealth();
+  }
+  refresh() {
+    return this.slot.refresh();
+  }
+  setPreferredCli(cli) {
+    this.slot.setPreferredCli(cli);
+  }
+  onFailover(cb) {
+    return this.slot.onFailover(cb);
+  }
+  getCircuitBreakerRegistry() {
+    return this.slot.getCircuitBreakerRegistry?.();
+  }
+  /** No-op: the shared slot adapter belongs to the registry, which disposes it. */
+  dispose() {
+  }
+};
+
+// src/adapters/unified-registry.ts
+var UnifiedAdapterRegistry = class {
+  logger;
+  defaultCliTimeoutMs;
+  /**
+   * Per-arm adapter cache. CLI slots are created lazily by
+   * {@link getAdapterForCli}; `api:*` arms enter only through
+   * {@link registerApiArm} and are never synthesised (#4392).
+   */
+  cliAdapters = /* @__PURE__ */ new Map();
+  /** Default adapter for unscoped requests. */
+  defaultAdapter;
+  constructor(config) {
+    this.logger = config?.logger ?? createLogger({ component: "unified-registry" });
+    this.defaultCliTimeoutMs = config?.defaultCliTimeoutMs;
+    this.logger.info("UnifiedAdapterRegistry initialized", {
+      categories: TASK_SPECIALIZATION_MATRIX.length,
+      models: getInTreeCapabilitiesMatrix().models.length
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Public API
+  // --------------------------------------------------------------------------
+  /** Logger used by this registry. Exposed so singleton helpers can warn. */
+  getLogger() {
+    return this.logger;
+  }
+  /**
+   * Get adapter for a task category. Routing is re-resolved on every read
+   * (#3185) so a post-startup overlay/registry update propagates without a
+   * restart. Falls back to default adapter if category unknown.
+   */
+  getAdapter(category) {
+    const routing = this.getRouting(category);
+    if (routing === void 0) {
+      this.logger.warn("Unknown task category, using default", { category });
+      return this.getDefault();
+    }
+    return this.getAdapterForCli(routing.primaryCli);
+  }
+  /**
+   * Get adapter for a free-text task description.
+   * Detects category from keywords, falls back to default.
+   */
+  getAdapterForTask(taskDescription) {
+    const match = detectTaskCategory(taskDescription);
+    if (match !== null) {
+      this.logger.debug("Task category detected", {
+        category: match.category,
+        cli: match.primaryCli
+      });
+      return this.getAdapterForCli(match.primaryCli);
+    }
+    return this.getDefault();
+  }
+  /**
+   * Get adapter pinned to a specific CLI.
+   * Creates and caches one IResilientAdapter per CLI.
+   */
+  getAdapterForCli(cli) {
+    const cached = this.cliAdapters.get(cli);
+    if (cached !== void 0) return cached;
+    const raw = createResilientAdapter({
+      logger: this.logger,
+      preferredCli: cli,
+      // #4659: the SHARED registry — the same one that already gates
+      // voter-panel availability (#4330). Per-adapter registries would let one
+      // adapter keep routing to a CLI another has already seen fail.
+      circuitBreakerRegistry: getDefaultCliCircuitBreakerRegistry(),
+      ...this.defaultCliTimeoutMs !== void 0 && {
+        defaultCliTimeoutMs: this.defaultCliTimeoutMs
+      }
+    });
+    const adapter = raw;
+    this.cliAdapters.set(cli, adapter);
+    this.logger.info("Created CLI-specific adapter", {
+      cli
+    });
+    return adapter;
+  }
+  /**
+   * Get the adapter for a routing arm (#4392). A CLI slot resolves exactly as
+   * {@link getAdapterForCli} (created lazily, cached, armed with the shared
+   * breaker registry). An `api:*` arm resolves to what {@link registerApiArm}
+   * supplied, or `undefined` — never to a CLI slot, and never by creating one.
+   */
+  getAdapterForArm(arm) {
+    if (isCliName(arm)) {
+      return this.getAdapterForCli(arm);
+    }
+    return this.cliAdapters.get(arm);
+  }
+  /**
+   * Register an `api:*` arm's adapter under its endpoint identity (#4392).
+   * Refuses built-in vendor arms (`api:anthropic`, `api:openai`, `api:google`, `api:gemini`)
+   * to prevent hijacking or redirecting vendor traffic without authorization.
+   * Accepts a dynamic `EndpointArmId`; the id is re-validated at runtime
+   * because the `EndpointArmId` type admits any `api:` string, so a cast from an
+   * unvalidated name is exactly what this refuses.
+   * Registering an id twice replaces (and disposes) the earlier adapter.
+   * CLI-slot behaviour is untouched. Endpoint arms are observable here and in
+   * the shared breaker registry. The router factory admits them only with
+   * NEXUS_ROUTE_GATEWAY_ARMS opt-in and a cost declaration (#7151). An arm
+   * registered without NEXUS_GATEWAY_COST is warned about once here, even
+   * when routing is disabled (#4392 increment 2).
+   */
+  registerApiArm(arm, adapter) {
+    if (!isEndpointArmId(arm)) {
+      throw new Error(`Invalid api arm id: ${JSON.stringify(arm)} (expected api:<endpoint>)`);
+    }
+    if (!isGatewayArmId(arm) || arm === "api:gemini") {
+      throw new Error(`Cannot overwrite built-in vendor arm: ${arm}`);
+    }
+    this.cliAdapters.get(arm)?.dispose();
+    this.cliAdapters.set(arm, adapter);
+    this.logger.info("Registered api arm adapter", { arm });
+    warnIfGatewayCostUndeclared(arm, this.logger);
+  }
+  /**
+   * Get adapter for a model preference string (e.g., "claude-opus-4-6").
+   * Resolves the model to its CLI via the canonical registry.
+   * Falls back to default adapter if model not recognized.
+   *
+   * An exact match returns the CLI slot adapter bound to the matched registry
+   * id, so the model reaches the CLI instead of its default (#6599). A prefix
+   * match routes to the CLI only, as before: the name was not an entry.
+   */
+  getAdapterForModel(modelPreference) {
+    const allModels = getInTreeCapabilitiesMatrix().models;
+    const exact = allModels.find(
+      (m) => m.id === modelPreference || m.cliAlias === modelPreference || m.cliModelName === modelPreference
+    );
+    const prefix = exact ?? [...allModels].filter((m) => modelPreference.startsWith(m.id)).sort((a, b) => b.id.length - a.id.length)[0];
+    const model = prefix;
+    if (model !== void 0) {
+      this.logger.debug("Model resolved to CLI", {
+        model: modelPreference,
+        cli: model.cliName
+      });
+      const slot = this.getAdapterForCli(model.cliName);
+      return exact !== void 0 ? new ModelBoundAdapter(slot, exact.id) : slot;
+    }
+    this.logger.debug("Model not in registry, using default", {
+      model: modelPreference
+    });
+    return this.getDefault();
+  }
+  /**
+   * Get adapter for an expert role (e.g., "code_expert").
+   * Uses ROLE_TO_TASK_CATEGORY mapping → task specialization → CLI.
+   */
+  getAdapterForRole(role) {
+    const category = ROLE_TO_CATEGORY[role];
+    if (category !== void 0) return this.getAdapter(category);
+    return this.getDefault();
+  }
+  /**
+   * Get the default adapter (no CLI preference — auto-detection priority).
+   */
+  getDefault() {
+    if (this.defaultAdapter !== void 0) return this.defaultAdapter;
+    const raw = createResilientAdapter({
+      logger: this.logger,
+      circuitBreakerRegistry: getDefaultCliCircuitBreakerRegistry(),
+      ...this.defaultCliTimeoutMs !== void 0 && {
+        defaultCliTimeoutMs: this.defaultCliTimeoutMs
+      }
+    });
+    this.defaultAdapter = raw;
+    return this.defaultAdapter;
+  }
+  /**
+   * Get snapshot of registry state for observability/debugging. Routing is
+   * re-resolved on read (#3185) so the snapshot reflects the live registry.
+   */
+  getSnapshot() {
+    return {
+      taskRouting: TASK_SPECIALIZATION_MATRIX.map((spec) => this.resolveRouting(spec)),
+      cachedArms: [...this.cliAdapters.keys()],
+      availableModels: getInTreeCapabilitiesMatrix().models.length
+    };
+  }
+  /**
+   * Resolve the routing for a specific category.
+   *
+   * Computed on every read (#3185) rather than cached at construction, so a
+   * post-startup model-registry / overlay update (e.g. a default-model change
+   * surfaced via `getDefaultModelForCli`) propagates to routing decisions
+   * without a process restart. The matrix is ~10 categories — the per-read
+   * resolution cost is negligible.
+   */
+  getRouting(category) {
+    const spec = TASK_SPECIALIZATION_MATRIX.find((s) => s.category === category);
+    if (spec === void 0) return void 0;
+    return this.resolveRouting(spec);
+  }
+  /**
+   * Dispose all cached adapters.
+   */
+  dispose() {
+    for (const adapter of this.cliAdapters.values()) {
+      adapter.dispose();
+    }
+    this.cliAdapters.clear();
+    this.defaultAdapter?.dispose();
+    this.defaultAdapter = void 0;
+    this.logger.info("UnifiedAdapterRegistry disposed");
+  }
+  // --------------------------------------------------------------------------
+  // Private
+  // --------------------------------------------------------------------------
+  /**
+   * Resolve one specialization-matrix row into a routing entry, re-reading the
+   * primary model from the (overlay-aware) model registry each call (#3185).
+   */
+  resolveRouting(spec) {
+    return {
+      category: spec.category,
+      primaryCli: spec.primaryCli,
+      secondaryCli: spec.secondaryCli,
+      primaryModel: resolveDefaultModel(spec.primaryCli)
+    };
+  }
+};
+var ROLE_TO_CATEGORY = {
+  code_expert: "code_generation",
+  architecture_expert: "architecture",
+  security_expert: "security_review",
+  documentation_expert: "documentation",
+  testing_expert: "testing",
+  devops_expert: "devops",
+  research_expert: "research",
+  pm_expert: "planning",
+  ux_expert: "planning",
+  infrastructure_expert: "devops"
+};
+function resolveDefaultModel(cli) {
+  if (isCliName(cli)) {
+    return getDefaultModelForCli(cli);
+  }
+  return cli;
+}
+var globalRegistry;
+function createUnifiedRegistry(config) {
+  return new UnifiedAdapterRegistry(config);
+}
+function claimGlobalRegistry(logger5, config) {
+  if (globalRegistry === void 0) {
+    globalRegistry = new UnifiedAdapterRegistry({ ...config, logger: logger5 });
+  } else if (config !== void 0 && Object.keys(config).length > 0) {
+    logger5.warn(
+      "UnifiedAdapterRegistry claim ignored configuration: singleton already initialized",
+      {
+        providedKeys: Object.keys(config)
+      }
+    );
+  }
+  return globalRegistry;
+}
+var RegistryAlreadyInitializedError = class extends ConfigError {
+  constructor(providedKeys) {
+    super(
+      `UnifiedAdapterRegistry singleton is already initialized, so getGlobalRegistry() cannot apply the supplied config (keys: ${providedKeys.join(", ")}). Call resetGlobalRegistry() first if reconfiguration is intentional, or getGlobalRegistry() with no config to use the existing instance; claimGlobalRegistry(logger) is the idempotent way to name the logger.`,
+      { context: { providedKeys: [...providedKeys] } }
+    );
+    this.name = "RegistryAlreadyInitializedError";
+  }
+};
+function getGlobalRegistry(config) {
+  if (globalRegistry === void 0) {
+    globalRegistry = new UnifiedAdapterRegistry(config);
+    return globalRegistry;
+  }
+  if (config !== void 0 && Object.keys(config).length > 0) {
+    throw new RegistryAlreadyInitializedError(Object.keys(config));
+  }
+  return globalRegistry;
+}
+function resetGlobalRegistry() {
+  globalRegistry?.dispose();
+  globalRegistry = void 0;
+}
+
 // src/cli-adapters/parsers/agy-parser.ts
 import { z as z2 } from "zod";
 var AgyUsageSchema = z2.object({
@@ -4012,8 +5050,33 @@ function createAllAdapters(logger5, codexTransport) {
       adapters.set(armId, adapter);
     }
   }
+  appendRegisteredEndpointArms(adapters, logger5 ?? factoryLogger);
   return adapters;
 }
+function appendRegisteredEndpointArms(adapters, logger5) {
+  if (!parseBoolEnv("NEXUS_ROUTE_GATEWAY_ARMS", false)) return;
+  const registry = getGlobalRegistry();
+  const configuredArm = `api:${readOpenAICompatEndpoint(process.env, logger5)}`;
+  const slotEndpoints = new Set([...adapters.values()].map(gatewaySlotEndpointOf));
+  for (const arm of registry.getSnapshot().cachedArms) {
+    if (!isEndpointArmId(arm)) continue;
+    if (slotEndpoints.has(arm)) {
+      logger5.debug("Gateway routing arm omitted: family slot already represents endpoint", { arm });
+      continue;
+    }
+    if (resolveGatewayCostDeclaration(arm) === void 0) {
+      logger5.warn("Gateway routing arm excluded: NEXUS_GATEWAY_COST declaration required", {
+        arm,
+        reason: gatewayCostGap(arm)
+      });
+      continue;
+    }
+    const endpoint = registry.getAdapterForArm(arm);
+    if (endpoint === void 0) continue;
+    if (arm === configuredArm) adapters.delete("api:custom-openai");
+    adapters.set(arm, createModelToCliAdapter(endpoint, { name: arm }));
+  }
+}
 function sharedSlotAvailability() {
   let cache;
   return (cli, fresh) => {
@@ -4122,6 +5185,15 @@ export {
   ClaudeAdapter,
   createClaudeAdapter,
   SdkAdapter,
-  createAutoAdapter
+  getGlobalEventBus,
+  createEvent,
+  EventTopics,
+  ModelBoundAdapter,
+  UnifiedAdapterRegistry,
+  createUnifiedRegistry,
+  claimGlobalRegistry,
+  RegistryAlreadyInitializedError,
+  getGlobalRegistry,
+  resetGlobalRegistry
 };
-//# sourceMappingURL=chunk-QRC3QLUQ.js.map
+//# sourceMappingURL=chunk-HL3EHBKJ.js.map