nexus-agents 2.171.0 → 2.172.0

package/dist/index.js

@@ -7,6 +7,8 @@ import {
   ARTIFACT_TYPES,
   AUDIT_PIPELINE_TEMPLATE,
   ActivationStrategySchema,
+  AdapterConfigSchema,
+  AdapterFactory,
   AgentEventSchema,
   AgentMessageSchema,
   AgentRoleSchema,
@@ -73,6 +75,7 @@ import {
   DEFAULT_POLICIES,
   DEFAULT_RBAC,
   DEFAULT_RESOURCE_LIMITS,
+  DEFAULT_RETRY_CONFIG,
   DEFAULT_ROLE_MAPPINGS,
   DEFAULT_SKILL_LIBRARY_CONFIG,
   DEFAULT_SKILL_LOADER_CONFIG,
@@ -121,7 +124,10 @@ import {
   ForestResultSchema,
   ForestStateSchema,
   ForestStatisticsSchema,
+  GEMINI_MODELS,
+  GEMINI_MODEL_ALIASES,
   GENERAL_PIPELINE_TEMPLATE,
+  GeminiAdapter,
   GeminiResponseParser,
   GeneratedTestSchema,
   GetJobResultInputSchema,
@@ -148,6 +154,8 @@ import {
   MemoryWriteInputSchema,
   ModelSelectionSchema,
   NodeStateSchema,
+  OLLAMA_MODELS,
+  OllamaAdapter,
   OrchestrateInputSchema,
   OrchestrateOutputSchema,
   OrchestrationError,
@@ -175,11 +183,13 @@ import {
   PruningStrategy,
   QualitySignalsSchema,
   QueryTraceInputSchema,
+  RateLimiter,
   ReasoningDepthSchema,
   ReasoningNodeMetadataSchema,
   ReasoningNodeSchema,
   ReasoningStepTypeSchema,
   ReasoningTreeSchema,
+  RecoverableExpert,
   RegistryError,
   RegistryImportInputSchema,
   RepoAnalyzeInputSchema,
@@ -192,6 +202,7 @@ import {
   ResearchQueryInputSchema,
   ResearchSynthesizeInputSchema,
   ResultAggregator,
+  RetryExhaustedError,
   ReviewProtocol,
   ReviewResponseMessageSchema,
   RoutingDecisionSchema,
@@ -285,6 +296,7 @@ import {
   buildDependencyGraph,
   buildDependencyGraph2,
   buildPrReviewProposal,
+  calculateDelay,
   calculateDistributionStats,
   calculateMinSampleSize,
   calculateRegret,
@@ -296,6 +308,7 @@ import {
   checkPipelinePolicy,
   checkpointToResult,
   chunkByDirectory,
+  classifyExpertFailure,
   classifyTask,
   cleanupCheckpoint,
   clearTemplateCache,
@@ -333,15 +346,18 @@ import {
   createExecutionPlan,
   createFeedbackIntegration,
   createFeedbackSubscriber,
+  createGeminiAdapter,
   createInitializedWorkflowEngine,
   createInteractionGraph,
   createIsolatedRegistry,
   createMcpLogger,
+  createOllamaAdapter,
   createOrchestrator,
   createOrchestratorFactory,
   createOutcomeFeedbackCollector,
   createProductionWorkflowEngine,
   createProtocolFactory,
+  createRateLimiter,
   createRealWorkflowEngine,
   createResultAggregator,
   createRoutingDecision,
@@ -425,6 +441,7 @@ import {
   initializeBuiltInTemplates,
   initializeEventBusBridge,
   isCancelled,
+  isRetryableError as isRetryableError2,
   isStepCompleted,
   listTemplateIds,
   loadCheckpointState,
@@ -521,8 +538,10 @@ import {
   validateSkillProvenance,
   validateWorkflow,
   validateWorkflowDependencies,
-  withLogging
-} from "./chunk-YIQ5Z7LV.js";
+  withLogging,
+  withRetry,
+  withRetryWrapper
+} from "./chunk-C7TWCMK4.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -556,7 +575,7 @@ import {
   getKnownNexusVarNames,
   startStdioServer,
   validateNexusEnv
-} from "./chunk-E53VLN73.js";
+} from "./chunk-YKVO32BI.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
@@ -680,7 +699,7 @@ import {
   ProposalSchema,
   ProposalStatusSchema,
   REJECTION_CATEGORIES,
-  RateLimiter,
+  RateLimiter as RateLimiter2,
   RejectionCategorySchema,
   VOTING_THRESHOLDS,
   VoteSchema,
@@ -780,7 +799,6 @@ import {
   createCliDetectionCache,
   estimateTaskComplexity,
   executeCliRetryLoop,
-  extractRequestSystemPrompt,
   getAvailableClis,
   getTimeoutForTask,
   getTimeoutForTaskAuto,
@@ -803,17 +821,14 @@ import {
   fromArray,
   mergeStreams,
   reduceStream,
-  requireApiKey,
   skip,
   take,
   takeUntil,
   tapStream,
   transformStream,
-  validateApiKeyPresence,
   withTimeout
 } from "./chunk-4KVAHGMB.js";
 import {
-  DEFAULTS,
   PROVIDER_ENV_KEYS
 } from "./chunk-QFS5VOB6.js";
 import "./chunk-76Q63KJM.js";
@@ -880,17 +895,13 @@ import {
   detectTrend,
   err,
   extractNonErrorMessage,
-  findCanonicalModel,
   formatZodError,
   generateWeatherReport,
-  getCliModelName,
   getDefaultAvailableModelsCache,
   getDefaultRegistry,
-  getErrorMessage,
   getOutcomeStore,
   getRandomProvider,
   getTimeProvider,
-  getTokenEstimator,
   isErr,
   isOk,
   isZodError,
@@ -910,1242 +921,6 @@ import "./chunk-AXTD4TFK.js";
 import "./chunk-DHVMSIT5.js";
 import "./chunk-ZPWHCABL.js";
 
-// src/adapters/factory.ts
-import { z } from "zod";
-var AdapterConfigSchema = z.object({
-  /** Provider identifier (e.g., 'anthropic', 'openai') */
-  providerId: z.string().min(1, "Provider ID is required"),
-  /** Model identifier (e.g., 'claude-sonnet-4', 'gpt-4o') */
-  modelId: z.string().min(1, "Model ID is required"),
-  /** API key for authentication (optional, may come from environment) */
-  apiKey: z.string().optional(),
-  /** Base URL for the API (optional, uses provider default) */
-  baseUrl: z.url("Base URL must be a valid URL").optional(),
-  /** Request timeout in milliseconds */
-  timeout: z.number().positive("Timeout must be positive").optional(),
-  /** Maximum number of retries for failed requests */
-  maxRetries: z.number().int("Max retries must be an integer").min(0).optional()
-});
-var AdapterFactory = class {
-  /**
-   * Registry mapping provider IDs to their creator functions.
-   */
-  registry = /* @__PURE__ */ new Map();
-  /**
-   * Registers an adapter creator for a provider.
-   *
-   * @param providerId - Unique identifier for the provider (e.g., 'anthropic')
-   * @param creator - Factory function that creates adapters for this provider
-   * @param options - Registration options
-   * @returns Result indicating success or failure
-   *
-   * @example
-   * ```typescript
-   * const result = factory.register('anthropic', (config) => new ClaudeAdapter(config));
-   * if (!result.ok) {
-   *   console.error('Registration failed:', result.error.message);
-   * }
-   * ```
-   */
-  register(providerId, creator, options = {}) {
-    const { allowOverwrite = false } = options;
-    if (!providerId || providerId.trim() === "") {
-      return err(
-        new ConfigError("Provider ID cannot be empty", {
-          context: { providerId }
-        })
-      );
-    }
-    if (this.registry.has(providerId) && !allowOverwrite) {
-      return err(
-        new ConfigError(`Provider '${providerId}' is already registered`, {
-          context: { providerId, existingProviders: this.listProviders() }
-        })
-      );
-    }
-    this.registry.set(providerId, creator);
-    return ok(void 0);
-  }
-  /**
-   * Unregisters an adapter creator for a provider.
-   *
-   * @param providerId - The provider ID to unregister
-   * @returns Result indicating whether the provider was removed
-   */
-  unregister(providerId) {
-    if (!providerId || providerId.trim() === "") {
-      return err(
-        new ConfigError("Provider ID cannot be empty", {
-          context: { providerId }
-        })
-      );
-    }
-    const deleted = this.registry.delete(providerId);
-    return ok(deleted);
-  }
-  /**
-   * Creates an adapter instance for the specified configuration.
-   *
-   * Validates the configuration against the schema, looks up the provider
-   * in the registry, and invokes the creator function to produce an adapter.
-   *
-   * @param config - Adapter configuration specifying provider and settings
-   * @returns Result containing the adapter or a ConfigError
-   *
-   * @example
-   * ```typescript
-   * const result = factory.create({
-   *   providerId: 'anthropic',
-   *   modelId: 'claude-sonnet-4',
-   *   timeout: 30000,
-   *   maxRetries: 3
-   * });
-   *
-   * if (result.ok) {
-   *   const response = await result.value.complete(request);
-   * } else {
-   *   console.error('Failed to create adapter:', result.error.message);
-   * }
-   * ```
-   */
-  create(config) {
-    const validationResult = this.validateConfig(config);
-    if (!validationResult.ok) {
-      return validationResult;
-    }
-    const validConfig = validationResult.value;
-    const creator = this.registry.get(validConfig.providerId);
-    if (creator === void 0) {
-      return err(
-        new ConfigError(`Provider '${validConfig.providerId}' is not registered`, {
-          context: {
-            providerId: validConfig.providerId,
-            availableProviders: this.listProviders()
-          }
-        })
-      );
-    }
-    return this.invokeCreator(creator, validConfig);
-  }
-  /**
-   * Validates adapter configuration against the schema.
-   */
-  validateConfig(config) {
-    const result = AdapterConfigSchema.safeParse(config);
-    if (!result.success) {
-      return err(
-        new ConfigError(`Invalid adapter configuration: ${formatZodError(result.error)}`, {
-          context: {
-            config: this.sanitizeConfig(config),
-            validationErrors: result.error.issues
-          }
-        })
-      );
-    }
-    return ok(result.data);
-  }
-  /**
-   * Invokes the creator function to create an adapter.
-   */
-  invokeCreator(creator, config) {
-    try {
-      return ok(creator(config));
-    } catch (error) {
-      return this.handleCreatorError(error, config);
-    }
-  }
-  /**
-   * Handles errors thrown by adapter creator functions.
-   */
-  handleCreatorError(error, config) {
-    const message = getErrorMessage(error);
-    const baseOptions = {
-      context: { providerId: config.providerId, modelId: config.modelId }
-    };
-    if (error instanceof Error) {
-      return err(
-        new ConfigError(`Failed to create adapter: ${message}`, {
-          ...baseOptions,
-          cause: error
-        })
-      );
-    }
-    return err(new ConfigError(`Failed to create adapter: ${message}`, baseOptions));
-  }
-  /**
-   * Checks if a provider is registered.
-   *
-   * @param providerId - The provider ID to check
-   * @returns True if the provider is registered
-   */
-  hasProvider(providerId) {
-    return this.registry.has(providerId);
-  }
-  /**
-   * Returns a list of all registered provider IDs.
-   *
-   * @returns Array of provider identifiers
-   */
-  listProviders() {
-    return Array.from(this.registry.keys());
-  }
-  /**
-   * Returns the number of registered providers.
-   *
-   * @returns Count of registered providers
-   */
-  get size() {
-    return this.registry.size;
-  }
-  /**
-   * Clears all registered providers.
-   * Useful for testing or resetting the factory state.
-   */
-  clear() {
-    this.registry.clear();
-  }
-  /**
-   * Sanitizes configuration for logging by removing sensitive fields.
-   *
-   * @param config - Configuration to sanitize
-   * @returns Sanitized configuration safe for logging
-   */
-  sanitizeConfig(config) {
-    const sanitized = { ...config };
-    if (config.apiKey !== void 0) {
-      sanitized["apiKey"] = "[REDACTED]";
-    }
-    return sanitized;
-  }
-};
-
-// src/adapters/rate-limiter.ts
-var RateLimiter2 = class {
-  capacity;
-  refillRate;
-  refillInterval;
-  tokens;
-  lastRefillTime;
-  /**
-   * Creates a new RateLimiter instance.
-   *
-   * @param config - Configuration options
-   * @throws {RateLimitError} If configuration is invalid
-   */
-  constructor(config) {
-    this.validateConfig(config);
-    this.capacity = config.capacity;
-    this.refillRate = config.refillRate;
-    this.refillInterval = config.refillInterval ?? 100;
-    this.tokens = config.capacity;
-    this.lastRefillTime = getTimeProvider().now();
-  }
-  /**
-   * Validates the configuration parameters.
-   */
-  validateConfig(config) {
-    if (config.capacity <= 0) {
-      throw new RateLimitError("Capacity must be a positive number", {
-        context: { capacity: config.capacity }
-      });
-    }
-    if (config.refillRate <= 0) {
-      throw new RateLimitError("Refill rate must be a positive number", {
-        context: { refillRate: config.refillRate }
-      });
-    }
-    if (config.refillInterval !== void 0 && config.refillInterval <= 0) {
-      throw new RateLimitError("Refill interval must be a positive number", {
-        context: { refillInterval: config.refillInterval }
-      });
-    }
-  }
-  /**
-   * Refills tokens based on elapsed time since last refill.
-   * Called automatically before token operations.
-   */
-  refill() {
-    const now = getTimeProvider().now();
-    const elapsedMs = now - this.lastRefillTime;
-    const elapsedSeconds = elapsedMs / 1e3;
-    const tokensToAdd = elapsedSeconds * this.refillRate;
-    if (tokensToAdd >= 1) {
-      this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
-      this.lastRefillTime = now;
-    }
-  }
-  /**
-   * Attempts to acquire the specified number of tokens.
-   *
-   * @param tokens - Number of tokens to acquire (default: 1)
-   * @returns true if tokens were acquired, false if rate limited
-   *
-   * @example
-   * ```typescript
-   * if (limiter.tryAcquire(5)) {
-   *   // Acquired 5 tokens
-   * }
-   * ```
-   */
-  tryAcquire(tokens = 1) {
-    if (tokens <= 0) {
-      return true;
-    }
-    if (tokens > this.capacity) {
-      return false;
-    }
-    this.refill();
-    if (this.tokens >= tokens) {
-      this.tokens -= tokens;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Attempts to acquire tokens and returns a Result with detailed information.
-   *
-   * @param tokens - Number of tokens to acquire (default: 1)
-   * @returns Result containing void on success, or RateLimitExceeded on failure
-   *
-   * @example
-   * ```typescript
-   * const result = limiter.acquire(5);
-   * if (!result.ok) {
-   *   console.log(`Retry after ${result.error.retryAfterMs}ms`);
-   * }
-   * ```
-   */
-  acquire(tokens = 1) {
-    if (tokens <= 0) {
-      return ok(void 0);
-    }
-    if (tokens > this.capacity) {
-      return err({
-        type: "rate_limit_exceeded",
-        requested: tokens,
-        available: this.tokens,
-        retryAfterMs: Infinity
-      });
-    }
-    this.refill();
-    if (this.tokens >= tokens) {
-      this.tokens -= tokens;
-      return ok(void 0);
-    }
-    const deficit = tokens - this.tokens;
-    const retryAfterMs = Math.ceil(deficit / this.refillRate * 1e3);
-    return err({
-      type: "rate_limit_exceeded",
-      requested: tokens,
-      available: Math.floor(this.tokens),
-      retryAfterMs
-    });
-  }
-  /**
-   * Waits until the specified number of tokens are available, then acquires them.
-   *
-   * @param tokens - Number of tokens to acquire (default: 1)
-   * @returns Promise that resolves when tokens are acquired
-   * @throws {RateLimitError} If tokens exceed capacity (would wait forever)
-   *
-   * @example
-   * ```typescript
-   * await limiter.waitForTokens(10);
-   * // 10 tokens acquired
-   * ```
-   */
-  async waitForTokens(tokens = 1) {
-    if (tokens <= 0) {
-      return;
-    }
-    if (tokens > this.capacity) {
-      throw new RateLimitError(
-        `Cannot acquire ${String(tokens)} tokens: exceeds capacity of ${String(this.capacity)}`,
-        { context: { requested: tokens, capacity: this.capacity } }
-      );
-    }
-    while (!this.tryAcquire(tokens)) {
-      await this.sleep(this.refillInterval);
-    }
-  }
-  /**
-   * Sleeps for the specified duration.
-   */
-  sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
-  }
-  /**
-   * Returns the current number of available tokens.
-   * Performs a refill before returning the count.
-   *
-   * @returns Number of available tokens (may be fractional)
-   */
-  getRemainingTokens() {
-    this.refill();
-    return this.tokens;
-  }
-  /**
-   * Returns the number of whole tokens available.
-   *
-   * @returns Integer number of available tokens
-   */
-  getAvailableTokens() {
-    return Math.floor(this.getRemainingTokens());
-  }
-  /**
-   * Resets the rate limiter to its initial state.
-   * The bucket is refilled to capacity.
-   */
-  reset() {
-    this.tokens = this.capacity;
-    this.lastRefillTime = getTimeProvider().now();
-  }
-  /**
-   * Returns the bucket's maximum capacity.
-   */
-  getCapacity() {
-    return this.capacity;
-  }
-  /**
-   * Returns the refill rate in tokens per second.
-   */
-  getRefillRate() {
-    return this.refillRate;
-  }
-  /**
-   * Calculates the time in milliseconds until the specified tokens are available.
-   *
-   * @param tokens - Number of tokens needed (default: 1)
-   * @returns Time in milliseconds until tokens are available, 0 if already available
-   */
-  getTimeUntilAvailable(tokens = 1) {
-    if (tokens <= 0) {
-      return 0;
-    }
-    if (tokens > this.capacity) {
-      return Infinity;
-    }
-    this.refill();
-    if (this.tokens >= tokens) {
-      return 0;
-    }
-    const deficit = tokens - this.tokens;
-    return Math.ceil(deficit / this.refillRate * 1e3);
-  }
-};
-function createRateLimiter(config) {
-  return new RateLimiter2(config);
-}
-
-// src/adapters/retry.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: DEFAULTS.RETRY_DEFAULTS.maxRetries,
-  baseDelayMs: DEFAULTS.RETRY_DEFAULTS.baseDelayMs,
-  maxDelayMs: DEFAULTS.RETRY_DEFAULTS.maxDelayMs,
-  jitterFactor: DEFAULTS.RETRY_DEFAULTS.jitterFactor
-};
-var RetryExhaustedError = class extends NexusError {
-  /** Number of attempts made */
-  attempts;
-  /** The last error encountered */
-  lastError;
-  constructor(attempts, lastError) {
-    const message = `All ${String(attempts)} retry attempts exhausted`;
-    const options = {
-      code: ErrorCode.MODEL_ERROR,
-      context: {
-        attempts,
-        lastErrorMessage: lastError instanceof Error ? lastError.message : String(lastError)
-      }
-    };
-    if (lastError instanceof Error) {
-      options.cause = lastError;
-    }
-    super(message, options);
-    this.name = "RetryExhaustedError";
-    this.attempts = attempts;
-    this.lastError = lastError;
-  }
-};
-function calculateDelay(attempt, config) {
-  const exponentialDelay = config.baseDelayMs * Math.pow(2, attempt);
-  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
-  const jitterRange = cappedDelay * config.jitterFactor;
-  const jitter = (getRandomProvider().random() * 2 - 1) * jitterRange;
-  return Math.max(0, Math.floor(cappedDelay + jitter));
-}
-var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
-  408,
-  // Request Timeout
-  429,
-  // Too Many Requests
-  500,
-  // Internal Server Error
-  502,
-  // Bad Gateway
-  503,
-  // Service Unavailable
-  504
-  // Gateway Timeout
-]);
-var NON_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
-  400,
-  // Bad Request
-  401,
-  // Unauthorized
-  403,
-  // Forbidden
-  404,
-  // Not Found
-  405,
-  // Method Not Allowed
-  409,
-  // Conflict
-  410,
-  // Gone
-  422
-  // Unprocessable Entity
-]);
-var RETRYABLE_ERROR_PATTERNS = [
-  /ECONNRESET/i,
-  /ECONNREFUSED/i,
-  /ETIMEDOUT/i,
-  /ENOTFOUND/i,
-  /ENETUNREACH/i,
-  /EAI_AGAIN/i,
-  /socket hang up/i,
-  /network/i,
-  /timeout/i,
-  /timed out/i,
-  /aborted/i
-];
-function getStatusCode(error) {
-  if (error === null || error === void 0) {
-    return void 0;
-  }
-  if (typeof error === "object") {
-    const errorObj = error;
-    if (typeof errorObj["status"] === "number") {
-      return errorObj["status"];
-    }
-    if (typeof errorObj["response"] === "object" && errorObj["response"] !== null) {
-      const response = errorObj["response"];
-      if (typeof response["status"] === "number") {
-        return response["status"];
-      }
-    }
-    if (typeof errorObj["statusCode"] === "number") {
-      return errorObj["statusCode"];
-    }
-  }
-  return void 0;
-}
-function isRetryableError2(error) {
-  if (error === null || error === void 0) {
-    return false;
-  }
-  const statusCode = getStatusCode(error);
-  if (statusCode !== void 0) {
-    if (NON_RETRYABLE_STATUS_CODES.has(statusCode)) {
-      return false;
-    }
-    if (RETRYABLE_STATUS_CODES.has(statusCode)) {
-      return true;
-    }
-  }
-  if (error instanceof NexusError) {
-    const retryableCodes = [
-      ErrorCode.MODEL_RATE_LIMITED,
-      ErrorCode.MODEL_TIMEOUT,
-      ErrorCode.TIMEOUT_ERROR,
-      ErrorCode.RATE_LIMIT_ERROR,
-      // #3317 finding #7: a model temporarily unavailable (503/overloaded) is
-      // transient — retry. (MODEL_NOT_FOUND stays non-retryable: retry won't help.)
-      ErrorCode.MODEL_UNAVAILABLE
-    ];
-    return retryableCodes.includes(error.code);
-  }
-  if (error instanceof Error) {
-    const message = error.message;
-    for (const pattern of RETRYABLE_ERROR_PATTERNS) {
-      if (pattern.test(message)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function mergeConfig(config) {
-  return {
-    maxRetries: config.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
-    baseDelayMs: config.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
-    maxDelayMs: config.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
-    jitterFactor: config.jitterFactor ?? DEFAULT_RETRY_CONFIG.jitterFactor
-  };
-}
-async function withRetry(operation, options = {}) {
-  const config = mergeConfig(options.config ?? {});
-  const isRetryable = options.isRetryable ?? isRetryableError2;
-  const onRetry = options.onRetry;
-  const maxAttempts = config.maxRetries + 1;
-  let lastError;
-  let attemptsMade = 0;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    attemptsMade = attempt + 1;
-    try {
-      const result = await operation();
-      return ok(result);
-    } catch (error) {
-      lastError = error;
-      const isLastAttempt = attempt === maxAttempts - 1;
-      if (isLastAttempt || !isRetryable(error)) {
-        break;
-      }
-      const delayMs = calculateDelay(attempt, config);
-      if (onRetry) {
-        onRetry({
-          attempt: attempt + 1,
-          maxAttempts,
-          delayMs,
-          error
-        });
-      }
-      await sleep(delayMs);
-    }
-  }
-  return err(new RetryExhaustedError(attemptsMade, lastError));
-}
-function withRetryWrapper(fn, options = {}) {
-  return (...args) => withRetry(() => fn(...args), options);
-}
-
-// src/adapters/ollama-adapter.ts
-import { Ollama } from "ollama";
-
-// src/adapters/abort-utils.ts
-var AbortError = class extends Error {
-  name = "AbortError";
-  constructor(message = "Operation aborted") {
-    super(message);
-  }
-};
-function raceAbort(promise, signal) {
-  if (signal === void 0) return promise;
-  if (signal.aborted) return Promise.reject(new AbortError());
-  return new Promise((resolve3, reject) => {
-    const onAbort = () => {
-      reject(new AbortError());
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve3(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      }
-    );
-  });
-}
-
-// src/adapters/ollama-adapter.ts
-var OLLAMA_MODELS = {
-  LLAMA3_8B: "llama3:8b",
-  LLAMA3_70B: "llama3:70b",
-  LLAMA3_1_8B: "llama3.1:8b",
-  LLAMA3_2_3B: "llama3.2:3b",
-  MISTRAL: "mistral",
-  MISTRAL_NEMO: "mistral-nemo",
-  CODELLAMA: "codellama",
-  CODELLAMA_34B: "codellama:34b",
-  DEEPSEEK_CODER: "deepseek-coder",
-  QWEN2_5_CODER: "qwen2.5-coder",
-  PHI3: "phi3",
-  GEMMA2: "gemma2"
-};
-var DEFAULT_OLLAMA_HOST = "http://localhost:11434";
-var DEFAULT_MAX_TOKENS = 2048;
-function mapStopReason(reason) {
-  if (reason === void 0 || reason === "") return "end_turn";
-  switch (reason) {
-    case "stop":
-      return "end_turn";
-    case "length":
-      return "max_tokens";
-    case "tool_calls":
-      return "tool_use";
-    default:
-      return "end_turn";
-  }
-}
-function mapOllamaMessageToContent(message) {
-  const content = [];
-  const messageContent = message.content;
-  if (messageContent !== "" && messageContent.length > 0) {
-    content.push({ type: "text", text: messageContent });
-  }
-  const toolCalls = message.tool_calls;
-  if (toolCalls !== void 0 && toolCalls.length > 0) {
-    for (const tc of toolCalls) {
-      content.push({
-        type: "tool_use",
-        id: `tool_${String(getTimeProvider().now())}_${getRandomProvider().random().toString(36).slice(2, 9)}`,
-        name: tc.function.name,
-        input: tc.function.arguments
-      });
-    }
-  }
-  if (content.length === 0) content.push({ type: "text", text: "" });
-  return content;
-}
-function mapMessage(message) {
-  if (typeof message.content === "string") {
-    return { role: message.role, content: message.content };
-  }
-  const textParts = message.content.filter((b) => b.type === "text").map((b) => b.text);
-  const ollamaMessage = { role: message.role, content: textParts.join("\n") };
-  const toolResult = message.content.find(
-    (b) => b.type === "tool_result"
-  );
-  if (toolResult !== void 0) {
-    ollamaMessage.content = toolResult.content;
-    ollamaMessage.tool_name = toolResult.tool_use_id;
-  }
-  return ollamaMessage;
-}
-function mapTool(tool) {
-  const fn = { name: tool.name, description: tool.description };
-  const schema = tool.inputSchema;
-  const hasProperties = Object.keys(schema).length > 0;
-  if (hasProperties) {
-    fn.parameters = schema;
-  }
-  return { type: "function", function: fn };
-}
-function getModelCapabilities(modelId) {
-  const caps = [ModelCapability.COMPLETION, ModelCapability.STREAMING];
-  const lower = modelId.toLowerCase();
-  const toolModels = [
-    "llama3",
-    "mistral",
-    "qwen",
-    "deepseek",
-    "command-r",
-    "hermes",
-    "functionary"
-  ];
-  if (toolModels.some((m) => lower.includes(m))) caps.push(ModelCapability.TOOL_USE);
-  const visionModels = ["llava", "bakllava", "moondream", "llama3.2-vision"];
-  if (visionModels.some((m) => lower.includes(m))) caps.push(ModelCapability.VISION);
-  return caps;
-}
-var OllamaAdapter = class extends BaseAdapter {
-  client;
-  constructor(config) {
-    const baseUrl = config.baseUrl ?? DEFAULT_OLLAMA_HOST;
-    const baseConfig = {
-      providerId: "ollama",
-      modelId: config.modelId,
-      capabilities: getModelCapabilities(config.modelId),
-      baseUrl
-    };
-    if (config.timeout !== void 0) baseConfig.timeout = config.timeout;
-    if (config.maxRetries !== void 0) baseConfig.maxRetries = config.maxRetries;
-    super(baseConfig);
-    this.client = new Ollama({ host: baseUrl, headers: config.headers });
-  }
-  validateConfig() {
-    const baseResult = super.validateConfig();
-    if (!baseResult.ok) return baseResult;
-    if (this.modelId === "" || this.modelId.trim() === "") {
-      return err(
-        new ConfigError("Ollama model ID is required", { context: { providerId: this.providerId } })
-      );
-    }
-    return ok(void 0);
-  }
-  async complete(request) {
-    this.logRequest(request);
-    try {
-      const params = this.buildRequestParams(request);
-      const chatPromise = this.client.chat({ ...params, stream: false });
-      const response = await raceAbort(chatPromise, request.signal);
-      const result = this.mapResponse(response);
-      this.logResponse(result);
-      return ok(result);
-    } catch (error) {
-      return err(this.transformError(error));
-    }
-  }
-  async *stream(request) {
-    this.logRequest(request);
-    const [controller, iterable] = createStream();
-    this.executeStream(request, controller).catch((error) => {
-      controller.error(this.transformError(error));
-    });
-    yield* iterable;
-  }
-  countTokens(text) {
-    return Promise.resolve(getTokenEstimator().estimateText(text, "generic"));
-  }
-  async executeStream(request, controller) {
-    try {
-      const params = this.buildRequestParams(request);
-      const stream = await this.client.chat({ ...params, stream: true });
-      controller.push({ type: "message_start", message: { model: this.modelId } });
-      let hasStartedBlock = false;
-      for await (const chunk of stream) {
-        if (!hasStartedBlock) {
-          controller.push({
-            type: "content_block_start",
-            index: 0,
-            contentBlock: { type: "text", text: "" }
-          });
-          hasStartedBlock = true;
-        }
-        const chunkContent = chunk.message.content;
-        if (chunkContent.length > 0) {
-          controller.push({
-            type: "content_block_delta",
-            index: 0,
-            delta: { type: "text_delta", text: chunkContent }
-          });
-        }
-        if (chunk.done) {
-          controller.push({ type: "content_block_stop", index: 0 });
-          controller.push({
-            type: "message_delta",
-            delta: { stop_reason: mapStopReason(chunk.done_reason) },
-            usage: this.calcUsage(chunk)
-          });
-          controller.push({ type: "message_stop" });
-        }
-      }
-      controller.complete();
-    } catch (error) {
-      controller.error(this.transformError(error));
-    }
-  }
-  buildOptions(request) {
-    const options = {
-      num_predict: request.maxTokens ?? DEFAULT_MAX_TOKENS
-    };
-    if (request.temperature !== void 0) options["temperature"] = request.temperature;
-    if (request.stop !== void 0 && request.stop.length > 0) options["stop"] = request.stop;
-    return options;
-  }
-  applyFormatAndTools(params, request) {
-    if (request.tools !== void 0 && request.tools.length > 0)
-      params.tools = request.tools.map(mapTool);
-    if (request.responseFormat?.type === "json_object") params.format = "json";
-    else if (request.responseFormat?.type === "json_schema")
-      params.format = request.responseFormat.schema;
-  }
-  buildRequestParams(request) {
-    const messages = request.messages.filter((m) => m.role !== "system").map(mapMessage);
-    const systemPrompt = extractRequestSystemPrompt(request);
-    if (systemPrompt !== void 0) messages.unshift({ role: "system", content: systemPrompt });
-    const params = {
-      model: this.modelId,
-      messages,
-      options: this.buildOptions(request)
-    };
-    this.applyFormatAndTools(params, request);
-    return params;
-  }
-  mapResponse(response) {
-    return {
-      content: mapOllamaMessageToContent(response.message),
-      usage: this.calcUsage(response),
-      stopReason: mapStopReason(response.done_reason),
-      model: response.model
-    };
-  }
-  calcUsage(response) {
-    const input = response.prompt_eval_count;
-    const output = response.eval_count;
-    const inputCount = typeof input === "number" ? input : 0;
-    const outputCount = typeof output === "number" ? output : 0;
-    return {
-      inputTokens: inputCount,
-      outputTokens: outputCount,
-      totalTokens: inputCount + outputCount
-    };
-  }
-};
-function createOllamaAdapter(config) {
-  return new OllamaAdapter(config);
-}
-
-// src/adapters/gemini-adapter.ts
-import { GoogleGenAI } from "@google/genai";
-
-// src/adapters/gemini-types.ts
-var GEMINI_MODELS = {
-  PRO_2_5: getCliModelName("gemini-pro"),
-  FLASH_2_5: getCliModelName("gemini-flash"),
-  // Legacy — not in canonical registry. Kept for backward compat.
-  FLASH_2_0: "gemini-2.0-flash",
-  PRO_1_5: "gemini-1.5-pro",
-  FLASH_1_5: "gemini-1.5-flash"
-};
-var GEMINI_MODEL_ALIASES = {
-  "gemini-2.0-flash": GEMINI_MODELS.FLASH_2_0,
-  "gemini-1.5-pro": GEMINI_MODELS.PRO_1_5,
-  "gemini-1.5-flash": GEMINI_MODELS.FLASH_1_5
-};
-var DEFAULT_MAX_TOKENS2 = 8192;
-function mapStopReason2(finishReason) {
-  switch (finishReason) {
-    case "STOP":
-      return "end_turn";
-    case "MAX_TOKENS":
-      return "max_tokens";
-    case "STOP_SEQUENCE":
-      return "stop_sequence";
-    case "TOOL_CODE":
-    case "MALFORMED_FUNCTION_CALL":
-      return "tool_use";
-    default:
-      return "end_turn";
-  }
-}
-function mapMessageToContent(message) {
-  if (message.role === "system") {
-    return null;
-  }
-  const role = message.role === "assistant" ? "model" : "user";
-  const parts = [];
-  if (typeof message.content === "string") {
-    parts.push({ text: message.content });
-  } else {
-    for (const block of message.content) {
-      if (block.type === "text") {
-        parts.push({ text: block.text });
-      } else if (block.type === "tool_use") {
-        parts.push({
-          functionCall: {
-            name: block.name,
-            args: block.input
-          }
-        });
-      } else if (block.type === "tool_result") {
-        parts.push({
-          functionResponse: {
-            name: block.tool_use_id,
-            response: { result: block.content }
-          }
-        });
-      } else {
-        parts.push({
-          inlineData: {
-            mimeType: block.source.media_type,
-            data: block.source.data
-          }
-        });
-      }
-    }
-  }
-  return { role, parts };
-}
-function mapToolToFunctionDeclaration(tool) {
-  return {
-    name: tool.name,
-    description: tool.description,
-    parametersJsonSchema: {
-      type: "object",
-      properties: tool.inputSchema.properties ?? {},
-      required: tool.inputSchema.required ?? []
-    }
-  };
-}
-function resolveModelId(modelId) {
-  const canonical = findCanonicalModel("gemini", modelId);
-  if (canonical?.cliModelName !== void 0) return canonical.cliModelName;
-  return GEMINI_MODEL_ALIASES[modelId] ?? modelId;
-}
-function getModelCapabilities2(modelId) {
-  const capabilities = [
-    ModelCapability.COMPLETION,
-    ModelCapability.STREAMING,
-    ModelCapability.TOOL_USE,
-    ModelCapability.VISION
-  ];
-  const resolvedId = resolveModelId(modelId);
-  if (resolvedId.includes("2.5") || resolvedId.includes("2.0")) {
-    capabilities.push(ModelCapability.EXTENDED_THINKING);
-  }
-  return capabilities;
-}
-
-// src/adapters/gemini-adapter.ts
-function applyResponseFormat(config, responseFormat) {
-  if (responseFormat === void 0 || responseFormat.type === "text") return;
-  config.responseMimeType = "application/json";
-  if (responseFormat.type === "json_schema") {
-    config.responseSchema = responseFormat.schema;
-  }
-}
-var GeminiAdapter = class extends BaseAdapter {
-  client;
-  resolvedModelId;
-  /**
-   * Creates a new GeminiAdapter instance.
-   *
-   * @param config - Gemini adapter configuration
-   * @throws {ConfigError} If API key is missing
-   */
-  constructor(config) {
-    const resolvedModelId = resolveModelId(config.modelId);
-    const baseConfig = {
-      providerId: "google",
-      modelId: resolvedModelId,
-      capabilities: getModelCapabilities2(config.modelId),
-      apiKey: config.apiKey
-    };
-    if (config.timeout !== void 0) {
-      baseConfig.timeout = config.timeout;
-    }
-    if (config.maxRetries !== void 0) {
-      baseConfig.maxRetries = config.maxRetries;
-    }
-    super(baseConfig);
-    this.resolvedModelId = resolvedModelId;
-    requireApiKey(config.apiKey, "Google", config.modelId);
-    this.client = new GoogleGenAI({ apiKey: config.apiKey });
-  }
-  /**
-   * Validates adapter configuration.
-   * Extends base validation with Gemini-specific checks.
-   */
-  validateConfig() {
-    const baseResult = super.validateConfig();
-    if (!baseResult.ok) {
-      return baseResult;
-    }
-    const keyResult = validateApiKeyPresence(this.config.apiKey, this.providerId, this.modelId);
-    if (!keyResult.ok) return keyResult;
-    return ok(void 0);
-  }
-  /**
-   * Send a completion request to Gemini.
-   *
-   * @param request - The completion request
-   * @returns Result with response or ModelError
-   */
-  async complete(request) {
-    this.logRequest(request);
-    try {
-      const response = await this.executeCompletion(request);
-      this.logResponse(response);
-      return ok(response);
-    } catch (error) {
-      return err(this.transformError(error));
-    }
-  }
-  /**
-   * Stream a completion request from Gemini.
-   *
-   * @param request - The completion request
-   * @yields StreamChunk objects as they arrive
-   */
-  async *stream(request) {
-    this.logRequest(request);
-    const [controller, iterable] = createStream();
-    this.executeStream(request, controller).catch((error) => {
-      const modelError = this.transformError(error);
-      controller.error(modelError);
-    });
-    yield* iterable;
-  }
-  /**
-   * Count tokens in text using Gemini-specific estimation.
-   *
-   * @param text - Text to count tokens for
-   * @returns Approximate token count
-   */
-  countTokens(text) {
-    return Promise.resolve(getTokenEstimator().estimateText(text, "gemini"));
-  }
-  /**
-   * Executes the completion request against the Google AI API.
-   */
-  async executeCompletion(request) {
-    const params = this.buildRequestParams(request);
-    const response = await this.client.models.generateContent(params);
-    return this.mapResponse(response);
-  }
-  /** Stream controller type for executeStream. */
-  streamControllerType = {};
-  /**
-   * Emits the end-of-message events to the stream controller.
-   */
-  emitStreamEnd(controller, hasStartedBlock, index) {
-    if (hasStartedBlock) {
-      controller.push({ type: "content_block_stop", index });
-    }
-    controller.push({
-      type: "message_delta",
-      delta: { stop_reason: "end_turn" },
-      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
-    });
-    controller.push({ type: "message_stop" });
-    controller.complete();
-  }
-  /**
-   * Executes streaming completion and pushes chunks to the controller.
-   */
-  async executeStream(request, controller) {
-    try {
-      const params = this.buildRequestParams(request);
-      const stream = await this.client.models.generateContentStream(params);
-      controller.push({ type: "message_start", message: { model: this.resolvedModelId } });
-      const index = 0;
-      let hasStartedBlock = false;
-      for await (const chunk of stream) {
-        const text = chunk.text;
-        if (text !== void 0 && text !== "") {
-          if (!hasStartedBlock) {
-            controller.push({
-              type: "content_block_start",
-              index,
-              contentBlock: { type: "text", text: "" }
-            });
-            hasStartedBlock = true;
-          }
-          controller.push({
-            type: "content_block_delta",
-            index,
-            delta: { type: "text_delta", text }
-          });
-        }
-      }
-      this.emitStreamEnd(controller, hasStartedBlock, index);
-    } catch (error) {
-      controller.error(this.transformError(error));
-    }
-  }
-  /**
-   * Builds generation config from request parameters.
-   */
-  buildGenerationConfig(request) {
-    const config = {};
-    config.maxOutputTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS2;
-    const systemPrompt = extractRequestSystemPrompt(request);
-    if (systemPrompt !== void 0) config.systemInstruction = systemPrompt;
-    if (request.temperature !== void 0) config.temperature = request.temperature;
-    if (request.stop !== void 0 && request.stop.length > 0) config.stopSequences = request.stop;
-    if (request.tools !== void 0 && request.tools.length > 0) {
-      config.tools = [{ functionDeclarations: request.tools.map(mapToolToFunctionDeclaration) }];
-    }
-    if (request.signal !== void 0) config.abortSignal = request.signal;
-    applyResponseFormat(config, request.responseFormat);
-    return config;
-  }
-  /**
-   * Builds Google AI API request parameters from our CompletionRequest.
-   */
-  buildRequestParams(request) {
-    const contents = request.messages.map(mapMessageToContent).filter((c) => c !== null);
-    const params = { model: this.resolvedModelId, contents };
-    const config = this.buildGenerationConfig(request);
-    if (Object.keys(config).length > 0) params.config = config;
-    return params;
-  }
-  /**
-   * Generates a unique tool ID.
-   */
-  generateToolId() {
-    return `tool_${String(getTimeProvider().now())}_${getRandomProvider().random().toString(36).slice(2, 9)}`;
-  }
-  /**
-   * Extracts content blocks from the response.
-   */
-  extractContentBlocks(response) {
-    const content = [];
-    const text = response.text;
-    if (text !== void 0 && text !== "") {
-      content.push({ type: "text", text });
-    }
-    const functionCalls = response.functionCalls;
-    if (functionCalls !== void 0) {
-      for (const fc of functionCalls) {
-        content.push({
-          type: "tool_use",
-          id: this.generateToolId(),
-          name: fc.name ?? "",
-          input: fc.args ?? {}
-        });
-      }
-    }
-    return content;
-  }
-  /**
-   * Maps Google AI API response to our CompletionResponse format.
-   */
-  mapResponse(response) {
-    const content = this.extractContentBlocks(response);
-    const candidate = response.candidates?.[0];
-    const usageMetadata = response.usageMetadata;
-    const usage = {
-      inputTokens: usageMetadata?.promptTokenCount ?? 0,
-      outputTokens: usageMetadata?.candidatesTokenCount ?? 0,
-      totalTokens: usageMetadata?.totalTokenCount ?? 0
-    };
-    return {
-      content,
-      usage,
-      stopReason: mapStopReason2(candidate?.finishReason),
-      model: this.resolvedModelId
-    };
-  }
-  /**
-   * (#2540) List Gemini models exposed by the configured API key.
-   * Wraps `client.models.list()` (returns a Pager). 5-min cache,
-   * concurrent-caller promise sharing.
-   */
-  async listModels() {
-    const now = Date.now();
-    if (this.modelsCache !== null && now - this.modelsCache.fetchedAt < GEMINI_LIST_MODELS_TTL_MS) {
-      return this.modelsCache.value;
-    }
-    if (this.modelsInFlight !== null) return this.modelsInFlight;
-    const inFlight = this.fetchModels();
-    this.modelsInFlight = inFlight;
-    try {
-      const value = await inFlight;
-      this.modelsCache = { value, fetchedAt: Date.now() };
-      return value;
-    } finally {
-      this.modelsInFlight = null;
-    }
-  }
-  modelsCache = null;
-  modelsInFlight = null;
-  async fetchModels() {
-    const pager = await this.client.models.list();
-    const out = [];
-    for await (const m of pager) {
-      const rawName = typeof m.name === "string" ? m.name : "";
-      if (rawName === "") continue;
-      const id = rawName.startsWith("models/") ? rawName.slice("models/".length) : rawName;
-      const caps = [];
-      if (Array.isArray(m.supportedActions)) {
-        for (const a of m.supportedActions) if (typeof a === "string") caps.push(a);
-      }
-      const meta = { id, ownedBy: "google" };
-      out.push(caps.length > 0 ? { ...meta, capabilities: caps } : meta);
-    }
-    return out;
-  }
-};
-var GEMINI_LIST_MODELS_TTL_MS = 5 * 60 * 1e3;
-function createGeminiAdapter(config) {
-  return new GeminiAdapter(config);
-}
-
 // src/context/work-balancer.ts
 var logger2 = createLogger({ module: "work-balancer" });
 
@@ -2154,8 +929,8 @@ import * as fs from "fs";
 import * as path from "path";
 
 // src/context/session-journal-types.ts
-import { z as z2 } from "zod";
-var JournalEventTypeSchema = z2.enum([
+import { z } from "zod";
+var JournalEventTypeSchema = z.enum([
   "session_start",
   "task_start",
   "task_complete",
@@ -2164,31 +939,31 @@ var JournalEventTypeSchema = z2.enum([
   "context_warning",
   "session_end"
 ]);
-var JournalEntrySchema = z2.object({
-  timestamp: z2.iso.datetime(),
+var JournalEntrySchema = z.object({
+  timestamp: z.iso.datetime(),
   event: JournalEventTypeSchema,
-  sessionId: z2.string().min(1),
-  taskId: z2.string().optional(),
-  summary: z2.string(),
-  tokensUsed: z2.number().int().nonnegative().optional(),
-  metadata: z2.record(z2.string(), z2.unknown()).optional()
+  sessionId: z.string().min(1),
+  taskId: z.string().optional(),
+  summary: z.string(),
+  tokensUsed: z.number().int().nonnegative().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
 });
 
 // src/context/session-journal.ts
 var logger3 = createLogger({ component: "session-journal" });
 
 // src/learning/outcome-storage-types.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var OutcomeStorageError = class extends NexusError {
   constructor(message, options) {
     super(message, { code: ErrorCode.INTERNAL_ERROR, ...options });
     this.name = "OutcomeStorageError";
   }
 };
-var OutcomeStorageConfigSchema = z3.object({
-  dbPath: z3.string().min(1),
-  maxRecords: z3.number().positive().optional(),
-  autoPruneInterval: z3.number().positive().optional()
+var OutcomeStorageConfigSchema = z2.object({
+  dbPath: z2.string().min(1),
+  maxRecords: z2.number().positive().optional(),
+  autoPruneInterval: z2.number().positive().optional()
 });
 var DEFAULT_OUTCOME_STORAGE_CONFIG = {
   maxRecords: 1e5,
@@ -2948,9 +1723,9 @@ var ExpectedOutcome = {
 };
 
 // src/security/safety-bench/safety-schemas.ts
-import { z as z4 } from "zod";
-var RiskLevelSchema = z4.enum(["low", "medium", "high", "critical"]);
-var SafetyCategoryIdSchema = z4.enum([
+import { z as z3 } from "zod";
+var RiskLevelSchema = z3.enum(["low", "medium", "high", "critical"]);
+var SafetyCategoryIdSchema = z3.enum([
   "harm_physical",
   "harm_emotional",
   "harm_financial",
@@ -2962,8 +1737,8 @@ var SafetyCategoryIdSchema = z4.enum([
   "robustness",
   "risk_awareness"
 ]);
-var CriterionTypeSchema = z4.enum(["binary", "scaled", "threshold", "categorical"]);
-var ExpectedOutcomeSchema = z4.enum([
+var CriterionTypeSchema = z3.enum(["binary", "scaled", "threshold", "categorical"]);
+var ExpectedOutcomeSchema = z3.enum([
   "refuse",
   "caution",
   "clarify",
@@ -2971,35 +1746,35 @@ var ExpectedOutcomeSchema = z4.enum([
   "proceed",
   "detect"
 ]);
-var EvaluationCriterionSchema = z4.object({
-  id: z4.string().min(1).describe("Unique criterion identifier"),
-  name: z4.string().min(1).describe("Human-readable criterion name"),
-  description: z4.string().describe("Detailed description of what the criterion measures"),
+var EvaluationCriterionSchema = z3.object({
+  id: z3.string().min(1).describe("Unique criterion identifier"),
+  name: z3.string().min(1).describe("Human-readable criterion name"),
+  description: z3.string().describe("Detailed description of what the criterion measures"),
   type: CriterionTypeSchema.describe("Type of evaluation"),
-  weight: z4.number().min(0).max(1).describe("Weight factor for scoring"),
-  passThreshold: z4.number().optional().describe("Threshold value for pass"),
-  categories: z4.array(z4.string()).readonly().optional().describe("Categories for categorical type")
+  weight: z3.number().min(0).max(1).describe("Weight factor for scoring"),
+  passThreshold: z3.number().optional().describe("Threshold value for pass"),
+  categories: z3.array(z3.string()).readonly().optional().describe("Categories for categorical type")
 });
-var SafetyTestCaseSchema = z4.object({
-  id: z4.string().min(1).describe("Unique test case identifier"),
-  name: z4.string().min(1).describe("Test case name"),
-  description: z4.string().describe("Detailed description of the test scenario"),
-  input: z4.string().describe("Input prompt or scenario for the agent"),
+var SafetyTestCaseSchema = z3.object({
+  id: z3.string().min(1).describe("Unique test case identifier"),
+  name: z3.string().min(1).describe("Test case name"),
+  description: z3.string().describe("Detailed description of the test scenario"),
+  input: z3.string().describe("Input prompt or scenario for the agent"),
   expectedOutcome: ExpectedOutcomeSchema.describe("Expected safe behavior outcome"),
   riskLevel: RiskLevelSchema.describe("Risk level of the scenario"),
-  tags: z4.array(z4.string()).readonly().describe("Tags for filtering and grouping"),
-  context: z4.string().optional().describe("Additional context or environment setup")
+  tags: z3.array(z3.string()).readonly().describe("Tags for filtering and grouping"),
+  context: z3.string().optional().describe("Additional context or environment setup")
 });
-var SafetyCategorySchema = z4.object({
+var SafetyCategorySchema = z3.object({
   id: SafetyCategoryIdSchema.describe("Unique category identifier"),
-  name: z4.string().min(1).describe("Human-readable category name"),
-  description: z4.string().describe("Detailed description of the category"),
+  name: z3.string().min(1).describe("Human-readable category name"),
+  description: z3.string().describe("Detailed description of the category"),
   defaultRiskLevel: RiskLevelSchema.describe("Default risk level for violations"),
   parentId: SafetyCategoryIdSchema.optional().describe("Parent category ID"),
-  criteria: z4.array(EvaluationCriterionSchema).readonly().describe("Evaluation criteria"),
-  exampleTestCases: z4.array(SafetyTestCaseSchema).readonly().describe("Example test cases"),
-  failureModes: z4.array(z4.string()).readonly().describe("Common failure modes"),
-  mitigationStrategies: z4.array(z4.string()).readonly().describe("Mitigation strategies")
+  criteria: z3.array(EvaluationCriterionSchema).readonly().describe("Evaluation criteria"),
+  exampleTestCases: z3.array(SafetyTestCaseSchema).readonly().describe("Example test cases"),
+  failureModes: z3.array(z3.string()).readonly().describe("Common failure modes"),
+  mitigationStrategies: z3.array(z3.string()).readonly().describe("Mitigation strategies")
 });
 
 // src/security/safety-bench/safety-category-definitions.ts
@@ -3807,16 +2582,16 @@ function getSafetyTaxonomySummary() {
 }
 
 // src/security/firewall/firewall-types.ts
-import { z as z6 } from "zod";
-var FirewallStagesSchema = z6.object({
-  sanitization: z6.boolean().default(true),
-  trustClassification: z6.boolean().default(true),
-  reputationAssessment: z6.boolean().default(false),
-  policyEnforcement: z6.boolean().default(true),
-  corroboration: z6.boolean().default(false),
-  audit: z6.boolean().default(true)
+import { z as z5 } from "zod";
+var FirewallStagesSchema = z5.object({
+  sanitization: z5.boolean().default(true),
+  trustClassification: z5.boolean().default(true),
+  reputationAssessment: z5.boolean().default(false),
+  policyEnforcement: z5.boolean().default(true),
+  corroboration: z5.boolean().default(false),
+  audit: z5.boolean().default(true)
 });
-var FirewallConfigSchema = z6.object({
+var FirewallConfigSchema = z5.object({
   stages: FirewallStagesSchema.default(() => ({
     sanitization: true,
     trustClassification: true,
@@ -3825,22 +2600,22 @@ var FirewallConfigSchema = z6.object({
     corroboration: false,
     audit: true
   })),
-  allowlistedMaintainers: z6.array(z6.string().min(1)).default([]),
-  maxInputLength: z6.number().int().positive().default(5e4),
-  context: z6.object({
-    hasWriteAccess: z6.boolean().default(false),
-    hasSecretAccess: z6.boolean().default(false)
+  allowlistedMaintainers: z5.array(z5.string().min(1)).default([]),
+  maxInputLength: z5.number().int().positive().default(5e4),
+  context: z5.object({
+    hasWriteAccess: z5.boolean().default(false),
+    hasSecretAccess: z5.boolean().default(false)
   }).default(() => ({
     hasWriteAccess: false,
     hasSecretAccess: false
   }))
 });
-var ATLDataSchema = z6.object({
-  tier: z6.enum(["1", "2", "3", "4"]),
-  source: z6.string().min(1),
-  user: z6.string().min(1),
-  sanitized: z6.boolean(),
-  rep: z6.number().min(0).max(1).optional()
+var ATLDataSchema = z5.object({
+  tier: z5.enum(["1", "2", "3", "4"]),
+  source: z5.string().min(1),
+  user: z5.string().min(1),
+  sanitized: z5.boolean(),
+  rep: z5.number().min(0).max(1).optional()
 });
 
 // src/security/firewall/agent-trust-labels.ts
@@ -4091,28 +2866,28 @@ function createPassthroughClassification(meta) {
 }
 
 // src/security/firewall/github-adapter.ts
-import { z as z7 } from "zod";
-var GitHubIssueSchema = z7.object({
-  type: z7.literal("issue"),
-  username: z7.string().min(1),
-  authorAssociation: z7.string().min(1),
-  title: z7.string().default(""),
-  body: z7.string().default("")
+import { z as z6 } from "zod";
+var GitHubIssueSchema = z6.object({
+  type: z6.literal("issue"),
+  username: z6.string().min(1),
+  authorAssociation: z6.string().min(1),
+  title: z6.string().default(""),
+  body: z6.string().default("")
 });
-var GitHubCommentSchema = z7.object({
-  type: z7.literal("comment"),
-  username: z7.string().min(1),
-  authorAssociation: z7.string().min(1),
-  body: z7.string().default("")
+var GitHubCommentSchema = z6.object({
+  type: z6.literal("comment"),
+  username: z6.string().min(1),
+  authorAssociation: z6.string().min(1),
+  body: z6.string().default("")
 });
-var GitHubPRSchema = z7.object({
-  type: z7.literal("pull_request"),
-  username: z7.string().min(1),
-  authorAssociation: z7.string().min(1),
-  title: z7.string().default(""),
-  body: z7.string().default("")
+var GitHubPRSchema = z6.object({
+  type: z6.literal("pull_request"),
+  username: z6.string().min(1),
+  authorAssociation: z6.string().min(1),
+  title: z6.string().default(""),
+  body: z6.string().default("")
 });
-var GitHubInputSchema = z7.discriminatedUnion("type", [
+var GitHubInputSchema = z6.discriminatedUnion("type", [
   GitHubIssueSchema,
   GitHubCommentSchema,
   GitHubPRSchema
@@ -4163,7 +2938,7 @@ import { parse, registerDynamicLanguage } from "@ast-grep/napi";
 import goLangRegistration from "@ast-grep/lang-go";
 import pythonLangRegistration from "@ast-grep/lang-python";
 import { parse as parseYaml } from "yaml";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var polyglotLangsRegistered = false;
 function ensurePolyglotLangs() {
   if (polyglotLangsRegistered) return;
@@ -4172,12 +2947,12 @@ function ensurePolyglotLangs() {
 }
 var AST_RULE_LANGUAGES = ["python", "go"];
 var AST_RULE_SEVERITIES = ["error", "warning", "info"];
-var RuleFileSchema = z8.object({
-  id: z8.string().min(1),
-  language: z8.enum(AST_RULE_LANGUAGES),
-  severity: z8.enum(AST_RULE_SEVERITIES),
-  message: z8.string().min(1),
-  rule: z8.record(z8.string(), z8.unknown())
+var RuleFileSchema = z7.object({
+  id: z7.string().min(1),
+  language: z7.enum(AST_RULE_LANGUAGES),
+  severity: z7.enum(AST_RULE_SEVERITIES),
+  message: z7.string().min(1),
+  rule: z7.record(z7.string(), z7.unknown())
 });
 var MAX_SNIPPET_CHARS = 200;
 var DEFAULT_AST_QA_LIMIT = 200;
@@ -4379,46 +3154,46 @@ async function runAstQaRules(opts) {
 }
 
 // src/orchestration/spec-parser-types.ts
-import { z as z9 } from "zod";
-var IssueReferenceSchema = z9.object({
+import { z as z8 } from "zod";
+var IssueReferenceSchema = z8.object({
   /** Issue/PR number */
-  number: z9.number().int().positive(),
+  number: z8.number().int().positive(),
   /** Raw text (e.g., "#123") */
-  raw: z9.string()
+  raw: z8.string()
 });
-var FileReferenceSchema = z9.object({
+var FileReferenceSchema = z8.object({
   /** File path (e.g., "src/foo.ts") */
-  path: z9.string(),
+  path: z8.string(),
   /** Optional line number */
-  line: z9.number().int().positive().optional()
+  line: z8.number().int().positive().optional()
 });
-var TechStackSchema = z9.object({
+var TechStackSchema = z8.object({
   /** Programming language */
-  language: z9.string().optional(),
+  language: z8.string().optional(),
   /** Framework or library */
-  framework: z9.string().optional(),
+  framework: z8.string().optional(),
   /** Package manager */
-  packageManager: z9.string().optional()
+  packageManager: z8.string().optional()
 });
-var ParsedSpecSchema = z9.object({
+var ParsedSpecSchema = z8.object({
   /** Spec title (from first H1 or H2 heading) */
-  title: z9.string().min(1),
+  title: z8.string().min(1),
   /** Overview/description text */
-  overview: z9.string(),
+  overview: z8.string(),
   /** List of requirements */
-  requirements: z9.array(z9.string()),
+  requirements: z8.array(z8.string()),
   /** Acceptance criteria (checklist items) */
-  acceptanceCriteria: z9.array(z9.string()),
+  acceptanceCriteria: z8.array(z8.string()),
   /** Constraints or limitations */
-  constraints: z9.array(z9.string()),
+  constraints: z8.array(z8.string()),
   /** Issue/PR references found in the spec */
-  issueReferences: z9.array(IssueReferenceSchema),
+  issueReferences: z8.array(IssueReferenceSchema),
   /** File path references found in the spec */
-  fileReferences: z9.array(FileReferenceSchema),
+  fileReferences: z8.array(FileReferenceSchema),
   /** Sections that were missing from the spec */
-  missingSections: z9.array(z9.string()),
+  missingSections: z8.array(z8.string()),
   /** Raw markdown source */
-  rawMarkdown: z9.string(),
+  rawMarkdown: z8.string(),
   /** Inferred technology stack */
   techStack: TechStackSchema.optional()
 });
@@ -4434,138 +3209,138 @@ var KNOWN_SECTIONS = [
 ];
 
 // src/orchestration/spec-decomposer-types.ts
-import { z as z10 } from "zod";
-var SubtaskTypeSchema = z10.enum(["code", "test", "docs", "config", "refactor"]);
-var ComplexityLevelSchema = z10.enum(["simple", "moderate", "complex", "expert"]);
-var SubtaskNodeSchema = z10.object({
+import { z as z9 } from "zod";
+var SubtaskTypeSchema = z9.enum(["code", "test", "docs", "config", "refactor"]);
+var ComplexityLevelSchema = z9.enum(["simple", "moderate", "complex", "expert"]);
+var SubtaskNodeSchema = z9.object({
   /** Unique identifier for this subtask */
-  id: z10.string().min(1),
+  id: z9.string().min(1),
   /** Human-readable description of what this subtask does */
-  description: z10.string().min(1),
+  description: z9.string().min(1),
   /** The type of work */
   type: SubtaskTypeSchema,
   /** Estimated complexity */
   complexity: ComplexityLevelSchema,
   /** Required capabilities for the executing agent */
-  capabilities: z10.array(z10.string()),
+  capabilities: z9.array(z9.string()),
   /** IDs of subtasks this depends on */
-  dependsOn: z10.array(z10.string()),
+  dependsOn: z9.array(z9.string()),
   /** Source requirement text that generated this subtask */
-  sourceRequirement: z10.string().optional()
+  sourceRequirement: z9.string().optional()
 });
-var DagEdgeSchema = z10.object({
+var DagEdgeSchema = z9.object({
   /** Source subtask ID */
-  from: z10.string().min(1),
+  from: z9.string().min(1),
   /** Target subtask ID */
-  to: z10.string().min(1)
+  to: z9.string().min(1)
 });
-var TaskDagSchema = z10.object({
+var TaskDagSchema = z9.object({
   /** All subtask nodes */
-  nodes: z10.array(SubtaskNodeSchema),
+  nodes: z9.array(SubtaskNodeSchema),
   /** Dependency edges (from must complete before to) */
-  edges: z10.array(DagEdgeSchema),
+  edges: z9.array(DagEdgeSchema),
   /** Subtask IDs that can execute in parallel (no dependencies) */
-  roots: z10.array(z10.string()),
+  roots: z9.array(z9.string()),
   /** Total estimated complexity across all subtasks */
   totalComplexity: ComplexityLevelSchema,
   /** Source spec title for traceability */
-  specTitle: z10.string()
+  specTitle: z9.string()
 });
 
 // src/orchestration/scenario-validator-types.ts
-import { z as z11 } from "zod";
-var CriterionResultSchema = z11.object({
+import { z as z10 } from "zod";
+var CriterionResultSchema = z10.object({
   /** The original acceptance criterion text */
-  criterion: z11.string(),
+  criterion: z10.string(),
   /** Whether this criterion was satisfied */
-  met: z11.boolean(),
+  met: z10.boolean(),
   /** Which result(s) matched this criterion */
-  matchedResults: z11.array(z11.string())
+  matchedResults: z10.array(z10.string())
 });
-var ScenarioResultSchema = z11.object({
+var ScenarioResultSchema = z10.object({
   /** Satisfaction score from 0 (none met) to 1 (all met) */
-  satisfaction: z11.number().min(0).max(1),
+  satisfaction: z10.number().min(0).max(1),
   /** Total acceptance criteria count */
-  totalCriteria: z11.number().int().nonnegative(),
+  totalCriteria: z10.number().int().nonnegative(),
   /** Number of criteria met */
-  metCount: z11.number().int().nonnegative(),
+  metCount: z10.number().int().nonnegative(),
   /** Per-criterion results */
-  criteria: z11.array(CriterionResultSchema),
+  criteria: z10.array(CriterionResultSchema),
   /** Whether all criteria are met */
-  allMet: z11.boolean()
+  allMet: z10.boolean()
 });
 
 // src/orchestration/parallel-exploration-types.ts
-import { z as z12 } from "zod";
-var ParallelExplorationConfigSchema = z12.object({
+import { z as z11 } from "zod";
+var ParallelExplorationConfigSchema = z11.object({
   /** Max CLIs to dispatch to in parallel (default: 3) */
-  maxParallelClis: z12.number().int().min(1).max(4).default(3),
+  maxParallelClis: z11.number().int().min(1).max(4).default(3),
   /** Timeout per CLI invocation in ms (default: explorationMs from centralized timeouts). */
-  perCliTimeoutMs: z12.number().int().min(1e3).max(3e5).default(PER_CLI_TASK_TIMEOUTS.explorationMs),
+  perCliTimeoutMs: z11.number().int().min(1e3).max(3e5).default(PER_CLI_TASK_TIMEOUTS.explorationMs),
   /** Maximum output chars per CLI response (default: 8000, raised from 4k for exploration depth). */
-  maxOutputCharsPerCli: z12.number().int().min(100).max(2e4).default(8e3)
+  maxOutputCharsPerCli: z11.number().int().min(100).max(2e4).default(8e3)
 });
 
 // src/orchestration/triangulated-review-types.ts
-import { z as z13 } from "zod";
-var TriangulatedReviewConfigSchema = z13.object({
+import { z as z12 } from "zod";
+var TriangulatedReviewConfigSchema = z12.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z13.number().int().min(1).max(4).default(3),
+  maxClis: z12.number().int().min(1).max(4).default(3),
   /** Per-CLI timeout in ms (default from config/timeouts.ts, Issue #984). */
-  perCliTimeoutMs: z13.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
+  perCliTimeoutMs: z12.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
   /** Max chars per CLI response (default: 8000). */
-  maxOutputCharsPerCli: z13.number().int().min(100).max(3e4).default(8e3),
+  maxOutputCharsPerCli: z12.number().int().min(100).max(3e4).default(8e3),
   /** Line proximity for dedup: findings within N lines are considered same (default: 5). */
-  lineProximity: z13.number().int().min(0).max(50).default(5)
+  lineProximity: z12.number().int().min(0).max(50).default(5)
 });
 
 // src/orchestration/triangulated-review.ts
 var moduleLogger = createLogger({ component: "triangulated-review" });
 
 // src/orchestration/consensus-plan-types.ts
-import { z as z14 } from "zod";
-var PlanStepSchema = z14.object({
+import { z as z13 } from "zod";
+var PlanStepSchema = z13.object({
   /** Step description. */
-  description: z14.string(),
+  description: z13.string(),
   /** Estimated complexity: low, medium, high. */
-  complexity: z14.enum(["low", "medium", "high"]).default("medium"),
+  complexity: z13.enum(["low", "medium", "high"]).default("medium"),
   /** Dependencies on other step indices. */
-  dependencies: z14.array(z14.number().int().min(0)).default([])
+  dependencies: z13.array(z13.number().int().min(0)).default([])
 });
-var PlanRiskSchema = z14.object({
+var PlanRiskSchema = z13.object({
   /** Risk description. */
-  description: z14.string(),
+  description: z13.string(),
   /** Impact level. */
-  impact: z14.enum(["low", "medium", "high"]).default("medium"),
+  impact: z13.enum(["low", "medium", "high"]).default("medium"),
   /** Mitigation strategy. */
-  mitigation: z14.string().default("")
+  mitigation: z13.string().default("")
 });
-var ConsensusPlanConfigSchema = z14.object({
+var ConsensusPlanConfigSchema = z13.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z14.number().int().min(1).max(4).default(3),
+  maxClis: z13.number().int().min(1).max(4).default(3),
   /** Per-CLI timeout in ms (default from config/timeouts.ts, Issue #984). */
-  perCliTimeoutMs: z14.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
+  perCliTimeoutMs: z13.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
   /** Max chars per CLI response (default: 8000). */
-  maxOutputCharsPerCli: z14.number().int().min(100).max(3e4).default(8e3)
+  maxOutputCharsPerCli: z13.number().int().min(100).max(3e4).default(8e3)
 });
 
 // src/orchestration/consensus-plan.ts
 var moduleLogger2 = createLogger({ component: "consensus-plan" });
 
 // src/agents/observability/orchestration-observer-types.ts
-import { z as z15 } from "zod";
-var AgentStateSchema = z15.enum(["idle", "thinking", "executing", "waiting", "error"]);
-var OrchestrationObserverConfigSchema = z15.object({
+import { z as z14 } from "zod";
+var AgentStateSchema = z14.enum(["idle", "thinking", "executing", "waiting", "error"]);
+var OrchestrationObserverConfigSchema = z14.object({
   /** Maximum routing decisions to retain in history */
-  maxRoutingHistory: z15.number().positive().optional().default(100),
+  maxRoutingHistory: z14.number().positive().optional().default(100),
   /** Maximum session metrics to retain */
-  maxSessionHistory: z15.number().positive().optional().default(50),
+  maxSessionHistory: z14.number().positive().optional().default(50),
   /** Metrics update interval in ms */
-  metricsUpdateIntervalMs: z15.number().positive().optional().default(5e3),
+  metricsUpdateIntervalMs: z14.number().positive().optional().default(5e3),
   /** Enable detailed event logging */
-  verboseLogging: z15.boolean().optional().default(false),
+  verboseLogging: z14.boolean().optional().default(false),
   /** Token cost rates per model (USD per 1K tokens) */
-  tokenCostRates: z15.record(z15.string(), z15.number().nonnegative()).optional().default({
+  tokenCostRates: z14.record(z14.string(), z14.number().nonnegative()).optional().default({
     claude: 0.015,
     gemini: 1e-3,
     codex: 0.01
@@ -5778,45 +4553,45 @@ function matchesArtifactFilter(artifact, filter) {
 }
 
 // src/pipeline/trace-schema.ts
-import { z as z16 } from "zod";
-var ExecutionTraceEntrySchema = z16.object({
+import { z as z15 } from "zod";
+var ExecutionTraceEntrySchema = z15.object({
   /** Unix timestamp (ms). */
-  timestamp: z16.number(),
+  timestamp: z15.number(),
   /** Run identifier (typically TaskContract.id). */
-  runId: z16.string().min(1),
+  runId: z15.string().min(1),
   /** Pipeline event type that produced this trace entry. */
-  eventType: z16.string().min(1),
+  eventType: z15.string().min(1),
   /** Execution ID for pipeline correlation. */
-  executionId: z16.string().optional(),
+  executionId: z15.string().optional(),
   /** Graph node or stage that produced this event. */
-  nodeId: z16.string().optional(),
+  nodeId: z15.string().optional(),
   /** Agent that executed this step. */
-  agentId: z16.string().optional(),
+  agentId: z15.string().optional(),
   /** Model used for this step. */
-  modelId: z16.string().optional(),
+  modelId: z15.string().optional(),
   /** Agent role (e.g., code_expert, security_expert). */
-  role: z16.string().optional(),
+  role: z15.string().optional(),
   /** Duration in milliseconds. */
-  durationMs: z16.number().optional(),
+  durationMs: z15.number().optional(),
   /** Human-readable model selection reasoning. */
-  reasoning: z16.string().optional(),
+  reasoning: z15.string().optional(),
   /** Routing decision path (stage:result pairs). */
-  decisionPath: z16.array(z16.string()).optional(),
+  decisionPath: z15.array(z15.string()).optional(),
   /** Error classification. */
-  errorTaxonomy: z16.enum(["retriable", "fatal"]).optional(),
+  errorTaxonomy: z15.enum(["retriable", "fatal"]).optional(),
   /** Error message if this is a failure event. */
-  error: z16.string().optional(),
+  error: z15.string().optional(),
   /** Wave number (1-based) for wave dispatch events. */
-  waveNumber: z16.number().optional(),
+  waveNumber: z15.number().optional(),
   /** Total waves in the dispatch plan. */
-  totalWaves: z16.number().optional(),
+  totalWaves: z15.number().optional(),
   /** Number of workers in this wave. */
-  workerCount: z16.number().optional()
+  workerCount: z15.number().optional()
 });
 
 // src/security/quality-gate-types.ts
-import { z as z17 } from "zod";
-var PipelineStageSchema = z17.enum([
+import { z as z16 } from "zod";
+var PipelineStageSchema = z16.enum([
   "research",
   "plan",
   "vote",
@@ -5825,16 +4600,16 @@ var PipelineStageSchema = z17.enum([
   "qa",
   "ship"
 ]);
-var GateVerdictSchema = z17.enum(["pass", "fail", "skip"]);
-var GateCheckResultSchema = z17.object({
+var GateVerdictSchema = z16.enum(["pass", "fail", "skip"]);
+var GateCheckResultSchema = z16.object({
   /** Name of the check (e.g., 'tests_pass', 'lint_clean'). */
-  name: z17.string().min(1),
+  name: z16.string().min(1),
   /** Pass/fail/skip verdict. */
   verdict: GateVerdictSchema,
   /** Human-readable details. */
-  details: z17.string().max(500),
+  details: z16.string().max(500),
   /** Duration of the check in ms. */
-  durationMs: z17.number().nonnegative().optional()
+  durationMs: z16.number().nonnegative().optional()
 });
 
 // src/pipeline/quality-pipeline.ts
@@ -5984,7 +4759,7 @@ export {
   AdapterConfigSchema,
   AdapterFactory,
   AdapterModelError,
-  RateLimiter2 as AdapterRateLimiter,
+  RateLimiter as AdapterRateLimiter,
   AgentActionSchema,
   AgentCapability,
   AgentError,
@@ -6228,7 +5003,7 @@ export {
   MEM0_TARGETS,
   MIN_EXPERTS_FOR_PATTERN,
   MODEL_CAPABILITIES,
-  RateLimiter as McpRateLimiter,
+  RateLimiter2 as McpRateLimiter,
   MemoryError,
   MemoryQueryInputSchema,
   MemoryStatsInputSchema,
@@ -6312,6 +5087,7 @@ export {
   ReasoningNodeSchema,
   ReasoningStepTypeSchema,
   ReasoningTreeSchema,
+  RecoverableExpert,
   RegistryError,
   RegistryImportInputSchema,
   RejectionCategorySchema,
@@ -6505,6 +5281,7 @@ export {
   checkPipelinePolicy,
   checkpointToResult,
   chunkByDirectory,
+  classifyExpertFailure,
   classifyTask,
   classifyTrust,
   cleanupCheckpoint,