vibecodingmachine-core 2026.1.3-2209 → 2026.1.22-1441

package/src/index.cjs

@@ -24,8 +24,22 @@ const requirementNumbering = require('./requirement-numbering.js');
 const gitBranchManager = require('./utils/git-branch-manager.js');
 const updateChecker = require('./utils/update-checker.js');
 const electronUpdateChecker = require('./utils/electron-update-checker.js');
+const { errorReporter, ErrorReporter } = require('./utils/error-reporter.js');
 const localization = require('./localization/index.js');
 
+// Health Tracking (Foundational)
+const { ValidationError, FileSystemError } = require('./health-tracking/errors.js');
+const { JSONStorage, DEFAULT_STORAGE_FILE, DEFAULT_HEALTH_DATA } = require('./health-tracking/json-storage.js');
+const { StorageInterface } = require('./health-tracking/storage-interface.js');
+const validators = require('./health-tracking/validators.js');
+
+// Health Tracking (User Story 1)
+const { InteractionRecorder, MAX_INTERACTIONS, DEFAULT_IDE_RECORD } = require('./health-tracking/interaction-recorder.js');
+const { IDEHealthTracker, MAX_RESPONSE_TIMES, CONSECUTIVE_FAILURE_THRESHOLD } = require('./health-tracking/ide-health-tracker.js');
+
+// Health Tracking (User Story 2)
+const { HealthReporter } = require('./health-tracking/health-reporter.js');
+
 module.exports = {
   CDPManager,
   AppleScriptManager,
@@ -51,5 +65,22 @@ module.exports = {
   ...gitBranchManager,
   ...updateChecker,
   ...electronUpdateChecker,
-  ...localization
+  errorReporter,
+  ErrorReporter,
+  ...localization,
+  // Health Tracking
+  ValidationError,
+  FileSystemError,
+  JSONStorage,
+  DEFAULT_STORAGE_FILE,
+  DEFAULT_HEALTH_DATA,
+  StorageInterface,
+  ...validators,
+  InteractionRecorder,
+  MAX_INTERACTIONS,
+  DEFAULT_IDE_RECORD,
+  IDEHealthTracker,
+  MAX_RESPONSE_TIMES,
+  CONSECUTIVE_FAILURE_THRESHOLD,
+  HealthReporter
 };

package/src/index.js

@@ -28,3 +28,19 @@ export * from './localization/index.js';
 
 // Error Reporting
 export * from './utils/error-reporter.js';
+
+// Admin Utilities
+export * from './utils/admin-utils.js';
+
+// Health Tracking (Foundational)
+export { ValidationError, FileSystemError } from './health-tracking/errors.js';
+export { JSONStorage, DEFAULT_STORAGE_FILE, DEFAULT_HEALTH_DATA } from './health-tracking/json-storage.js';
+export { StorageInterface } from './health-tracking/storage-interface.js';
+export * from './health-tracking/validators.js';
+
+// Health Tracking (User Story 1)
+export { InteractionRecorder, MAX_INTERACTIONS, DEFAULT_IDE_RECORD } from './health-tracking/interaction-recorder.js';
+export { IDEHealthTracker, MAX_RESPONSE_TIMES, CONSECUTIVE_FAILURE_THRESHOLD } from './health-tracking/ide-health-tracker.js';
+
+// Health Tracking (User Story 2)
+export { HealthReporter } from './health-tracking/health-reporter.js';

package/src/localization/translations/en.js

@@ -303,6 +303,18 @@ module.exports = {
   'interactive.sync.now': 'Sync Now',
   'interactive.logout': 'Logout',
   'interactive.exit': 'Exit',
+  'interactive.feedback': 'Feedback',
+  'interactive.feedback.title': 'Vibe Coding Machine Feedback',
+  'interactive.feedback.instructions': 'Your feedback helps us make Vibe Coding Machine better! Please let us know what you think.',
+  'interactive.feedback.email': 'Email (optional):',
+  'interactive.feedback.comment': 'Comment:',
+  'interactive.feedback.comment.instructions': 'Enter your comments below (press Enter twice on an empty line to finish):',
+  'interactive.feedback.comment.required': 'Comment is required',
+  'interactive.feedback.submitting': 'Submitting feedback',
+  'interactive.feedback.success': 'Feedback submitted successfully!',
+  'interactive.feedback.error': 'Failed to submit feedback',
+  'interactive.feedback.error.network': 'Network error - please check your internet connection or try again later.',
+  'interactive.feedback.cancelled': 'Feedback cancelled',
   'interactive.initialize': 'Initialize repository (.vibecodingmachine)',
   'interactive.goodbye': 'Goodbye! Be dreaming about what requirements to add!',
   'interactive.confirm.exit': 'Are you sure you want to exit? (x/y/N)',
@@ -323,7 +335,7 @@ module.exports = {
   'provider.available': 'Available',
   'provider.resets.in': 'Resets in',
   'provider.rate.limit.resets': 'Rate limit resets in',
-  'provider.instructions': '↑/↓ move selection    j/k reorder    e enable    d disable    Space toggle    Enter save/select    Esc cancel',
+  'provider.instructions': '↑/↓ move selection    j/k reorder    e enable    d disable    i install    Space toggle    Enter save/select    Esc cancel',
   'provider.status.available': 'Available',
   'provider.status.quota.infinite': 'Quota: Infinite',
   'provider.status.available.resets': 'available • resets in',

package/src/localization/translations/es.js

@@ -303,6 +303,18 @@ module.exports = {
   'interactive.sync.now': 'Sincronizar Ahora',
   'interactive.logout': 'Cerrar Sesión',
   'interactive.exit': 'Salir',
+  'interactive.feedback': 'Comentarios',
+  'interactive.feedback.title': 'Comentarios de Vibe Coding Machine',
+  'interactive.feedback.instructions': '¡Tus comentarios nos ayudan a mejorar Vibe Coding Machine! Por favor, dinos qué piensas.',
+  'interactive.feedback.email': 'Correo electrónico (opcional):',
+  'interactive.feedback.comment': 'Comentario:',
+  'interactive.feedback.comment.instructions': 'Ingresa tus comentarios a continuación (presiona Enter dos veces en una línea vacía para terminar):',
+  'interactive.feedback.comment.required': 'El comentario es obligatorio',
+  'interactive.feedback.submitting': 'Enviando comentarios',
+  'interactive.feedback.success': '¡Comentarios enviados con éxito!',
+  'interactive.feedback.error': 'No se pudieron enviar los comentarios',
+  'interactive.feedback.error.network': 'Error de red: por favor, verifica tu conexión a internet o inténtalo de nuevo más tarde.',
+  'interactive.feedback.cancelled': 'Comentarios cancelados',
   'interactive.initialize': 'Inicializar repositorio (.vibecodingmachine)',
   'interactive.goodbye': '¡Adiós! ¡Sigue soñando sobre qué requisitos agregar!',
   'interactive.confirm.exit': '¿Estás seguro de que quieres salir? (x/y/N)',

package/src/utils/admin-utils.js

@@ -0,0 +1,33 @@
+/**
+ * Admin Utilities for VibeCodingMachine
+ */
+
+const ADMIN_EMAILS = [
+    'jesse.d.olsen@gmail.com'
+];
+
+/**
+ * Check if an email belongs to an administrator
+ * @param {string} email - The email to check
+ * @returns {boolean} True if the email is an admin email
+ */
+function isAdmin(email) {
+    if (!email) return false;
+    return ADMIN_EMAILS.includes(email.toLowerCase().trim());
+}
+
+/**
+ * Check if the application should automatically start implementation
+ * based on the user's email (admin feedback)
+ * @param {string} email - The email of the feedback sender
+ * @returns {boolean} True if auto-start should be triggered
+ */
+function shouldAutoStart(email) {
+    return isAdmin(email);
+}
+
+module.exports = {
+    isAdmin,
+    shouldAutoStart,
+    ADMIN_EMAILS
+};

package/src/utils/error-reporter.js

@@ -5,19 +5,27 @@
  * This helps the admin know about issues and use VibeCodingMachine to fix itself.
  */
 
-const UserDatabase = require('../database/user-schema');
-
 class ErrorReporter {
   constructor() {
-    this.db = new UserDatabase();
     this.enabled = true;
+    this.db = null;
+    
+    try {
+      const UserDatabase = require('../database/user-schema');
+      this.db = new UserDatabase();
+    } catch (error) {
+      console.warn('ErrorReporter: Failed to initialize UserDatabase:', error.message);
+      this.enabled = false;
+    }
   }
 
   /**
    * Set authentication token for error reporting
    */
   setAuthToken(token) {
-    this.db.setAuthToken(token);
+    if (this.db) {
+      this.db.setAuthToken(token);
+    }
   }
 
   /**

package/src/utils/requirement-helpers.js

@@ -556,6 +556,8 @@ async function getProjectRequirementStats(repoPath) {
     let todoCount = 0;
     let toVerifyCount = 0;
     let verifiedCount = 0;
+    let clarificationCount = 0;
+    let recycledCount = 0;
 
     if (reqPath && await fs.pathExists(reqPath)) {
       const content = await fs.readFile(reqPath, 'utf8');
@@ -571,15 +573,31 @@ async function getProjectRequirementStats(repoPath) {
         'Verified by AI screenshot'
       ];
 
+      const clarificationVariants = [
+        'NEEDING CLARIFICATION',
+        'Requirements that need information',
+        'need information'
+      ];
+
+      const recycledVariants = [
+        '♻️ Recycled',
+        'Recycled'
+      ];
+
       for (const line of lines) {
         const trimmed = line.trim();
 
         if (trimmed.startsWith('###')) {
           if (currentSection) {
-            const requirementText = trimmed.replace(/^###\s*/, '').trim();
-            if (requirementText) {
+            // Remove ALL leading ### markers including spaces between them (handles "###", "### ###", "#### ####", etc.)
+            const requirementText = trimmed.replace(/^(#{1,}\s*)+/, '').trim();
+            // Filter out empty titles and package names
+            const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+            if (requirementText && requirementText.length > 0 && !packageNames.includes(requirementText.toLowerCase())) {
               if (currentSection === 'todo') todoCount++;
               else if (currentSection === 'toverify') toVerifyCount++;
+              else if (currentSection === 'clarification') clarificationCount++;
+              else if (currentSection === 'recycled') recycledCount++;
             }
           }
         } else if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
@@ -588,6 +606,10 @@ async function getProjectRequirementStats(repoPath) {
             currentSection = 'todo';
           } else if (verifySectionVariants.some(v => trimmed.includes(v))) {
             currentSection = 'toverify';
+          } else if (clarificationVariants.some(v => trimmed.includes(v))) {
+            currentSection = 'clarification';
+          } else if (recycledVariants.some(v => trimmed.includes(v))) {
+            currentSection = 'recycled';
           } else {
             currentSection = '';
           }
@@ -599,22 +621,30 @@ async function getProjectRequirementStats(repoPath) {
     const verifiedReqs = await loadVerifiedFromChangelog(repoPath);
     verifiedCount = verifiedReqs.length;
 
-    const total = todoCount + toVerifyCount + verifiedCount;
+    const total = todoCount + toVerifyCount + verifiedCount + clarificationCount + recycledCount;
     const todoPercent = total > 0 ? Math.round((todoCount / total) * 100) : 0;
     const toVerifyPercent = total > 0 ? Math.round((toVerifyCount / total) * 100) : 0;
     const verifiedPercent = total > 0 ? Math.round((verifiedCount / total) * 100) : 0;
+    const clarificationPercent = total > 0 ? Math.round((clarificationCount / total) * 100) : 0;
+    const recycledPercent = total > 0 ? Math.round((recycledCount / total) * 100) : 0;
 
     return {
       todoCount,
       toVerifyCount,
       verifiedCount,
+      clarificationCount,
+      recycledCount,
       total,
       todoPercent,
       toVerifyPercent,
       verifiedPercent,
+      clarificationPercent,
+      recycledPercent,
       todoLabel: `TODO (${todoCount} - ${todoPercent}%)`,
       toVerifyLabel: `TO VERIFY (${toVerifyCount} - ${toVerifyPercent}%)`,
-      verifiedLabel: `VERIFIED (${verifiedCount} - ${verifiedPercent}%)`
+      verifiedLabel: `VERIFIED (${verifiedCount} - ${verifiedPercent}%)`,
+      clarificationLabel: `CLARIFICATION (${clarificationCount} - ${clarificationPercent}%)`,
+      recycledLabel: `RECYCLED (${recycledCount} - ${recycledPercent}%)`
     };
   } catch (error) {
     logger.error('❌ Error getting project requirement stats:', error);

package/src/utils/requirements-parser.js

@@ -113,7 +113,7 @@ function parseRequirementsFile(content) {
 
       const details = [];
       const questions = [];
-      let package = null;
+      let pkg = null;
       let options = null;
       let optionsType = null;
       let currentQuestion = null;
@@ -129,7 +129,7 @@ function parseRequirementsFile(content) {
 
         // Check for PACKAGE line
         if (nextLine.startsWith('PACKAGE:')) {
-          package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
         }
         // Check for OPTIONS line (for need information requirements)
         else if (nextLine.startsWith('OPTIONS:')) {
@@ -173,7 +173,7 @@ function parseRequirementsFile(content) {
       const requirement = {
         title,
         description: details.join('\n'),
-        package,
+        package: pkg,
         options,
         optionsType,
         questions: currentSection === 'needInformation' ? questions : undefined,

package/tests/health-tracking/health-reporter.test.js

@@ -0,0 +1,329 @@
+/**
+ * Unit Tests for HealthReporter
+ * 
+ * Tests for formatting health data for CLI and Electron UI display.
+ */
+
+const { HealthReporter } = require('../../../src/health-tracking/health-reporter');
+
+describe('HealthReporter', () => {
+  let reporter;
+  let mockMetrics;
+
+  beforeEach(() => {
+    reporter = new HealthReporter();
+    
+    mockMetrics = {
+      cursor: {
+        successCount: 42,
+        failureCount: 3,
+        successRate: 0.933,
+        averageResponseTime: 121500,
+        currentTimeout: 170100,
+        consecutiveFailures: 0,
+        lastSuccess: '2026-01-21T09:15:00.000Z',
+        lastFailure: '2026-01-20T23:45:00.000Z',
+        totalInteractions: 45,
+        recentInteractions: [
+          {
+            timestamp: '2026-01-21T09:15:00.000Z',
+            outcome: 'success',
+            responseTime: 120000,
+            timeoutUsed: 180000,
+            continuationPromptsDetected: 1,
+            requirementId: 'req-042',
+            errorMessage: null
+          }
+        ]
+      },
+      windsurf: {
+        successCount: 28,
+        failureCount: 15,
+        successRate: 0.651,
+        averageResponseTime: 1490000,
+        currentTimeout: 2086000,
+        consecutiveFailures: 2,
+        lastSuccess: '2026-01-21T08:30:00.000Z',
+        lastFailure: '2026-01-21T07:15:00.000Z',
+        totalInteractions: 43,
+        recentInteractions: [
+          {
+            timestamp: '2026-01-21T08:30:00.000Z',
+            outcome: 'failure',
+            responseTime: null,
+            timeoutUsed: 1800000,
+            continuationPromptsDetected: 0,
+            requirementId: 'req-041',
+            errorMessage: 'Timeout exceeded'
+          }
+        ]
+      }
+    };
+  });
+
+  describe('formatForCLI', () => {
+    it('should format health metrics for CLI display', () => {
+      const formatted = reporter.formatForCLI(mockMetrics);
+
+      expect(formatted).toContain('🖥️  Cursor');
+      expect(formatted).toContain('+42 -3');
+      expect(formatted).toContain('93.3%');
+      expect(formatted).toContain('2.0m');
+      expect(formatted).toContain('✅ Healthy');
+
+      expect(formatted).toContain('🌊  Windsurf');
+      expect(formatted).toContain('+28 -15');
+      expect(formatted).toContain('65.1%');
+      expect(formatted).toContain('24.9m');
+      expect(formatted).toContain('⚠️  2 consecutive failures');
+    });
+
+    it('should handle empty metrics', () => {
+      const formatted = reporter.formatForCLI({});
+
+      expect(formatted).toContain('No IDE health data available');
+    });
+
+    it('should show warning for IDEs with consecutive failures', () => {
+      const metricsWithFailures = {
+        cursor: {
+          ...mockMetrics.cursor,
+          consecutiveFailures: 3
+        }
+      };
+
+      const formatted = reporter.formatForCLI(metricsWithFailures);
+
+      expect(formatted).toContain('⚠️  3 consecutive failures');
+      expect(formatted).not.toContain('✅ Healthy');
+    });
+
+    it('should format timestamps relative to now', () => {
+      const now = new Date('2026-01-21T10:00:00.000Z');
+      const formatted = reporter.formatForCLI(mockMetrics, now);
+
+      expect(formatted).toContain('Last success: 45m ago');
+      expect(formatted).toContain('Last failure: 10h ago');
+    });
+
+    it('should show "Never" for null timestamps', () => {
+      const metricsWithNulls = {
+        cursor: {
+          ...mockMetrics.cursor,
+          lastSuccess: null,
+          lastFailure: null
+        }
+      };
+
+      const formatted = reporter.formatForCLI(metricsWithNulls);
+
+      expect(formatted).toContain('Last success: Never');
+      expect(formatted).toContain('Last failure: Never');
+    });
+  });
+
+  describe('formatForElectron', () => {
+    it('should format health metrics for Electron UI', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      expect(formatted).toHaveProperty('cursor');
+      expect(formatted).toHaveProperty('windsurf');
+
+      const cursorData = formatted.cursor;
+      expect(cursorData.ide).toBe('Cursor');
+      expect(cursorData.successCount).toBe(42);
+      expect(cursorData.failureCount).toBe(3);
+      expect(cursorData.successRate).toBe(93.3);
+      expect(cursorData.averageResponseTime).toBe('2.0m');
+      expect(cursorData.currentTimeout).toBe('2.8m');
+      expect(cursorData.status).toBe('healthy');
+      expect(cursorData.lastSuccess).toBe('45m ago');
+      expect(cursorData.lastFailure).toBe('10h ago');
+    });
+
+    it('should include recent interactions in Electron format', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      const cursorData = formatted.cursor;
+      expect(cursorData.recentInteractions).toHaveLength(1);
+      
+      const interaction = cursorData.recentInteractions[0];
+      expect(interaction.outcome).toBe('success');
+      expect(interaction.displayTime).toBe('2.0m');
+      expect(interaction.requirementId).toBe('req-042');
+    });
+
+    it('should handle IDEs with no interactions', () => {
+      const metricsWithNoInteractions = {
+        vscode: {
+          successCount: 0,
+          failureCount: 0,
+          successRate: 0,
+          averageResponseTime: 0,
+          currentTimeout: 1800000,
+          consecutiveFailures: 0,
+          lastSuccess: null,
+          lastFailure: null,
+          totalInteractions: 0,
+          recentInteractions: []
+        }
+      };
+
+      const formatted = reporter.formatForElectron(metricsWithNoInteractions);
+
+      const vscodeData = formatted.vscode;
+      expect(vscodeData.status).toBe('no-data');
+      expect(vscodeData.successRate).toBe(0);
+      expect(vscodeData.averageResponseTime).toBe('N/A');
+    });
+
+    it('should format response times in human-readable units', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      expect(formatted.cursor.averageResponseTime).toBe('2.0m'); // 121.5s
+      expect(formatted.windsurf.averageResponseTime).toBe('24.9m'); // 1490s
+      expect(formatted.cursor.currentTimeout).toBe('2.8m'); // 170.1s
+      expect(formatted.windsurf.currentTimeout).toBe('34.8m'); // 2086s
+    });
+  });
+
+  describe('generateSummary', () => {
+    it('should generate overall health summary', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      expect(summary.totalIDEs).toBe(2);
+      expect(summary.healthyIDEs).toBe(1);
+      expect(summary.problematicIDEs).toBe(1);
+      expect(summary.totalInteractions).toBe(88);
+      expect(summary.overallSuccessRate).toBe(79.5);
+      expect(summary.averageResponseTime).toBe(805750); // Weighted average
+      expect(summary.recommendedIDE).toBe('cursor');
+    });
+
+    it('should handle empty metrics in summary', () => {
+      const summary = reporter.generateSummary({});
+
+      expect(summary.totalIDEs).toBe(0);
+      expect(summary.healthyIDEs).toBe(0);
+      expect(summary.problematicIDEs).toBe(0);
+      expect(summary.totalInteractions).toBe(0);
+      expect(summary.overallSuccessRate).toBe(0);
+      expect(summary.averageResponseTime).toBe(0);
+      expect(summary.recommendedIDE).toBeNull();
+    });
+
+    it('should calculate weighted average response time', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      // Weighted average: (45 * 121500 + 43 * 1490000) / 88
+      const expected = (45 * 121500 + 43 * 1490000) / 88;
+      expect(summary.averageResponseTime).toBeCloseTo(expected, 0);
+    });
+
+    it('should identify recommended IDE based on success rate', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      expect(summary.recommendedIDE).toBe('cursor'); // 93.3% vs 65.1%
+    });
+
+    it('should return null for recommendation when no IDE has sufficient data', () => {
+      const metricsWithInsufficientData = {
+        cursor: {
+          successCount: 1,
+          failureCount: 0,
+          successRate: 1.0,
+          totalInteractions: 1
+        }
+      };
+
+      const summary = reporter.generateSummary(metricsWithInsufficientData);
+
+      expect(summary.recommendedIDE).toBeNull();
+    });
+  });
+
+  describe('formatResponseTime', () => {
+    it('should format milliseconds to human readable format', () => {
+      expect(reporter.formatResponseTime(500)).toBe('500ms');
+      expect(reporter.formatResponseTime(1500)).toBe('1.5s');
+      expect(reporter.formatResponseTime(60000)).toBe('1.0m');
+      expect(reporter.formatResponseTime(121500)).toBe('2.0m');
+      expect(reporter.formatResponseTime(3600000)).toBe('1.0h');
+      expect(reporter.formatResponseTime(7200000)).toBe('2.0h');
+    });
+
+    it('should handle zero and null values', () => {
+      expect(reporter.formatResponseTime(0)).toBe('0ms');
+      expect(reporter.formatResponseTime(null)).toBe('N/A');
+      expect(reporter.formatResponseTime(undefined)).toBe('N/A');
+    });
+  });
+
+  describe('formatTimestamp', () => {
+    it('should format timestamps relative to now', () => {
+      const now = new Date('2026-01-21T10:00:00.000Z');
+      
+      expect(reporter.formatTimestamp('2026-01-21T09:15:00.000Z', now))
+        .toBe('45m ago');
+      
+      expect(reporter.formatTimestamp('2026-01-21T08:00:00.000Z', now))
+        .toBe('2h ago');
+      
+      expect(reporter.formatTimestamp('2026-01-20T10:00:00.000Z', now))
+        .toBe('24h ago');
+      
+      expect(reporter.formatTimestamp('2026-01-19T10:00:00.000Z', now))
+        .toBe('2d ago');
+    });
+
+    it('should handle null timestamps', () => {
+      expect(reporter.formatTimestamp(null)).toBe('Never');
+      expect(reporter.formatTimestamp(undefined)).toBe('Never');
+    });
+
+    it('should use current time when no reference provided', () => {
+      const timestamp = new Date(Date.now() - 5 * 60 * 1000).toISOString(); // 5 minutes ago
+      const formatted = reporter.formatTimestamp(timestamp);
+      
+      expect(formatted).toBe('5m ago');
+    });
+  });
+
+  describe('getHealthStatus', () => {
+    it('should return healthy for IDEs with no consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 0,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('healthy');
+    });
+
+    it('should return warning for IDEs with consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 3,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('warning');
+    });
+
+    it('should return critical for IDEs with many consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 6,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('critical');
+    });
+
+    it('should return no-data for IDEs with no interactions', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 0,
+        totalInteractions: 0
+      });
+
+      expect(status).toBe('no-data');
+    });
+  });
+});