@dotdo/postgres 0.1.0

package/src/routing/adaptive-router.test.ts

@@ -0,0 +1,884 @@
+/**
+ * RED PHASE TESTS: Adaptive Routing (learn from history)
+ *
+ * Task: postgres-d6g.10
+ *
+ * Purpose: Learn from execution history to improve routing decisions.
+ * Uses actual CPU time measurements to adjust complexity estimates.
+ *
+ * Key features:
+ * - Learn from execution history
+ * - Adjust complexity weights based on observed performance
+ * - Per-query routing optimization
+ * - A/B testing for routing strategies
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  AdaptiveRouter,
+  AdaptiveConfig,
+  LearningModel,
+  RoutingStrategy,
+  StrategyComparison,
+} from './adaptive-router'
+
+describe('AdaptiveRouter', () => {
+  describe('learning from history', () => {
+    it('should record execution outcomes', async () => {
+      const router = new AdaptiveRouter()
+
+      await router.recordOutcome({
+        sql: 'SELECT * FROM users WHERE id = 1',
+        sqlHash: 'hash1',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 15,
+        runtime: 'worker',
+        timestamp: Date.now(),
+      })
+
+      const history = router.getHistory('hash1')
+      expect(history).toHaveLength(1)
+      expect(history[0].actualCpuTimeMs).toBe(15)
+    })
+
+    it('should track prediction accuracy', async () => {
+      const router = new AdaptiveRouter()
+
+      // Record some predictions
+      await router.recordOutcome({
+        sql: 'SELECT 1',
+        sqlHash: 'hash1',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 12, // 20% off
+        runtime: 'worker',
+        timestamp: Date.now(),
+      })
+
+      await router.recordOutcome({
+        sql: 'SELECT 2',
+        sqlHash: 'hash2',
+        predictedCpuTimeMs: 50,
+        actualCpuTimeMs: 45, // 10% off
+        runtime: 'durable-object',
+        timestamp: Date.now(),
+      })
+
+      const accuracy = router.getPredictionAccuracy()
+      expect(accuracy.meanAbsoluteError).toBeDefined()
+      expect(accuracy.predictionCount).toBe(2)
+    })
+
+    it('should use historical average for known queries', async () => {
+      const router = new AdaptiveRouter()
+      const sql = 'SELECT * FROM orders WHERE status = $1'
+      const sqlHash = 'orders-query'
+
+      // Record several executions
+      for (let i = 0; i < 5; i++) {
+        await router.recordOutcome({
+          sql,
+          sqlHash,
+          predictedCpuTimeMs: 30,
+          actualCpuTimeMs: 40 + i * 2, // 40, 42, 44, 46, 48
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      const prediction = await router.predictCpuTime(sql, sqlHash)
+      expect(prediction.source).toBe('history')
+      // Average of 40, 42, 44, 46, 48 = 44
+      expect(prediction.estimatedMs).toBeCloseTo(44, 0)
+    })
+  })
+
+  describe('weight adjustment', () => {
+    it('should adjust JOIN weight based on observations', async () => {
+      const router = new AdaptiveRouter()
+
+      // Record JOIN queries that take longer than predicted
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM users u JOIN orders o ON u.id = o.user_id',
+          sqlHash: 'join-query',
+          predictedCpuTimeMs: 20,
+          actualCpuTimeMs: 50, // Much higher than predicted
+          runtime: 'worker',
+          timestamp: Date.now(),
+          factors: { joinCount: 1 },
+        })
+      }
+
+      const weights = router.getAdjustedWeights()
+      // JOIN weight should be increased since actual > predicted
+      expect(weights.perJoin).toBeGreaterThan(15) // Default is 15
+    })
+
+    it('should adjust aggregation weight based on observations', async () => {
+      const router = new AdaptiveRouter()
+
+      // Record aggregation queries that are faster than predicted
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT COUNT(*) FROM users',
+          sqlHash: 'count-query',
+          predictedCpuTimeMs: 30,
+          actualCpuTimeMs: 15, // Faster than predicted
+          runtime: 'worker',
+          timestamp: Date.now(),
+          factors: { hasAggregation: true },
+        })
+      }
+
+      const weights = router.getAdjustedWeights()
+      // Aggregation weight should be decreased since actual < predicted
+      expect(weights.aggregation).toBeLessThan(10) // Default is 10
+    })
+  })
+
+  describe('per-query optimization', () => {
+    it('should create query-specific models', async () => {
+      const router = new AdaptiveRouter()
+      const sqlHash = 'specific-query'
+
+      // Record enough samples for model building
+      for (let i = 0; i < 20; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM products WHERE category = $1',
+          sqlHash,
+          predictedCpuTimeMs: 25,
+          actualCpuTimeMs: 20 + Math.random() * 10,
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      const hasModel = router.hasQueryModel(sqlHash)
+      expect(hasModel).toBe(true)
+    })
+
+    it('should use query-specific model for prediction', async () => {
+      const router = new AdaptiveRouter()
+      const sqlHash = 'product-query'
+
+      // Record consistent pattern
+      for (let i = 0; i < 20; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM products WHERE id = $1',
+          sqlHash,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 5, // Consistently faster
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      const prediction = await router.predictCpuTime(
+        'SELECT * FROM products WHERE id = $1',
+        sqlHash
+      )
+      expect(prediction.estimatedMs).toBeLessThan(10)
+    })
+  })
+
+  describe('routing strategy comparison', () => {
+    it('should support A/B testing of routing strategies', async () => {
+      const router = new AdaptiveRouter({
+        enableABTesting: true,
+        abTestingRatio: 0.1, // 10% goes to alternative
+      })
+
+      const strategies: RoutingStrategy[] = []
+      for (let i = 0; i < 100; i++) {
+        const decision = await router.route('SELECT 1')
+        strategies.push(decision.strategy)
+      }
+
+      // Should have both strategies
+      expect(strategies.filter(s => s === 'primary').length).toBeGreaterThan(0)
+      expect(strategies.filter(s => s === 'alternative').length).toBeGreaterThan(0)
+    })
+
+    it('should compare strategy performance', async () => {
+      const router = new AdaptiveRouter({
+        enableABTesting: true,
+      })
+
+      // Record outcomes for both strategies
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash: 'test',
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: Date.now(),
+          strategy: 'primary',
+        })
+
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash: 'test',
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 12,
+          runtime: 'worker',
+          timestamp: Date.now(),
+          strategy: 'alternative',
+        })
+      }
+
+      const comparison = router.compareStrategies()
+      expect(comparison.primary).toBeDefined()
+      expect(comparison.alternative).toBeDefined()
+      expect(comparison.winner).toBeDefined()
+    })
+
+    it('should auto-select best strategy after sufficient data', async () => {
+      const router = new AdaptiveRouter({
+        enableABTesting: true,
+        minSamplesForDecision: 20,
+      })
+
+      // Record many outcomes showing alternative is better
+      for (let i = 0; i < 25; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash: 'test',
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 20,
+          runtime: 'worker',
+          timestamp: Date.now(),
+          strategy: 'primary',
+        })
+
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash: 'test',
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 8,
+          runtime: 'worker',
+          timestamp: Date.now(),
+          strategy: 'alternative',
+        })
+      }
+
+      const selected = router.getSelectedStrategy()
+      expect(selected).toBe('alternative')
+    })
+  })
+
+  describe('confidence-based routing', () => {
+    it('should route conservatively for low confidence predictions', async () => {
+      const router = new AdaptiveRouter({
+        conservativeThreshold: 'low',
+      })
+
+      // Complex query with subqueries has low confidence (harder to estimate)
+      const decision = await router.route(`
+        SELECT * FROM users WHERE id IN (
+          SELECT user_id FROM orders WHERE total > (
+            SELECT AVG(total) FROM orders
+          )
+        )
+      `)
+
+      // Subqueries result in lower confidence
+      expect(['low', 'medium']).toContain(decision.confidence)
+    })
+
+    it('should route aggressively for high confidence predictions', async () => {
+      const router = new AdaptiveRouter()
+      const sqlHash = 'known-fast-query'
+
+      // Build up confidence with consistent history
+      for (let i = 0; i < 50; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT id FROM users WHERE id = 1',
+          sqlHash,
+          predictedCpuTimeMs: 5,
+          actualCpuTimeMs: 5 + Math.random() * 2, // Very consistent
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      const prediction = await router.predictCpuTime(
+        'SELECT id FROM users WHERE id = 1',
+        sqlHash
+      )
+      expect(prediction.confidence).toBe('high')
+    })
+  })
+
+  describe('time-based decay', () => {
+    it('should weight recent observations more heavily', async () => {
+      const router = new AdaptiveRouter({
+        decayHalfLifeMs: 3600000, // 1 hour half-life
+      })
+
+      const now = Date.now()
+      const sqlHash = 'decay-test'
+
+      // Old observations (1 day ago) showing 100ms
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash,
+          predictedCpuTimeMs: 50,
+          actualCpuTimeMs: 100,
+          runtime: 'durable-object',
+          timestamp: now - 86400000, // 1 day ago
+        })
+      }
+
+      // Recent observations (now) showing 10ms (more extreme difference)
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash,
+          predictedCpuTimeMs: 50,
+          actualCpuTimeMs: 10,
+          runtime: 'worker',
+          timestamp: now,
+        })
+      }
+
+      const prediction = await router.predictCpuTime('SELECT 1', sqlHash)
+      // Should be closer to 10ms than 100ms due to recency weighting
+      // With 1-hour half-life and 1-day-old data, old data is heavily discounted
+      expect(prediction.estimatedMs).toBeLessThanOrEqual(55)
+    })
+  })
+
+  describe('feedback loop', () => {
+    it('should improve predictions over time', async () => {
+      const router = new AdaptiveRouter()
+      const sqlHash = 'improving-query'
+
+      // Initial predictions are off
+      const initialPrediction = await router.predictCpuTime(
+        'SELECT * FROM events WHERE type = $1',
+        sqlHash
+      )
+
+      // Record actual outcomes
+      for (let i = 0; i < 30; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM events WHERE type = $1',
+          sqlHash,
+          predictedCpuTimeMs: initialPrediction.estimatedMs,
+          actualCpuTimeMs: 35, // Actual is 35ms
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      // Prediction should improve
+      const improvedPrediction = await router.predictCpuTime(
+        'SELECT * FROM events WHERE type = $1',
+        sqlHash
+      )
+      expect(Math.abs(improvedPrediction.estimatedMs - 35)).toBeLessThan(
+        Math.abs(initialPrediction.estimatedMs - 35)
+      )
+    })
+  })
+
+  describe('model persistence', () => {
+    it('should export learned model', () => {
+      const router = new AdaptiveRouter()
+
+      const model = router.exportModel()
+      expect(model).toBeDefined()
+      expect(typeof model).toBe('string')
+    })
+
+    it('should import learned model', async () => {
+      const router1 = new AdaptiveRouter()
+
+      // Learn something
+      for (let i = 0; i < 20; i++) {
+        await router1.recordOutcome({
+          sql: 'SELECT 1',
+          sqlHash: 'test-hash',
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      const model = router1.exportModel()
+
+      // Import into new router
+      const router2 = new AdaptiveRouter()
+      router2.importModel(model)
+
+      const history = router2.getHistory('test-hash')
+      expect(history.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('warm start', () => {
+    it('should accept initial weights configuration', async () => {
+      const router = new AdaptiveRouter({
+        initialWeights: {
+          perJoin: 20,
+          aggregation: 15,
+        },
+      })
+
+      const weights = router.getAdjustedWeights()
+      expect(weights.perJoin).toBe(20)
+      expect(weights.aggregation).toBe(15)
+    })
+
+    it('should accept seed data for cold start', async () => {
+      const seedData = [
+        { sqlHash: 'q1', avgCpuTimeMs: 15, sampleCount: 100 },
+        { sqlHash: 'q2', avgCpuTimeMs: 75, sampleCount: 50 },
+      ]
+
+      const router = new AdaptiveRouter({
+        seedData,
+      })
+
+      const prediction1 = await router.predictCpuTime('SELECT 1', 'q1')
+      expect(prediction1.estimatedMs).toBeCloseTo(15)
+
+      const prediction2 = await router.predictCpuTime('SELECT 2', 'q2')
+      expect(prediction2.estimatedMs).toBeCloseTo(75)
+    })
+  })
+
+  describe('anomaly detection', () => {
+    it('should detect sudden performance changes', async () => {
+      const router = new AdaptiveRouter()
+      const sqlHash = 'stable-query'
+
+      // Record stable performance
+      for (let i = 0; i < 20; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM users',
+          sqlHash,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 10 + Math.random() * 2,
+          runtime: 'worker',
+          timestamp: Date.now() - 100000 + i * 1000,
+        })
+      }
+
+      // Record sudden spike
+      await router.recordOutcome({
+        sql: 'SELECT * FROM users',
+        sqlHash,
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 100, // 10x slower
+        runtime: 'worker',
+        timestamp: Date.now(),
+      })
+
+      const anomalies = router.detectPerformanceAnomalies(sqlHash)
+      expect(anomalies.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('integration with RuntimeRouter', () => {
+    it('should provide predictions compatible with RuntimeRouter', async () => {
+      const router = new AdaptiveRouter()
+
+      const decision = await router.route('SELECT * FROM users WHERE id = 1')
+
+      expect(decision.target).toBeDefined()
+      expect(decision.estimatedMs).toBeDefined()
+      expect(['worker', 'durable-object']).toContain(decision.target)
+    })
+  })
+
+  describe('history pruning', () => {
+    it('should limit history to maxHistoryEntries unique query hashes', async () => {
+      const maxHistoryEntries = 100
+      const router = new AdaptiveRouter({
+        maxHistoryEntries,
+      })
+
+      // Add more unique queries than the limit
+      const numQueries = 150
+      for (let i = 0; i < numQueries; i++) {
+        await router.recordOutcome({
+          sql: `SELECT * FROM table_${i}`,
+          sqlHash: `hash-${i}`,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      // Get total history size
+      const historySize = router.getHistorySize()
+      expect(historySize).toBeLessThanOrEqual(maxHistoryEntries)
+    })
+
+    it('should evict oldest entries when limit is reached (LRU)', async () => {
+      const maxHistoryEntries = 10
+      const router = new AdaptiveRouter({
+        maxHistoryEntries,
+      })
+
+      // Add queries with timestamps in order
+      const baseTime = Date.now()
+      for (let i = 0; i < 15; i++) {
+        await router.recordOutcome({
+          sql: `SELECT * FROM table_${i}`,
+          sqlHash: `hash-${i}`,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: baseTime + i * 1000,
+        })
+      }
+
+      // First 5 hashes should be evicted (oldest), last 10 should remain
+      const oldestHistory = router.getHistory('hash-0')
+      const newestHistory = router.getHistory('hash-14')
+
+      expect(oldestHistory).toHaveLength(0)
+      expect(newestHistory.length).toBeGreaterThan(0)
+    })
+
+    it('should prune entries older than maxHistoryAgeMs', async () => {
+      const maxHistoryAgeMs = 3600000 // 1 hour
+      const router = new AdaptiveRouter({
+        maxHistoryAgeMs,
+      })
+
+      const now = Date.now()
+      const oldTimestamp = now - 2 * maxHistoryAgeMs // 2 hours ago
+      const recentTimestamp = now - maxHistoryAgeMs / 2 // 30 minutes ago
+
+      // Add old entry
+      await router.recordOutcome({
+        sql: 'SELECT * FROM old_query',
+        sqlHash: 'old-hash',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 15,
+        runtime: 'worker',
+        timestamp: oldTimestamp,
+      })
+
+      // Add recent entry
+      await router.recordOutcome({
+        sql: 'SELECT * FROM recent_query',
+        sqlHash: 'recent-hash',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 15,
+        runtime: 'worker',
+        timestamp: recentTimestamp,
+      })
+
+      // Trigger pruning
+      router.pruneOldEntries()
+
+      // Old entry should be pruned
+      const oldHistory = router.getHistory('old-hash')
+      const recentHistory = router.getHistory('recent-hash')
+
+      expect(oldHistory).toHaveLength(0)
+      expect(recentHistory.length).toBeGreaterThan(0)
+    })
+
+    it('should handle 10000+ unique query hashes without unbounded growth', async () => {
+      const maxHistoryEntries = 1000
+      const router = new AdaptiveRouter({
+        maxHistoryEntries,
+      })
+
+      // Add 10000+ unique queries
+      const numQueries = 10500
+      for (let i = 0; i < numQueries; i++) {
+        await router.recordOutcome({
+          sql: `SELECT * FROM table_${i} WHERE id = ${i}`,
+          sqlHash: `hash-${i}`,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: Date.now(),
+        })
+      }
+
+      // History should be bounded to maxHistoryEntries
+      const historySize = router.getHistorySize()
+      expect(historySize).toBeLessThanOrEqual(maxHistoryEntries)
+      expect(historySize).toBe(maxHistoryEntries)
+    })
+
+    it('should use default values when config not provided', () => {
+      const router = new AdaptiveRouter()
+      const config = router.getConfig()
+
+      expect(config.maxHistoryEntries).toBe(1000)
+      expect(config.maxHistoryAgeMs).toBe(3600000) // 1 hour
+    })
+
+    it('should update last access time when query is accessed (LRU behavior)', async () => {
+      const maxHistoryEntries = 5
+      const router = new AdaptiveRouter({
+        maxHistoryEntries,
+      })
+
+      // Add initial queries
+      for (let i = 0; i < 5; i++) {
+        await router.recordOutcome({
+          sql: `SELECT * FROM table_${i}`,
+          sqlHash: `hash-${i}`,
+          predictedCpuTimeMs: 10,
+          actualCpuTimeMs: 15,
+          runtime: 'worker',
+          timestamp: Date.now() - (5 - i) * 1000,
+        })
+      }
+
+      // Access hash-0 again (making it recently used)
+      await router.recordOutcome({
+        sql: 'SELECT * FROM table_0',
+        sqlHash: 'hash-0',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 15,
+        runtime: 'worker',
+        timestamp: Date.now(),
+      })
+
+      // Add one more query to trigger eviction
+      await router.recordOutcome({
+        sql: 'SELECT * FROM table_new',
+        sqlHash: 'hash-new',
+        predictedCpuTimeMs: 10,
+        actualCpuTimeMs: 15,
+        runtime: 'worker',
+        timestamp: Date.now(),
+      })
+
+      // hash-0 should still exist (was recently accessed)
+      // hash-1 should be evicted (oldest without recent access)
+      const hash0History = router.getHistory('hash-0')
+      const hash1History = router.getHistory('hash-1')
+
+      expect(hash0History.length).toBeGreaterThan(0)
+      expect(hash1History).toHaveLength(0)
+    })
+  })
+
+  describe('complexity weights configuration', () => {
+    it('should provide default weights via static method', () => {
+      const defaults = AdaptiveRouter.getDefaultWeights()
+
+      expect(defaults).toBeDefined()
+      expect(defaults.baseQuery).toBe(1)
+      expect(defaults.perJoin).toBe(15)
+      expect(defaults.perSubquery).toBe(20)
+      expect(defaults.perUnion).toBe(10)
+      expect(defaults.perCte).toBe(15)
+      expect(defaults.perWindowFunction).toBe(25)
+      expect(defaults.aggregation).toBe(10)
+      expect(defaults.groupBy).toBe(8)
+      expect(defaults.having).toBe(5)
+      expect(defaults.orderBy).toBe(8)
+      expect(defaults.distinct).toBe(10)
+      expect(defaults.noLimit).toBe(15)
+      expect(defaults.fullTableScan).toBe(20)
+      expect(defaults.largeTableMultiplier).toBe(0.00001)
+      expect(defaults.transaction).toBe(5)
+    })
+
+    it('should return a copy of default weights (immutability)', () => {
+      const defaults1 = AdaptiveRouter.getDefaultWeights()
+      defaults1.perJoin = 999
+
+      const defaults2 = AdaptiveRouter.getDefaultWeights()
+      expect(defaults2.perJoin).toBe(15) // Original unchanged
+    })
+
+    it('should accept full complexityWeights configuration', () => {
+      const customWeights = {
+        baseQuery: 2,
+        perJoin: 25,
+        perSubquery: 30,
+        perUnion: 15,
+        perCte: 20,
+        perWindowFunction: 35,
+        aggregation: 15,
+        groupBy: 12,
+        having: 8,
+        orderBy: 12,
+        distinct: 15,
+        noLimit: 20,
+        fullTableScan: 30,
+        largeTableMultiplier: 0.00002,
+        transaction: 8,
+      }
+
+      const router = new AdaptiveRouter({
+        complexityWeights: customWeights,
+      })
+
+      const weights = router.getAdjustedWeights()
+      expect(weights).toEqual(customWeights)
+    })
+
+    it('should prioritize complexityWeights over initialWeights', () => {
+      const router = new AdaptiveRouter({
+        initialWeights: {
+          perJoin: 100, // Would be 100 if used
+        },
+        complexityWeights: {
+          baseQuery: 1,
+          perJoin: 50, // This should be used instead
+          perSubquery: 20,
+          perUnion: 10,
+          perCte: 15,
+          perWindowFunction: 25,
+          aggregation: 10,
+          groupBy: 8,
+          having: 5,
+          orderBy: 8,
+          distinct: 10,
+          noLimit: 15,
+          fullTableScan: 20,
+          largeTableMultiplier: 0.00001,
+          transaction: 5,
+        },
+      })
+
+      const weights = router.getAdjustedWeights()
+      expect(weights.perJoin).toBe(50) // complexityWeights takes precedence
+    })
+
+    it('should merge initialWeights with defaults when complexityWeights not provided', () => {
+      const router = new AdaptiveRouter({
+        initialWeights: {
+          perJoin: 30,
+          aggregation: 20,
+        },
+      })
+
+      const weights = router.getAdjustedWeights()
+      expect(weights.perJoin).toBe(30) // Overridden
+      expect(weights.aggregation).toBe(20) // Overridden
+      expect(weights.perSubquery).toBe(20) // Default preserved
+      expect(weights.baseQuery).toBe(1) // Default preserved
+    })
+
+    it('should calculate complexity score using configured weights', async () => {
+      // Use custom weights with higher JOIN cost
+      const router = new AdaptiveRouter({
+        initialWeights: {
+          perJoin: 50, // Much higher than default 15
+        },
+      })
+
+      // Record outcomes with JOIN factors
+      for (let i = 0; i < 10; i++) {
+        await router.recordOutcome({
+          sql: 'SELECT * FROM a JOIN b ON a.id = b.id',
+          sqlHash: 'join-test',
+          predictedCpuTimeMs: 50,
+          actualCpuTimeMs: 60,
+          runtime: 'durable-object',
+          timestamp: Date.now(),
+          factors: { joinCount: 1 },
+        })
+      }
+
+      const weights = router.getAdjustedWeights()
+      // Weight should have been adjusted from our custom starting point (50)
+      expect(weights.perJoin).toBeGreaterThan(15) // Higher than default
+    })
+
+    it('should allow creating custom weights based on defaults', () => {
+      const defaults = AdaptiveRouter.getDefaultWeights()
+
+      // Create custom weights with some modifications
+      const customWeights = {
+        ...defaults,
+        perJoin: defaults.perJoin * 2, // Double JOIN cost
+        perWindowFunction: defaults.perWindowFunction * 1.5, // 50% higher window function cost
+      }
+
+      const router = new AdaptiveRouter({
+        complexityWeights: customWeights,
+      })
+
+      const weights = router.getAdjustedWeights()
+      expect(weights.perJoin).toBe(30) // 15 * 2
+      expect(weights.perWindowFunction).toBe(37.5) // 25 * 1.5
+      expect(weights.aggregation).toBe(10) // Unchanged from default
+    })
+
+    it('should include complexityWeights in exported config', () => {
+      const customWeights = {
+        baseQuery: 2,
+        perJoin: 25,
+        perSubquery: 30,
+        perUnion: 15,
+        perCte: 20,
+        perWindowFunction: 35,
+        aggregation: 15,
+        groupBy: 12,
+        having: 8,
+        orderBy: 12,
+        distinct: 15,
+        noLimit: 20,
+        fullTableScan: 30,
+        largeTableMultiplier: 0.00002,
+        transaction: 8,
+      }
+
+      const router = new AdaptiveRouter({
+        complexityWeights: customWeights,
+      })
+
+      const config = router.getConfig()
+      expect(config.complexityWeights).toEqual(customWeights)
+    })
+
+    it('should validate weight values are used in routing decisions', async () => {
+      // High threshold to test weight impact
+      const routerWithHighJoinWeight = new AdaptiveRouter({
+        cpuTimeThresholdMs: 40,
+        initialWeights: {
+          perJoin: 100, // Very high JOIN weight
+        },
+      })
+
+      const routerWithLowJoinWeight = new AdaptiveRouter({
+        cpuTimeThresholdMs: 40,
+        initialWeights: {
+          perJoin: 1, // Very low JOIN weight
+        },
+      })
+
+      // Record same outcome for both routers
+      const outcome = {
+        sql: 'SELECT * FROM a JOIN b ON a.id = b.id',
+        sqlHash: 'routing-test',
+        predictedCpuTimeMs: 30,
+        actualCpuTimeMs: 45,
+        runtime: 'durable-object' as const,
+        timestamp: Date.now(),
+      }
+
+      await routerWithHighJoinWeight.recordOutcome(outcome)
+      await routerWithLowJoinWeight.recordOutcome(outcome)
+
+      // Both should have recorded the outcome
+      expect(routerWithHighJoinWeight.getHistory('routing-test')).toHaveLength(1)
+      expect(routerWithLowJoinWeight.getHistory('routing-test')).toHaveLength(1)
+
+      // Weights should be different
+      const highWeights = routerWithHighJoinWeight.getAdjustedWeights()
+      const lowWeights = routerWithLowJoinWeight.getAdjustedWeights()
+      expect(highWeights.perJoin).toBeGreaterThan(lowWeights.perJoin)
+    })
+  })
+})