vibecodingmachine-core 2026.1.3-2209 → 2026.1.23-1010

package/tests/health-tracking/ide-health-tracker.test.js

@@ -0,0 +1,368 @@
+/**
+ * Unit Tests for IDEHealthTracker
+ * 
+ * Tests for health tracking functionality including success/failure recording,
+ * quota detection, and consecutive failure handling.
+ */
+
+const { IDEHealthTracker, MAX_RESPONSE_TIMES, CONSECUTIVE_FAILURE_THRESHOLD } = require('../../../src/health-tracking/ide-health-tracker');
+const { JSONStorage } = require('../../../src/health-tracking/json-storage');
+const { ValidationError } = require('../../../src/health-tracking/errors');
+
+describe('IDEHealthTracker', () => {
+  let tracker;
+  let mockStorage;
+
+  beforeEach(() => {
+    mockStorage = {
+      read: jest.fn().mockResolvedValue({
+        version: '1.0.0',
+        lastUpdated: new Date().toISOString(),
+        ides: {},
+        timeoutConfig: {
+          mode: 'fixed',
+          defaultTimeout: 1800000,
+          bufferPercentage: 0.4,
+          minSamplesForAdaptive: 10,
+          ewmaAlpha: 0.3
+        },
+        defaultRequirement: null
+      }),
+      write: jest.fn().mockResolvedValue(),
+      exists: jest.fn().mockResolvedValue(true)
+    };
+    
+    tracker = new IDEHealthTracker({ storage: mockStorage });
+  });
+
+  describe('recordSuccess', () => {
+    it('should increment success count and reset consecutive failures', async () => {
+      // First record a failure to test reset
+      await tracker.recordFailure('cursor', 'Test error');
+      let metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.consecutiveFailures).toBe(1);
+
+      // Now record success
+      await tracker.recordSuccess('cursor', 120000);
+      
+      metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(1);
+      expect(metrics.failureCount).toBe(1); // Previous failure remains
+      expect(metrics.consecutiveFailures).toBe(0); // Reset on success
+      expect(metrics.responseTimes).toContain(120000);
+      expect(metrics.lastSuccess).toBeTruthy();
+    });
+
+    it('should add response time to array and maintain max size', async () => {
+      // Add max number of response times
+      for (let i = 0; i < MAX_RESPONSE_TIMES + 5; i++) {
+        await tracker.recordSuccess('cursor', 100000 + i);
+      }
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.responseTimes.length).toBe(MAX_RESPONSE_TIMES);
+      expect(metrics.responseTimes).not.toContain(100000); // Oldest removed
+      expect(metrics.responseTimes).toContain(100000 + MAX_RESPONSE_TIMES + 4); // Newest included
+    });
+
+    it('should recalculate EWMA after each success', async () => {
+      await tracker.recordSuccess('cursor', 100000);
+      let metrics = await tracker.getHealthMetrics('cursor');
+      const firstEWMA = metrics.ewma;
+      expect(firstEWMA).toBe(100000); // First value becomes initial EWMA
+
+      await tracker.recordSuccess('cursor', 120000);
+      metrics = await tracker.getHealthMetrics('cursor');
+      const secondEWMA = metrics.ewma;
+      expect(secondEWMA).toBeGreaterThan(firstEWMA);
+      expect(secondEWMA).toBeLessThan(120000); // Weighted average
+    });
+
+    it('should record interaction details', async () => {
+      const options = {
+        continuationPromptsDetected: 2,
+        requirementId: 'req-042',
+        timeoutUsed: 180000
+      };
+
+      await tracker.recordSuccess('cursor', 120000, options);
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.interactions).toHaveLength(1);
+      
+      const interaction = metrics.interactions[0];
+      expect(interaction.outcome).toBe('success');
+      expect(interaction.responseTime).toBe(120000);
+      expect(interaction.continuationPromptsDetected).toBe(2);
+      expect(interaction.requirementId).toBe('req-042');
+      expect(interaction.timeoutUsed).toBe(180000);
+      expect(interaction.timestamp).toBeTruthy();
+    });
+
+    it('should validate IDE identifier', async () => {
+      await expect(tracker.recordSuccess('', 120000))
+        .rejects.toThrow(ValidationError);
+      
+      await expect(tracker.recordSuccess(null, 120000))
+        .rejects.toThrow(ValidationError);
+    });
+
+    it('should validate response time', async () => {
+      await expect(tracker.recordSuccess('cursor', -1000))
+        .rejects.toThrow(ValidationError);
+      
+      await expect(tracker.recordSuccess('cursor', 'invalid'))
+        .rejects.toThrow(ValidationError);
+    });
+  });
+
+  describe('recordFailure', () => {
+    it('should increment failure count and consecutive failures', async () => {
+      await tracker.recordFailure('cursor', 'Timeout exceeded');
+      
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(1);
+      expect(metrics.consecutiveFailures).toBe(1);
+      expect(metrics.lastFailure).toBeTruthy();
+    });
+
+    it('should accumulate consecutive failures', async () => {
+      for (let i = 0; i < 3; i++) {
+        await tracker.recordFailure('cursor', `Error ${i}`);
+      }
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.failureCount).toBe(3);
+      expect(metrics.consecutiveFailures).toBe(3);
+    });
+
+    it('should emit consecutive-failures event at threshold', async () => {
+      const eventSpy = jest.fn();
+      tracker.on('consecutive-failures', eventSpy);
+
+      // Add failures up to threshold
+      for (let i = 0; i < CONSECUTIVE_FAILURE_THRESHOLD; i++) {
+        await tracker.recordFailure('cursor', `Error ${i}`);
+      }
+
+      expect(eventSpy).toHaveBeenCalledTimes(1);
+      expect(eventSpy).toHaveBeenCalledWith({
+        ideId: 'cursor',
+        consecutiveFailures: CONSECUTIVE_FAILURE_THRESHOLD,
+        threshold: CONSECUTIVE_FAILURE_THRESHOLD
+      });
+    });
+
+    it('should record failure interaction details', async () => {
+      const options = {
+        requirementId: 'req-043',
+        timeoutUsed: 180000
+      };
+
+      await tracker.recordFailure('cursor', 'Network error', options);
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.interactions).toHaveLength(1);
+      
+      const interaction = metrics.interactions[0];
+      expect(interaction.outcome).toBe('failure');
+      expect(interaction.responseTime).toBeNull();
+      expect(interaction.errorMessage).toBe('Network error');
+      expect(interaction.requirementId).toBe('req-043');
+      expect(interaction.timeoutUsed).toBe(180000);
+    });
+
+    it('should validate error message', async () => {
+      await expect(tracker.recordFailure('cursor', ''))
+        .rejects.toThrow(ValidationError);
+      
+      await expect(tracker.recordFailure('cursor', null))
+        .rejects.toThrow(ValidationError);
+    });
+  });
+
+  describe('recordQuota', () => {
+    it('should record quota without changing counters', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordFailure('cursor', 'Test error');
+      
+      let metrics = await tracker.getHealthMetrics('cursor');
+      const successCount = metrics.successCount;
+      const failureCount = metrics.failureCount;
+
+      await tracker.recordQuota('cursor', 'Rate limit exceeded');
+
+      metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(successCount); // Unchanged
+      expect(metrics.failureCount).toBe(failureCount); // Unchanged
+      expect(metrics.consecutiveFailures).toBe(1); // Unchanged
+    });
+
+    it('should record quota interaction details', async () => {
+      const options = {
+        requirementId: 'req-044',
+        timeoutUsed: 180000
+      };
+
+      await tracker.recordQuota('cursor', 'Rate limit exceeded', options);
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.interactions).toHaveLength(1);
+      
+      const interaction = metrics.interactions[0];
+      expect(interaction.outcome).toBe('quota');
+      expect(interaction.responseTime).toBeNull();
+      expect(interaction.errorMessage).toBe('Rate limit exceeded');
+      expect(interaction.requirementId).toBe('req-044');
+      expect(interaction.timeoutUsed).toBe(180000);
+    });
+
+    it('should validate quota message', async () => {
+      await expect(tracker.recordQuota('cursor', ''))
+        .rejects.toThrow(ValidationError);
+      
+      await expect(tracker.recordQuota('cursor', null))
+        .rejects.toThrow(ValidationError);
+    });
+  });
+
+  describe('getHealthMetrics', () => {
+    it('should return default record for unknown IDE', async () => {
+      const metrics = await tracker.getHealthMetrics('unknown-ide');
+      
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(0);
+      expect(metrics.consecutiveFailures).toBe(0);
+      expect(metrics.responseTimes).toEqual([]);
+      expect(metrics.interactions).toEqual([]);
+      expect(metrics.ewma).toBe(0);
+      expect(metrics.currentTimeout).toBe(1800000); // Default timeout
+    });
+
+    it('should return recorded metrics for known IDE', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordFailure('cursor', 'Test error');
+      
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(1);
+      expect(metrics.failureCount).toBe(1);
+      expect(metrics.consecutiveFailures).toBe(1);
+      expect(metrics.responseTimes).toContain(120000);
+      expect(metrics.interactions).toHaveLength(2);
+    });
+  });
+
+  describe('getAllHealthMetrics', () => {
+    it('should return metrics for all IDEs', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordFailure('windsurf', 'Test error');
+      
+      const allMetrics = await tracker.getAllHealthMetrics();
+      
+      expect(allMetrics).toHaveProperty('cursor');
+      expect(allMetrics).toHaveProperty('windsurf');
+      expect(allMetrics.cursor.successCount).toBe(1);
+      expect(allMetrics.windsurf.failureCount).toBe(1);
+    });
+  });
+
+  describe('getRecommendedIDE', () => {
+    it('should return IDE with highest success rate', async () => {
+      // Setup IDEs with different success rates
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 130000);
+      await tracker.recordFailure('cursor', 'Error'); // 2/3 = 66.7%
+
+      await tracker.recordSuccess('windsurf', 150000);
+      await tracker.recordFailure('windsurf', 'Error'); // 1/2 = 50%
+
+      const recommended = await tracker.getRecommendedIDE();
+      expect(recommended).toBe('cursor');
+    });
+
+    it('should return null for no IDEs with sufficient data', async () => {
+      // Only failures, no successes
+      await tracker.recordFailure('cursor', 'Error');
+      
+      const recommended = await tracker.getRecommendedIDE();
+      expect(recommended).toBeNull();
+    });
+
+    it('should require minimum interactions for recommendation', async () => {
+      // Only one interaction - not enough data
+      await tracker.recordSuccess('cursor', 120000);
+      
+      const recommended = await tracker.getRecommendedIDE();
+      expect(recommended).toBeNull();
+    });
+  });
+
+  describe('save and load', () => {
+    it('should save data to storage', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.save();
+
+      expect(mockStorage.write).toHaveBeenCalledWith(
+        expect.objectContaining({
+          version: '1.0.0',
+          ides: expect.objectContaining({
+            cursor: expect.objectContaining({
+              successCount: 1,
+              failureCount: 0
+            })
+          })
+        })
+      );
+    });
+
+    it('should load data from storage', async () => {
+      const storedData = {
+        version: '1.0.0',
+        lastUpdated: new Date().toISOString(),
+        ides: {
+          cursor: {
+            successCount: 5,
+            failureCount: 2,
+            responseTimes: [120000, 130000],
+            ewma: 125000,
+            lastSuccess: new Date().toISOString(),
+            lastFailure: new Date().toISOString(),
+            consecutiveFailures: 0,
+            currentTimeout: 175000,
+            interactions: []
+          }
+        },
+        timeoutConfig: {
+          mode: 'fixed',
+          defaultTimeout: 1800000,
+          bufferPercentage: 0.4,
+          minSamplesForAdaptive: 10,
+          ewmaAlpha: 0.3
+        },
+        defaultRequirement: null
+      };
+
+      mockStorage.read.mockResolvedValue(storedData);
+      
+      await tracker.load();
+      
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(5);
+      expect(metrics.failureCount).toBe(2);
+      expect(metrics.responseTimes).toEqual([120000, 130000]);
+    });
+  });
+
+  describe('interaction array management', () => {
+    it('should maintain maximum interaction array size', async () => {
+      // Add more interactions than max
+      for (let i = 0; i < 105; i++) {
+        await tracker.recordSuccess('cursor', 120000);
+      }
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.interactions.length).toBeLessThanOrEqual(100);
+    });
+  });
+});

package/tests/health-tracking/interaction-recorder.test.js

@@ -0,0 +1,309 @@
+/**
+ * Unit Tests for InteractionRecorder
+ * 
+ * Tests for recording individual IDE interactions with timestamps,
+ * outcomes, and metadata.
+ */
+
+const { InteractionRecorder, MAX_INTERACTIONS, DEFAULT_IDE_RECORD } = require('../../../src/health-tracking/interaction-recorder');
+const { ValidationError } = require('../../../src/health-tracking/errors');
+
+describe('InteractionRecorder', () => {
+  let recorder;
+
+  beforeEach(() => {
+    recorder = new InteractionRecorder();
+  });
+
+  describe('recordInteraction', () => {
+    it('should record a successful interaction', () => {
+      const interaction = recorder.recordInteraction('cursor', 'success', {
+        responseTime: 120000,
+        timeoutUsed: 180000,
+        continuationPromptsDetected: 1,
+        requirementId: 'req-042'
+      });
+
+      expect(interaction.outcome).toBe('success');
+      expect(interaction.responseTime).toBe(120000);
+      expect(interaction.timeoutUsed).toBe(180000);
+      expect(interaction.continuationPromptsDetected).toBe(1);
+      expect(interaction.requirementId).toBe('req-042');
+      expect(interaction.errorMessage).toBeNull();
+      expect(interaction.timestamp).toBeTruthy();
+    });
+
+    it('should record a failed interaction', () => {
+      const interaction = recorder.recordInteraction('windsurf', 'failure', {
+        errorMessage: 'Timeout exceeded',
+        timeoutUsed: 1800000,
+        requirementId: 'req-043'
+      });
+
+      expect(interaction.outcome).toBe('failure');
+      expect(interaction.responseTime).toBeNull();
+      expect(interaction.errorMessage).toBe('Timeout exceeded');
+      expect(interaction.timeoutUsed).toBe(1800000);
+      expect(interaction.requirementId).toBe('req-043');
+    });
+
+    it('should record a quota detection', () => {
+      const interaction = recorder.recordInteraction('cursor', 'quota', {
+        errorMessage: 'Rate limit exceeded',
+        timeoutUsed: 180000,
+        requirementId: 'req-044'
+      });
+
+      expect(interaction.outcome).toBe('quota');
+      expect(interaction.responseTime).toBeNull();
+      expect(interaction.errorMessage).toBe('Rate limit exceeded');
+    });
+
+    it('should validate outcome', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'invalid');
+      }).toThrow(ValidationError);
+    });
+
+    it('should validate IDE identifier', () => {
+      expect(() => {
+        recorder.recordInteraction('', 'success');
+      }).toThrow(ValidationError);
+
+      expect(() => {
+        recorder.recordInteraction(null, 'success');
+      }).toThrow(ValidationError);
+    });
+
+    it('should validate response time for success', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { responseTime: -1000 });
+      }).toThrow(ValidationError);
+
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { responseTime: 'invalid' });
+      }).toThrow(ValidationError);
+    });
+
+    it('should set responseTime to null for non-success outcomes', () => {
+      const interaction = recorder.recordInteraction('cursor', 'failure', {
+        responseTime: 120000 // Should be ignored
+      });
+
+      expect(interaction.responseTime).toBeNull();
+    });
+
+    it('should validate timeoutUsed', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { timeoutUsed: -1000 });
+      }).toThrow(ValidationError);
+
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { timeoutUsed: 'invalid' });
+      }).toThrow(ValidationError);
+    });
+
+    it('should validate continuationPromptsDetected', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { continuationPromptsDetected: -1 });
+      }).toThrow(ValidationError);
+
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success', { continuationPromptsDetected: 'invalid' });
+      }).toThrow(ValidationError);
+    });
+
+    it('should validate errorMessage for failure/quota', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'failure', { errorMessage: '' });
+      }).toThrow(ValidationError);
+
+      expect(() => {
+        recorder.recordInteraction('cursor', 'quota', { errorMessage: null });
+      }).toThrow(ValidationError);
+    });
+
+    it('should not require errorMessage for success', () => {
+      expect(() => {
+        recorder.recordInteraction('cursor', 'success');
+      }).not.toThrow();
+    });
+
+    it('should set default values', () => {
+      const interaction = recorder.recordInteraction('cursor', 'success');
+
+      expect(interaction.responseTime).toBe(0); // Default
+      expect(interaction.timeoutUsed).toBe(0); // Default
+      expect(interaction.continuationPromptsDetected).toBe(0); // Default
+      expect(interaction.requirementId).toBeNull(); // Default
+      expect(interaction.errorMessage).toBeNull(); // Default
+    });
+  });
+
+  describe('getInteractions', () => {
+    it('should return empty array for new recorder', () => {
+      const interactions = recorder.getInteractions('cursor');
+      expect(interactions).toEqual([]);
+    });
+
+    it('should return interactions for specific IDE', () => {
+      recorder.recordInteraction('cursor', 'success');
+      recorder.recordInteraction('windsurf', 'failure');
+      recorder.recordInteraction('cursor', 'success');
+
+      const cursorInteractions = recorder.getInteractions('cursor');
+      const windsurfInteractions = recorder.getInteractions('windsurf');
+
+      expect(cursorInteractions).toHaveLength(2);
+      expect(windsurfInteractions).toHaveLength(1);
+    });
+
+    it('should return interactions in chronological order', () => {
+      const now = Date.now();
+      
+      const interaction1 = recorder.recordInteraction('cursor', 'success');
+      // Small delay to ensure different timestamps
+      const interaction2 = recorder.recordInteraction('cursor', 'failure');
+      const interaction3 = recorder.recordInteraction('cursor', 'success');
+
+      const interactions = recorder.getInteractions('cursor');
+      
+      expect(interactions[0]).toEqual(interaction1);
+      expect(interactions[1]).toEqual(interaction2);
+      expect(interactions[2]).toEqual(interaction3);
+    });
+  });
+
+  describe('getAllInteractions', () => {
+    it('should return all interactions grouped by IDE', () => {
+      recorder.recordInteraction('cursor', 'success');
+      recorder.recordInteraction('windsurf', 'failure');
+      recorder.recordInteraction('cursor', 'success');
+
+      const allInteractions = recorder.getAllInteractions();
+
+      expect(allInteractions).toHaveProperty('cursor');
+      expect(allInteractions).toHaveProperty('windsurf');
+      expect(allInteractions.cursor).toHaveLength(2);
+      expect(allInteractions.windsurf).toHaveLength(1);
+    });
+
+    it('should return empty object for no interactions', () => {
+      const allInteractions = recorder.getAllInteractions();
+      expect(allInteractions).toEqual({});
+    });
+  });
+
+  describe('clearInteractions', () => {
+    it('should clear interactions for specific IDE', () => {
+      recorder.recordInteraction('cursor', 'success');
+      recorder.recordInteraction('windsurf', 'failure');
+
+      recorder.clearInteractions('cursor');
+
+      expect(recorder.getInteractions('cursor')).toEqual([]);
+      expect(recorder.getInteractions('windsurf')).toHaveLength(1);
+    });
+
+    it('should clear all interactions when no IDE specified', () => {
+      recorder.recordInteraction('cursor', 'success');
+      recorder.recordInteraction('windsurf', 'failure');
+
+      recorder.clearInteractions();
+
+      expect(recorder.getAllInteractions()).toEqual({});
+    });
+  });
+
+  describe('interaction limit management', () => {
+    it('should maintain maximum interactions per IDE', () => {
+      // Add more interactions than max
+      for (let i = 0; i < MAX_INTERACTIONS + 10; i++) {
+        recorder.recordInteraction('cursor', 'success');
+      }
+
+      const interactions = recorder.getInteractions('cursor');
+      expect(interactions.length).toBe(MAX_INTERACTIONS);
+    });
+
+    it('should remove oldest interactions when limit exceeded', () => {
+      const firstInteraction = recorder.recordInteraction('cursor', 'success');
+      
+      // Add max interactions
+      for (let i = 0; i < MAX_INTERACTIONS; i++) {
+        recorder.recordInteraction('cursor', 'success');
+      }
+
+      const interactions = recorder.getInteractions('cursor');
+      expect(interactions).not.toContain(firstInteraction);
+      expect(interactions.length).toBe(MAX_INTERACTIONS);
+    });
+  });
+
+  describe('getInteractionStats', () => {
+    it('should return stats for IDE with interactions', () => {
+      recorder.recordInteraction('cursor', 'success', { responseTime: 120000 });
+      recorder.recordInteraction('cursor', 'failure');
+      recorder.recordInteraction('cursor', 'quota');
+
+      const stats = recorder.getInteractionStats('cursor');
+
+      expect(stats.total).toBe(3);
+      expect(stats.success).toBe(1);
+      expect(stats.failure).toBe(1);
+      expect(stats.quota).toBe(1);
+      expect(stats.successRate).toBeCloseTo(0.33, 2);
+    });
+
+    it('should return zero stats for IDE with no interactions', () => {
+      const stats = recorder.getInteractionStats('unknown-ide');
+
+      expect(stats.total).toBe(0);
+      expect(stats.success).toBe(0);
+      expect(stats.failure).toBe(0);
+      expect(stats.quota).toBe(0);
+      expect(stats.successRate).toBe(0);
+    });
+
+    it('should calculate average response time for successful interactions', () => {
+      recorder.recordInteraction('cursor', 'success', { responseTime: 120000 });
+      recorder.recordInteraction('cursor', 'success', { responseTime: 180000 });
+      recorder.recordInteraction('cursor', 'failure'); // No response time
+
+      const stats = recorder.getInteractionStats('cursor');
+
+      expect(stats.averageResponseTime).toBe(150000); // (120000 + 180000) / 2
+    });
+
+    it('should handle average response time with no successful interactions', () => {
+      recorder.recordInteraction('cursor', 'failure');
+      recorder.recordInteraction('cursor', 'quota');
+
+      const stats = recorder.getInteractionStats('cursor');
+
+      expect(stats.averageResponseTime).toBeNull();
+    });
+  });
+
+  describe('DEFAULT_IDE_RECORD', () => {
+    it('should provide default structure for new IDE records', () => {
+      const defaultRecord = DEFAULT_IDE_RECORD;
+
+      expect(defaultRecord.successCount).toBe(0);
+      expect(defaultRecord.failureCount).toBe(0);
+      expect(defaultRecord.responseTimes).toEqual([]);
+      expect(defaultRecord.ewma).toBe(0);
+      expect(defaultRecord.lastSuccess).toBeNull();
+      expect(defaultRecord.lastFailure).toBeNull();
+      expect(defaultRecord.consecutiveFailures).toBe(0);
+      expect(defaultRecord.currentTimeout).toBe(1800000); // 30 minutes
+      expect(defaultRecord.interactions).toEqual([]);
+    });
+  });
+
+  describe('MAX_INTERACTIONS constant', () => {
+    it('should define maximum interactions per IDE', () => {
+      expect(MAX_INTERACTIONS).toBe(100);
+    });
+  });
+});