nexus-agents 2.170.0 → 2.172.0

package/dist/index.js

@@ -1,12 +1,14 @@
 import {
   createGitHubProvider,
   createScmProvider
-} from "./chunk-LYWNKEGM.js";
+} from "./chunk-25CWEJ2M.js";
 import {
   ALLOWED_COMMANDS,
   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-QMOJJ6A2.js";
+  withLogging,
+  withRetry,
+  withRetryWrapper
+} from "./chunk-C7TWCMK4.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -530,7 +549,7 @@ import {
   generateSecurityPlan,
   getRegistryManifest,
   resolveScannerData
-} from "./chunk-JYDXHV4L.js";
+} from "./chunk-B4XT3B2E.js";
 import {
   analyzeGitHubRepo,
   analyzeRepo,
@@ -556,20 +575,20 @@ import {
   getKnownNexusVarNames,
   startStdioServer,
   validateNexusEnv
-} from "./chunk-BGV3IF3G.js";
+} from "./chunk-YKVO32BI.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
   OpenAIAdapter,
   createOpenAIAdapter
-} from "./chunk-OIT75IRK.js";
+} from "./chunk-DLVDFJXU.js";
 import {
   CliCircuitBreakerIntegration,
   createCliCircuitBreakerIntegration
-} from "./chunk-57RYP435.js";
+} from "./chunk-IK7POCXO.js";
 import {
   executeExpert
-} from "./chunk-75AUSQL4.js";
+} from "./chunk-GJRLIANS.js";
 import {
   AgentFindingSchema,
   ConsensusEngine,
@@ -618,9 +637,9 @@ import {
   generateProposalId,
   parseAgentPairKey,
   registerConsensusVoteTool
-} from "./chunk-LOKT6EW7.js";
-import "./chunk-NXSY4G4Y.js";
-import "./chunk-6TN2Z2AQ.js";
+} from "./chunk-SZ3CRNPI.js";
+import "./chunk-7AJWIOMT.js";
+import "./chunk-DYFF72HX.js";
 import {
   AgentActionSchema,
   GitHubReviewer,
@@ -642,11 +661,11 @@ import {
   requiresCorroboration,
   validateAgentAction,
   validateCorroboration
-} from "./chunk-WKW5SEP7.js";
+} from "./chunk-RQGORCFM.js";
 import {
   GitHubProvider,
   ScmError
-} from "./chunk-C6IAXFNC.js";
+} from "./chunk-RAK6PTNM.js";
 import {
   GitHubUserRoleSchema,
   InjectionFlagSchema,
@@ -661,11 +680,11 @@ import {
   assessReputation,
   reconcileTrustTier,
   sanitizeInput
-} from "./chunk-DEE2UTYV.js";
+} from "./chunk-CEDSYAAI.js";
 import {
   ImprovementReviewInputSchema,
   registerImprovementReviewTool
-} from "./chunk-ZW7544DX.js";
+} from "./chunk-SCHMBRK4.js";
 import {
   AgentPerformanceSchema,
   ConsensusAlgorithmSchema,
@@ -680,7 +699,7 @@ import {
   ProposalSchema,
   ProposalStatusSchema,
   REJECTION_CATEGORIES,
-  RateLimiter,
+  RateLimiter as RateLimiter2,
   RejectionCategorySchema,
   VOTING_THRESHOLDS,
   VoteSchema,
@@ -701,7 +720,7 @@ import {
   toolSuccess,
   toolSuccessStructured,
   validateToolInput
-} from "./chunk-DDQXPARJ.js";
+} from "./chunk-KP4ZXW3B.js";
 import {
   AuditTrail,
   MAX_STRIPPED_ELEMENTS_PER_EVENT,
@@ -713,7 +732,7 @@ import {
   emitReputationEvent,
   emitSanitizationEvent,
   emitTrustEvent
-} from "./chunk-OYBAKU7N.js";
+} from "./chunk-BTH745HU.js";
 import {
   PersistentStrategyDistiller,
   RulesSnapshotSchema,
@@ -721,19 +740,19 @@ import {
   TokenCounter,
   TokenCounterProvider,
   createTokenCounter
-} from "./chunk-URRNWRI4.js";
+} from "./chunk-QBOTSJ7S.js";
 import {
   getTokenEnvVars,
   hasToken,
   resolveToken
-} from "./chunk-5N5XURKV.js";
-import "./chunk-RZJQZ5P3.js";
+} from "./chunk-Y7JDXVJA.js";
+import "./chunk-ZSWXEDI6.js";
 import "./chunk-NUBSJGQZ.js";
 import {
   MemoryError
-} from "./chunk-MG4JBADQ.js";
+} from "./chunk-LFKCJQ7G.js";
 import "./chunk-6T3EPABN.js";
-import "./chunk-PIODB4SW.js";
+import "./chunk-O4J34GZT.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -752,7 +771,7 @@ import {
   resetGlobalRegistry,
   withModelNotFoundFallback,
   wrapResilientWithFallback
-} from "./chunk-RJDJMOX6.js";
+} from "./chunk-Z5GJ4FXW.js";
 import {
   BaseCliAdapter,
   CLAUDE_MODELS,
@@ -780,14 +799,13 @@ import {
   createCliDetectionCache,
   estimateTaskComplexity,
   executeCliRetryLoop,
-  extractRequestSystemPrompt,
   getAvailableClis,
   getTimeoutForTask,
   getTimeoutForTaskAuto,
   isCliAvailable,
   isRetryableError,
   sleep
-} from "./chunk-SCHD7NZD.js";
+} from "./chunk-5UDKUPZB.js";
 import {
   AdapterModelError,
   BaseAdapter,
@@ -803,20 +821,17 @@ import {
   fromArray,
   mergeStreams,
   reduceStream,
-  requireApiKey,
   skip,
   take,
   takeUntil,
   tapStream,
   transformStream,
-  validateApiKeyPresence,
   withTimeout
-} from "./chunk-JOYOOEPJ.js";
+} from "./chunk-4KVAHGMB.js";
 import {
-  DEFAULTS,
   PROVIDER_ENV_KEYS
-} from "./chunk-JLG5AUZB.js";
-import "./chunk-Z4AWOPXA.js";
+} from "./chunk-QFS5VOB6.js";
+import "./chunk-76Q63KJM.js";
 import {
   AvailabilityCache,
   filterAvailableModels,
@@ -825,9 +840,9 @@ import {
   getFallbackChain,
   resetAvailabilityCache,
   resolveFallback
-} from "./chunk-UXXNNT5D.js";
+} from "./chunk-SUWN54CK.js";
 import "./chunk-QZUG667L.js";
-import "./chunk-DCXCVEZP.js";
+import "./chunk-IC3NZHPT.js";
 import {
   AgentCapability,
   AgentError,
@@ -880,17 +895,13 @@ import {
   detectTrend,
   err,
   extractNonErrorMessage,
-  findCanonicalModel,
   formatZodError,
   generateWeatherReport,
-  getCliModelName,
   getDefaultAvailableModelsCache,
   getDefaultRegistry,
-  getErrorMessage,
   getOutcomeStore,
   getRandomProvider,
   getTimeProvider,
-  getTokenEstimator,
   isErr,
   isOk,
   isZodError,
@@ -905,1247 +916,11 @@ import {
   toError,
   unwrap,
   unwrapOr
-} from "./chunk-GVTXP6F6.js";
+} from "./chunk-QBCWORAK.js";
 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((resolve2) => setTimeout(resolve2, 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((resolve2, reject) => {
-    const onAbort = () => {
-      reject(new AbortError());
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve2(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
@@ -4154,6 +2929,230 @@ function createGitHubAdapter() {
   };
 }
 
+// src/security/ast-rule-runner.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { dirname, extname, join as join2, relative, resolve as resolve2, sep } from "path";
+import { fileURLToPath } from "url";
+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 z7 } from "zod";
+var polyglotLangsRegistered = false;
+function ensurePolyglotLangs() {
+  if (polyglotLangsRegistered) return;
+  registerDynamicLanguage({ python: pythonLangRegistration, go: goLangRegistration });
+  polyglotLangsRegistered = true;
+}
+var AST_RULE_LANGUAGES = ["python", "go"];
+var AST_RULE_SEVERITIES = ["error", "warning", "info"];
+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;
+var MAX_AST_QA_LIMIT = 2e3;
+var AST_QA_MAX_DEPTH = 24;
+var MAX_FILES_SCANNED = 5e3;
+var logger5 = createLogger({ component: "ast-rule-runner" });
+async function loadRules(dir) {
+  let entries;
+  try {
+    entries = (await readdir(dir)).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).sort();
+  } catch (caught) {
+    const e = caught instanceof Error ? caught : new Error(String(caught));
+    throw new ValidationError(`ast-rule-runner: cannot read rules dir ${dir}: ${e.message}`, {
+      cause: e
+    });
+  }
+  const rules = [];
+  for (const file of entries) {
+    const path2 = join2(dir, file);
+    const raw = await readFile(path2, "utf8");
+    let parsed;
+    try {
+      parsed = parseYaml(raw);
+    } catch (caught) {
+      const e = caught instanceof Error ? caught : new Error(String(caught));
+      throw new ValidationError(`ast-rule-runner: malformed YAML in ${path2}: ${e.message}`, {
+        cause: e
+      });
+    }
+    const result = RuleFileSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new ValidationError(
+        `ast-rule-runner: invalid rule file ${path2}: ${formatZodError(result.error)}`
+      );
+    }
+    rules.push(result.data);
+  }
+  return rules;
+}
+function getBuiltInAstRulesPath() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  if (currentFile.includes(`${sep}dist${sep}`) || currentFile.endsWith(`${sep}dist`)) {
+    const distIndex = currentFile.lastIndexOf(`${sep}dist${sep}`);
+    if (distIndex !== -1) {
+      const distDir = currentFile.substring(0, distIndex + 5);
+      const bundledPath = join2(distDir, "security", "ast-rules");
+      if (existsSync2(bundledPath)) return bundledPath;
+    }
+  }
+  const possiblePaths = [
+    join2(currentDir, "ast-rules"),
+    // Unbundled: sibling of this file in src/security/
+    join2(currentDir, "security", "ast-rules"),
+    // Bundled chunk: dist/security sibling
+    join2(dirname(currentDir), "security", "ast-rules")
+  ];
+  for (const path2 of possiblePaths) {
+    if (existsSync2(path2)) return path2;
+  }
+  return join2(currentDir, "ast-rules");
+}
+function resolveWithinCwd(target) {
+  const resolved = resolve2(target);
+  const cwdRoot = resolve2(".");
+  if (resolved !== cwdRoot && !resolved.startsWith(cwdRoot + sep)) {
+    return { error: `Path traversal denied: scope must be within ${cwdRoot}` };
+  }
+  return { resolved };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
+var POLYGLOT_EXT_TO_LANG = {
+  ".py": "python",
+  ".go": "go"
+};
+function inferRuleLang(file) {
+  return POLYGLOT_EXT_TO_LANG[extname(file).toLowerCase()] ?? null;
+}
+async function findPolyglotFiles(dir, maxDepth) {
+  if (maxDepth <= 0) return [];
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (caught) {
+    const e = caught instanceof Error ? caught : new Error(String(caught));
+    logger5.warn(`ast-rule-runner: skipped unreadable directory ${dir}: ${e.message}`);
+    return out;
+  }
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+      out.push(...await findPolyglotFiles(fullPath, maxDepth - 1));
+    } else if (entry.isFile() && inferRuleLang(entry.name) !== null) {
+      out.push(fullPath);
+    }
+  }
+  return out;
+}
+function langToParseArg(lang) {
+  ensurePolyglotLangs();
+  return lang;
+}
+function scanFile(src, lang, applicable, budget) {
+  const { rel, limit, alreadyFound } = budget;
+  const root = parse(langToParseArg(lang), src).root();
+  const lines = src.split("\n");
+  const findings = [];
+  let total = 0;
+  for (const rule of applicable) {
+    const config = { rule: rule.rule };
+    for (const node of root.findAll(config)) {
+      total += 1;
+      if (alreadyFound + findings.length < limit) {
+        const { start } = node.range();
+        const rawLine = lines[start.line] ?? node.text();
+        findings.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          message: rule.message,
+          file: rel,
+          line: start.line + 1,
+          column: start.column + 1,
+          snippet: rawLine.trim().slice(0, MAX_SNIPPET_CHARS)
+        });
+      }
+    }
+  }
+  return { findings, total };
+}
+async function assertScanRootIsDirectory(resolved) {
+  let rootStat;
+  try {
+    rootStat = await stat(resolved);
+  } catch (caught) {
+    const e = caught instanceof Error ? caught : new Error(String(caught));
+    throw new ValidationError(`ast-rule-runner: cannot read targetDir ${resolved}: ${e.message}`, {
+      cause: e
+    });
+  }
+  if (!rootStat.isDirectory()) {
+    throw new ValidationError(
+      `ast-rule-runner: targetDir must be a directory, got a non-directory path: ${resolved}`
+    );
+  }
+}
+async function resolveScanFiles(root) {
+  const discovered = await findPolyglotFiles(root, AST_QA_MAX_DEPTH);
+  const files = discovered.slice(0, MAX_FILES_SCANNED);
+  const filesSkipped = discovered.length - files.length;
+  const filesTruncated = filesSkipped > 0;
+  if (filesTruncated) {
+    logger5.warn(
+      `ast-rule-runner: ${String(filesSkipped)} file(s) NOT scanned \u2014 file cap ${String(MAX_FILES_SCANNED)} exceeded (discovered=${String(discovered.length)}). Scan is PARTIAL; do not treat findings as exhaustive.`
+    );
+  }
+  return { files, filesSkipped, filesTruncated };
+}
+async function collectAstQaFindings(opts) {
+  const guard = resolveWithinCwd(opts.targetDir);
+  if ("error" in guard) {
+    throw new SecurityError(guard.error);
+  }
+  await assertScanRootIsDirectory(guard.resolved);
+  const rulesDir = opts.rulesDir ?? getBuiltInAstRulesPath();
+  const rules = await loadRules(rulesDir);
+  const limit = Math.min(Math.max(opts.limit ?? DEFAULT_AST_QA_LIMIT, 1), MAX_AST_QA_LIMIT);
+  const { files, filesSkipped, filesTruncated } = await resolveScanFiles(guard.resolved);
+  const findings = [];
+  let total = 0;
+  for (const file of files) {
+    const lang = inferRuleLang(file);
+    if (lang === null) continue;
+    const applicable = rules.filter((r) => r.language === lang);
+    if (applicable.length === 0) continue;
+    let src;
+    try {
+      src = await readFile(file, "utf8");
+    } catch {
+      logger5.warn(`ast-rule-runner: skipped unreadable file ${file}`);
+      continue;
+    }
+    const rel = relative(guard.resolved, file) || file;
+    const scanned = scanFile(src, lang, applicable, { rel, limit, alreadyFound: findings.length });
+    findings.push(...scanned.findings);
+    total += scanned.total;
+  }
+  if (total > findings.length) {
+    logger5.warn(
+      `ast-rule-runner: ${String(total - findings.length)} finding(s) omitted beyond limit=${String(limit)} (total=${String(total)})`
+    );
+  }
+  return { findings, total, limit, filesScanned: files.length, filesSkipped, filesTruncated };
+}
+async function runAstQaRules(opts) {
+  const { findings } = await collectAstQaFindings(opts);
+  return findings;
+}
+
 // src/orchestration/spec-parser-types.ts
 import { z as z8 } from "zod";
 var IssueReferenceSchema = z8.object({
@@ -4568,7 +3567,7 @@ var DEFAULT_BENCHMARK_CONFIG = {
 
 // src/benchmarks/benchmark-runner.ts
 import { cpus, totalmem, platform, arch } from "os";
-var logger5 = createLogger({ component: "benchmark-runner" });
+var logger6 = createLogger({ component: "benchmark-runner" });
 var LatencySampler = class {
   samples = [];
   startTimes = /* @__PURE__ */ new Map();
@@ -4664,11 +3663,11 @@ async function runOperationBenchmark(operation, datasetSize, fn, config = {}) {
   const startTime = getTimeProvider().now();
   const startMemory = process.memoryUsage().heapUsed;
   let peakMemory = startMemory;
-  logger5.debug("Running warmup", { operation, iterations: cfg.warmupIterations });
+  logger6.debug("Running warmup", { operation, iterations: cfg.warmupIterations });
   for (let i = 0; i < cfg.warmupIterations; i++) {
     await fn();
   }
-  logger5.debug("Running measurements", { operation, iterations: cfg.measurementIterations });
+  logger6.debug("Running measurements", { operation, iterations: cfg.measurementIterations });
   for (let i = 0; i < cfg.measurementIterations; i++) {
     const id = `op-${String(i)}`;
     sampler.start(id);
@@ -4793,7 +3792,7 @@ ${"=".repeat(60)}`);
 }
 
 // src/benchmarks/memory-benchmarks.ts
-var logger6 = createLogger({ component: "memory-benchmarks" });
+var logger7 = createLogger({ component: "memory-benchmarks" });
 var DEFAULT_MEMORY_BENCHMARK_CONFIG = {
   ...DEFAULT_BENCHMARK_CONFIG,
   contentSizeBytes: 1024,
@@ -4901,9 +3900,9 @@ async function benchmarkPrune(backend, data, config) {
 async function runMemoryBenchmarks(backend, name, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const operations = [];
-  logger6.info("Starting memory benchmarks", { name, sizes: cfg.datasetSizes });
+  logger7.info("Starting memory benchmarks", { name, sizes: cfg.datasetSizes });
   for (const size of cfg.datasetSizes) {
-    logger6.info("Running benchmarks for dataset size", { size });
+    logger7.info("Running benchmarks for dataset size", { size });
     const data = generateTestData(size, cfg);
     try {
       const futureDate = new Date(getTimeProvider().now() + 365 * 24 * 60 * 60 * 1e3);
@@ -4917,7 +3916,7 @@ async function runMemoryBenchmarks(backend, name, config = {}) {
   }
   const environment = getBenchmarkEnvironment();
   const summary = createBenchmarkSummary(operations, cfg);
-  logger6.info("Benchmarks complete", {
+  logger7.info("Benchmarks complete", {
     name,
     passed: summary.passed,
     avgP95: summary.avgP95Latency,
@@ -4963,7 +3962,7 @@ function compareBenchmarks(baseline, current) {
 }
 
 // src/benchmarks/token-benchmark.ts
-var logger7 = createLogger({ component: "token-benchmark" });
+var logger8 = createLogger({ component: "token-benchmark" });
 var CHARS_PER_TOKEN = 4;
 function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
@@ -4981,7 +3980,7 @@ async function runTokenBenchmark(backend, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const results = [];
   for (const size of cfg.datasetSizes) {
-    logger7.info("Running token benchmark", { size });
+    logger8.info("Running token benchmark", { size });
     const data = generateTestData(size, cfg);
     for (const entry of data.entries) {
       await backend.store(entry.key, entry.content, {
@@ -5014,15 +4013,15 @@ async function runTokenBenchmark(backend, config = {}) {
 }
 
 // src/benchmarks/consolidation-benchmark.ts
-var logger8 = createLogger({ component: "consolidation-benchmark" });
+var logger9 = createLogger({ component: "consolidation-benchmark" });
 async function runConsolidationBenchmark(operations, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const benchmarks = [];
-  logger8.info("Starting consolidation benchmarks", {
+  logger9.info("Starting consolidation benchmarks", {
     operationCount: operations.length
   });
   for (const op of operations) {
-    logger8.info("Benchmarking consolidation operation", { name: op.name });
+    logger9.info("Benchmarking consolidation operation", { name: op.name });
     const benchmark = await runOperationBenchmark(
       op.name,
       0,
@@ -5137,7 +4136,7 @@ function formatBenchmarkReport(report) {
 }
 
 // src/benchmarks/adapter-latency-benchmark.ts
-var logger9 = createLogger({ component: "adapter-latency-benchmark" });
+var logger10 = createLogger({ component: "adapter-latency-benchmark" });
 var DEFAULT_ADAPTER_LATENCY_CONFIG = {
   warmupIterations: 3,
   measurementIterations: 10,
@@ -5187,7 +4186,7 @@ async function benchmarkScenario(adapter, scenario, config) {
   const errors = [];
   let successCount = 0;
   let failureCount = 0;
-  logger9.info("Benchmarking scenario", {
+  logger10.info("Benchmarking scenario", {
     adapter: adapter.name,
     scenario: scenario.name,
     warmup: config.warmupIterations,
@@ -5614,7 +4613,7 @@ var GateCheckResultSchema = z16.object({
 });
 
 // src/pipeline/quality-pipeline.ts
-var logger10 = createLogger({ component: "quality-pipeline" });
+var logger11 = createLogger({ component: "quality-pipeline" });
 
 // src/pipeline/iterative-consensus.ts
 var defaultLogger = createLogger({ component: "iterative-consensus" });
@@ -5715,7 +4714,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-USZFJO2K.js");
+    const { executeVoting } = await import("./consensus-vote-KF6M7NZJ.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -5748,17 +4747,19 @@ function parseVotingResult(result) {
 }
 
 // src/replay/replay-executor.ts
-var logger11 = createLogger({ component: "ReplayExecutor" });
+var logger12 = createLogger({ component: "ReplayExecutor" });
 export {
   ALLOWED_COMMANDS,
   ARTIFACT_TYPES,
+  AST_RULE_LANGUAGES,
+  AST_RULE_SEVERITIES,
   AUDIT_PIPELINE_TEMPLATE,
   AbTestTracker,
   ActivationStrategySchema,
   AdapterConfigSchema,
   AdapterFactory,
   AdapterModelError,
-  RateLimiter2 as AdapterRateLimiter,
+  RateLimiter as AdapterRateLimiter,
   AgentActionSchema,
   AgentCapability,
   AgentError,
@@ -5862,6 +4863,7 @@ export {
   DECEPTION_CATEGORY,
   DEFAULT_ACTIVATION_OPTIONS,
   DEFAULT_ADAPTER_LATENCY_CONFIG,
+  DEFAULT_AST_QA_LIMIT,
   DEFAULT_BENCHMARK_CONFIG,
   DEFAULT_BUDGET,
   DEFAULT_COLLECT_STREAM_MAX_CHUNKS,
@@ -5994,12 +4996,14 @@ export {
   LoadedSkillSetSchema,
   LoggingConfigSchema,
   MANIPULATION_CATEGORY,
+  MAX_AST_QA_LIMIT,
   MAX_DIFF_LENGTH,
   MAX_EXECUTION_TIME_MS,
+  MAX_FILES_SCANNED,
   MEM0_TARGETS,
   MIN_EXPERTS_FOR_PATTERN,
   MODEL_CAPABILITIES,
-  RateLimiter as McpRateLimiter,
+  RateLimiter2 as McpRateLimiter,
   MemoryError,
   MemoryQueryInputSchema,
   MemoryStatsInputSchema,
@@ -6083,6 +5087,7 @@ export {
   ReasoningNodeSchema,
   ReasoningStepTypeSchema,
   ReasoningTreeSchema,
+  RecoverableExpert,
   RegistryError,
   RegistryImportInputSchema,
   RejectionCategorySchema,
@@ -6276,6 +5281,7 @@ export {
   checkPipelinePolicy,
   checkpointToResult,
   chunkByDirectory,
+  classifyExpertFailure,
   classifyTask,
   classifyTrust,
   cleanupCheckpoint,
@@ -6284,6 +5290,7 @@ export {
   calculateBackoffDelay as cliCalculateBackoffDelay,
   categorizeError as cliCategorizeError,
   closeServer,
+  collectAstQaFindings,
   collectRealVotes,
   collectStream,
   compareBenchmarks,
@@ -6433,6 +5440,7 @@ export {
   emitStateUpdated,
   emitStepCompleted,
   emitTrustEvent,
+  ensurePolyglotLangs,
   err,
   estimateTokens2 as estimateBenchmarkTokens,
   estimateTaskComplexity,
@@ -6476,6 +5484,7 @@ export {
   getAvailableClis,
   getAvailableRoles,
   getBenchmarkEnvironment,
+  getBuiltInAstRulesPath,
   getBuiltInTemplates,
   getBuiltInTemplatesPath,
   getBuiltInTemplatesWithMetadata,
@@ -6536,6 +5545,7 @@ export {
   isZodError,
   listTemplateIds,
   loadCheckpointState,
+  loadRules,
   loadTemplateFile,
   loadTemplatesFromDirectory,
   loadWorkflowFile,
@@ -6626,6 +5636,7 @@ export {
   resultToOutcome,
   runAdapterLatencyBenchmark,
   runAdaptiveOrchestrator,
+  runAstQaRules,
   runBenchmark,
   runConsensusGate,
   runConsolidationBenchmark,