claude-flow 2.7.34 → 2.7.36

package/scripts/test-docker-wsl.sh

@@ -0,0 +1,198 @@
+#!/bin/bash
+# Test automatic error recovery in Docker (simulates WSL)
+# Run this before creating GitHub issue
+
+set -e
+
+echo "🐳 Testing Automatic Error Recovery in Docker"
+echo ""
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test configurations
+DISTROS=("ubuntu:22.04" "ubuntu:20.04" "debian:11" "debian:12")
+TEST_RESULTS=()
+
+# Function to test on a distro
+test_distro() {
+    local distro=$1
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing on: $distro"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Run test in Docker
+    docker run --rm -i $distro bash -c "
+        set -e
+
+        echo '📦 Installing dependencies...'
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+
+        echo '📥 Installing Node.js...'
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '🔍 Node version:'
+        node --version
+        npm --version
+
+        echo ''
+        echo '🚀 Running claude-flow init --force...'
+        echo ''
+
+        # Run the actual test
+        npx claude-flow@alpha init --force
+
+        echo ''
+        echo '✅ Test completed successfully on $distro'
+    " && {
+        echo -e "${GREEN}✅ PASS: $distro${NC}"
+        TEST_RESULTS+=("PASS: $distro")
+    } || {
+        echo -e "${RED}❌ FAIL: $distro${NC}"
+        TEST_RESULTS+=("FAIL: $distro")
+    }
+}
+
+# Function to test with corrupted cache simulation
+test_corrupted_cache() {
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing with corrupted npm cache simulation"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    docker run --rm -i ubuntu:22.04 bash -c "
+        set -e
+
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '💥 Simulating corrupted npm cache...'
+        mkdir -p ~/.npm/_npx/test-corrupt/node_modules/better-sqlite3
+        touch ~/.npm/_npx/test-corrupt/node_modules/better-sqlite3/.lock
+
+        echo ''
+        echo '🚀 Running claude-flow init --force with corrupted cache...'
+        echo ''
+
+        npx claude-flow@alpha init --force
+
+        echo ''
+        echo '✅ Recovery from corrupted cache successful'
+    " && {
+        echo -e "${GREEN}✅ PASS: Corrupted cache recovery${NC}"
+        TEST_RESULTS+=("PASS: Corrupted cache recovery")
+    } || {
+        echo -e "${RED}❌ FAIL: Corrupted cache recovery${NC}"
+        TEST_RESULTS+=("FAIL: Corrupted cache recovery")
+    }
+}
+
+# Function to test without --force flag
+test_without_force() {
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing without --force flag (3 retries max)"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    docker run --rm -i ubuntu:22.04 bash -c "
+        set -e
+
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '🚀 Running claude-flow init (no --force)...'
+        echo ''
+
+        npx claude-flow@alpha init
+
+        echo ''
+        echo '✅ Init without --force successful'
+    " && {
+        echo -e "${GREEN}✅ PASS: Init without --force${NC}"
+        TEST_RESULTS+=("PASS: Init without --force")
+    } || {
+        echo -e "${RED}❌ FAIL: Init without --force${NC}"
+        TEST_RESULTS+=("FAIL: Init without --force")
+    }
+}
+
+# Main test execution
+echo "Starting comprehensive Docker tests..."
+echo ""
+echo "This will test:"
+echo "  - Multiple Linux distributions"
+echo "  - Corrupted cache recovery"
+echo "  - With and without --force flag"
+echo ""
+
+read -p "Continue? (y/n) " -n 1 -r
+echo ""
+
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Aborted"
+    exit 1
+fi
+
+# Run tests
+for distro in "${DISTROS[@]}"; do
+    test_distro "$distro"
+done
+
+test_corrupted_cache
+test_without_force
+
+# Print summary
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "TEST SUMMARY"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+PASS_COUNT=0
+FAIL_COUNT=0
+
+for result in "${TEST_RESULTS[@]}"; do
+    if [[ $result == PASS* ]]; then
+        echo -e "${GREEN}✅ $result${NC}"
+        ((PASS_COUNT++))
+    else
+        echo -e "${RED}❌ $result${NC}"
+        ((FAIL_COUNT++))
+    fi
+done
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Total: $((PASS_COUNT + FAIL_COUNT)) tests"
+echo -e "${GREEN}Passed: $PASS_COUNT${NC}"
+echo -e "${RED}Failed: $FAIL_COUNT${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+if [ $FAIL_COUNT -eq 0 ]; then
+    echo -e "${GREEN}✅ All tests passed!${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "1. Review test results above"
+    echo "2. Run: bash scripts/create-github-issue.sh"
+    echo "3. Update issue with test results"
+    exit 0
+else
+    echo -e "${RED}❌ Some tests failed${NC}"
+    echo ""
+    echo "Please fix failing tests before creating GitHub issue"
+    exit 1
+fi

package/src/__tests__/benchmarks/performance.bench.ts

@@ -5,11 +5,10 @@
  * Benchmarks session forking, hook matchers, and in-process MCP
  */
 
+/* eslint-disable no-console */
+
 import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
 import { performance } from 'perf_hooks';
-import { ClaudeFlowSDKAdapter } from '../../sdk/sdk-config.js';
-import { TaskExecutorSDK } from '../../swarm/executor-sdk.js';
-import { ClaudeClientV25 } from '../../api/claude-client-v2.5.js';
 
 interface BenchmarkResult {
   name: string;
@@ -89,31 +88,9 @@ class PerformanceBenchmark {
 
 describe('Performance Benchmarks', () => {
   let benchmark: PerformanceBenchmark;
-  let adapter: ClaudeFlowSDKAdapter;
-  let executor: TaskExecutorSDK;
-  let client: ClaudeClientV25;
 
   beforeAll(() => {
     benchmark = new PerformanceBenchmark();
-
-    adapter = new ClaudeFlowSDKAdapter({
-      apiKey: 'test-api-key',
-      swarmMode: true,
-      persistenceEnabled: true,
-    });
-
-    executor = new TaskExecutorSDK({
-      apiKey: 'test-api-key',
-      swarmMode: true,
-    });
-
-    client = new ClaudeClientV25(
-      {
-        apiKey: 'test-api-key',
-        enableSwarmMode: true,
-      },
-      undefined
-    );
   });
 
   afterAll(() => {

package/src/__tests__/hook-matchers.test.ts

@@ -4,6 +4,8 @@
  * Comprehensive test suite for hook pattern matching system
  */
 
+/* eslint-disable */
+
 import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
 import {
   HookMatcher,

package/src/agents/agent-registry.ts

@@ -4,7 +4,7 @@
  */
 
 import type { DistributedMemorySystem } from '../memory/distributed-memory.js';
-import type { AgentState, AgentId, AgentType, AgentStatus } from '../swarm/types.js';
+import type { AgentState, AgentType, AgentStatus } from '../swarm/types.js';
 import { EventEmitter } from 'node:events';
 
 export interface AgentRegistryEntry {

package/src/api/auth-service.ts

@@ -4,7 +4,7 @@
  */
 
 import { ILogger } from '../core/logger.js';
-import { AuthenticationError, AuthorizationError } from '../utils/errors.js';
+import { AuthenticationError } from '../utils/errors.js';
 import { nanoid } from 'nanoid';
 import { createHash, createHmac, timingSafeEqual } from 'crypto';
 

package/src/api/claude-client-enhanced.ts

@@ -483,9 +483,10 @@ export class EnhancedClaudeAPIClient extends EventEmitter {
       case 401:
       case 403:
         return new ClaudeAuthenticationError(message, errorData);
-      case 429:
+      case 429: {
         const retryAfter = errorData.error?.retry_after;
         return new ClaudeRateLimitError(message, retryAfter, errorData);
+      }
       case 500:
         return new ClaudeInternalServerError(message, errorData);
       case 503:

package/src/api/claude-client.ts

@@ -6,7 +6,6 @@
 import { EventEmitter } from 'events';
 import { ILogger } from '../core/logger.js';
 import { ConfigManager } from '../config/config-manager.js';
-import { getErrorMessage } from '../utils/error-handler.js';
 import { 
   ClaudeAPIError,
   ClaudeInternalServerError,
@@ -655,9 +654,10 @@ export class ClaudeAPIClient extends EventEmitter {
       case 401:
       case 403:
         return new ClaudeAuthenticationError(message, errorData);
-      case 429:
+      case 429: {
         const retryAfter = errorData.error?.retry_after;
         return new ClaudeRateLimitError(message, retryAfter, errorData);
+      }
       case 500:
         return new ClaudeInternalServerError(message, errorData);
       case 503:

package/src/api/database-service.ts

@@ -4,8 +4,7 @@
  */
 
 import { ILogger } from '../core/logger.js';
-import { ConfigManager } from '../config/config-manager.js';
-import { SwarmError, DatabaseError } from '../utils/errors.js';
+import { DatabaseError } from '../utils/errors.js';
 import { nanoid } from 'nanoid';
 
 export interface DatabaseConfig {

package/src/api/swarm-api.ts

@@ -11,7 +11,7 @@ import { ICoordinationManager } from '../coordination/manager.js';
 import { SwarmCoordinator } from '../swarm/coordinator.js';
 import { AgentManager } from '../agents/agent-manager.js';
 import { ResourceManager } from '../resources/resource-manager.js';
-import { Task, Agent, SwarmConfig, SwarmStatus } from '../utils/types.js';
+import { SwarmConfig } from '../utils/types.js';
 import { ValidationError, SwarmError } from '../utils/errors.js';
 import { nanoid } from 'nanoid';
 
@@ -123,7 +123,7 @@ export class SwarmApi {
     });
 
     // Error handling
-    this.router.use((err: Error, req: any, res: any, next: any) => {
+    this.router.use((err: Error, req: any, res: any, _next: any) => {
       this.logger.error('Swarm API error', {
         error: err.message,
         stack: err.stack,

package/src/cli/commands/hive-mind/wizard.ts

@@ -383,7 +383,7 @@ async function submitTaskWizard() {
   ]);
 
   let taskDescription = '';
-  let taskConfig: any = {};
+  const taskConfig: any = {};
 
   if (template === 'custom') {
     const answers = await inquirer.prompt([

package/src/cli/init/index.ts

@@ -5,6 +5,7 @@ import { createSwarmCommands } from './swarm-commands.js';
 import { createSparcEnvironment } from './sparc-environment.js';
 import { createClaudeConfig } from './claude-config.js';
 import { createBatchToolsGuide } from './batch-tools.js';
+import { errorRecovery } from '../../utils/error-recovery.js';
 
 export interface InitOptions {
   sparc?: boolean;
@@ -12,56 +13,85 @@ export interface InitOptions {
 }
 
 export async function initCommand(options: InitOptions = {}) {
-  try {
-    const fs = await import('fs/promises');
-    const path = await import('path');
+  // Wrap entire initialization in retry logic with automatic recovery
+  return errorRecovery.retryWithRecovery(
+    async () => {
+      try {
+        const fs = await import('fs/promises');
+        const path = await import('path');
 
-    printSuccess('Initializing Claude-Flow project...');
+        printSuccess('Initializing Claude-Flow project...');
 
-    // Phase 1: Create directory structure
-    console.log('\n📁 Phase 1: Creating directory structure...');
-    await createDirectoryStructure();
+        // Check WSL environment and apply fixes proactively
+        if (errorRecovery.isWSL()) {
+          console.log('🔍 WSL environment detected');
+          const wslCheck = await errorRecovery.recoverWSLErrors();
+          if (wslCheck.recovered) {
+            console.log('✅ WSL environment optimized\n');
+          }
+        }
 
-    // Phase 2: Create base configuration
-    console.log('\n⚙️  Phase 2: Creating configuration...');
-    await createClaudeConfig(options);
+        // Phase 1: Create directory structure
+        console.log('\n📁 Phase 1: Creating directory structure...');
+        await createDirectoryStructure();
 
-    // Phase 3: Create swarm commands and documentation
-    console.log('\n🤖 Phase 3: Creating swarm commands...');
-    await createSwarmCommands();
+        // Phase 2: Create base configuration
+        console.log('\n⚙️  Phase 2: Creating configuration...');
+        await createClaudeConfig(options);
 
-    // Phase 4: Create batch tools guides
-    console.log('\n🔧 Phase 4: Creating batch tools guides...');
-    await createBatchToolsGuide();
+        // Phase 3: Create swarm commands and documentation
+        console.log('\n🤖 Phase 3: Creating swarm commands...');
+        await createSwarmCommands();
 
-    // Phase 5: SPARC environment (if requested)
-    if (options.sparc) {
-      console.log('\n🚀 Phase 5: Creating SPARC environment...');
-      await createSparcEnvironment();
-    }
+        // Phase 4: Create batch tools guides
+        console.log('\n🔧 Phase 4: Creating batch tools guides...');
+        await createBatchToolsGuide();
+
+        // Phase 5: SPARC environment (if requested)
+        if (options.sparc) {
+          console.log('\n🚀 Phase 5: Creating SPARC environment...');
+          await createSparcEnvironment();
+        }
+
+        // Success summary
+        console.log('\n🎉 Project initialized successfully!');
+        console.log('   📁 Created .claude/ directory structure');
+        console.log('   📋 Created comprehensive swarm command documentation');
+        console.log('   🔧 Created batch tools coordination guides');
+        console.log('   📖 Created detailed usage examples with orchestration');
 
-    // Success summary
-    console.log('\n🎉 Project initialized successfully!');
-    console.log('   📁 Created .claude/ directory structure');
-    console.log('   📋 Created comprehensive swarm command documentation');
-    console.log('   🔧 Created batch tools coordination guides');
-    console.log('   📖 Created detailed usage examples with orchestration');
+        console.log('\n   Next steps:');
+        console.log('   1. Run "claude-flow swarm --help" to see swarm options');
+        console.log('   2. Check .claude/commands/swarm/ for detailed documentation');
+        console.log('   3. Review batch tools guide for orchestration patterns');
+        console.log('   4. Run "claude-flow help" for all available commands');
 
-    console.log('\n   Next steps:');
-    console.log('   1. Run "claude-flow swarm --help" to see swarm options');
-    console.log('   2. Check .claude/commands/swarm/ for detailed documentation');
-    console.log('   3. Review batch tools guide for orchestration patterns');
-    console.log('   4. Run "claude-flow help" for all available commands');
+        if (options.sparc) {
+          console.log('   5. Run "claude-flow sparc modes" to see available SPARC modes');
+          console.log('   6. Use TodoWrite/TodoRead for task coordination');
+          console.log('   7. Use Task tool for parallel agent execution');
+        }
+      } catch (error) {
+        // Attempt automatic error recovery
+        const recovery = await errorRecovery.recoverInitErrors(error);
 
-    if (options.sparc) {
-      console.log('   5. Run "claude-flow sparc modes" to see available SPARC modes');
-      console.log('   6. Use TodoWrite/TodoRead for task coordination');
-      console.log('   7. Use Task tool for parallel agent execution');
+        if (recovery.recovered) {
+          console.log('✅ Recovered from error, retrying initialization...\n');
+          throw error; // Trigger retry
+        } else {
+          printError(
+            `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          throw error;
+        }
+      }
+    },
+    {
+      maxRetries: options.force ? 5 : 3,
+      delay: 1000,
+      onRetry: (attempt, error) => {
+        console.log(`\n🔄 Retry attempt ${attempt} after error recovery...`);
+      }
     }
-  } catch (error) {
-    printError(
-      `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
+  );
 }

package/src/cli/simple-commands/init/skills-copier.js

@@ -12,7 +12,7 @@ const __dirname = dirname(__filename);
 export async function copySkillFiles(targetDir, options = {}) {
   console.log('  🚀 copySkillFiles function called');
   console.log(`  📂 Target directory: ${targetDir}`);
-  console.log(`  ⚙️  Options:`, options);
+  console.log(`  ⚙️  Options: { force: ${options.force || 'false'}, dryRun: ${options.dryRun || 'false'} }`);
   console.log(`  📍 __dirname: ${__dirname}`);
 
   const { force = false, dryRun = false } = options;

package/src/cli/simple-orchestrator.ts

@@ -77,7 +77,7 @@ function startWebUI(host: string, port: number) {
   const activeConnections: Set<any> = new Set();
 
   // CLI output capture system
-  let cliProcess: any = null;
+  const cliProcess: any = null;
 
   const consoleHTML = `
     <!DOCTYPE html>

package/src/coordination/conflict-resolution.ts

@@ -277,7 +277,7 @@ export class ConflictResolver {
     }
 
     // Build context based on conflict type
-    let context: any = {};
+    const context: any = {};
 
     if (preferredStrategy === 'priority') {
       // In a real implementation, fetch agent priorities from configuration

package/src/coordination/load-balancer.ts

@@ -228,7 +228,7 @@ export class LoadBalancer extends EventEmitter {
 
     try {
       // Filter agents based on constraints
-      let candidates = this.filterAgentsByConstraints(availableAgents, task, constraints);
+      const candidates = this.filterAgentsByConstraints(availableAgents, task, constraints);
 
       if (candidates.length === 0) {
         throw new Error('No suitable agents available for task');

package/src/core/DatabaseManager.ts

@@ -12,6 +12,8 @@ export class DatabaseManager implements IDatabaseProvider {
   private dbType: 'sqlite' | 'json';
   private dbPath: string;
   private initialized: boolean = false;
+  private retryCount: number = 0;
+  private maxRetries: number = 3;
 
   constructor(dbType: 'sqlite' | 'json' = 'sqlite', dbPath?: string) {
     this.dbType = dbType;
@@ -19,18 +21,36 @@ export class DatabaseManager implements IDatabaseProvider {
 
     // Try SQLite first, fallback to JSON if needed
     if (this.dbType === 'sqlite') {
-      try {
-        this.provider = new SQLiteProvider(this.dbPath);
-      } catch (error) {
-        console.warn('SQLite not available, falling back to JSON storage:', error);
-        this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
-        this.dbType = 'json';
-      }
+      this.provider = this.initializeSQLiteWithRecovery();
     } else {
       this.provider = new JSONProvider(this.dbPath);
     }
   }
 
+  /**
+   * Initialize SQLite with automatic error recovery
+   */
+  private initializeSQLiteWithRecovery(): IDatabaseProvider {
+    try {
+      return new SQLiteProvider(this.dbPath);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+
+      // Check if it's an npm cache error
+      if (errorMsg.includes('ENOTEMPTY') || errorMsg.includes('better-sqlite3')) {
+        console.warn('⚠️  SQLite initialization failed due to npm cache error');
+        console.warn('   Will attempt automatic recovery during initialize()');
+      } else {
+        console.warn('SQLite not available, falling back to JSON storage:', error);
+      }
+
+      // Fallback to JSON for now
+      this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
+      this.dbType = 'json';
+      return this.provider;
+    }
+  }
+
   private getDefaultPath(): string {
     const baseDir = path.join(process.cwd(), '.claude-flow');
     return this.dbType === 'sqlite'
@@ -40,8 +60,34 @@ export class DatabaseManager implements IDatabaseProvider {
 
   async initialize(): Promise<void> {
     await fs.ensureDir(path.dirname(this.dbPath));
-    await this.provider.initialize();
-    this.initialized = true;
+
+    try {
+      await this.provider.initialize();
+      this.initialized = true;
+    } catch (error) {
+      // If JSON provider failed, just propagate the error
+      if (this.dbType === 'json') {
+        throw error;
+      }
+
+      // For SQLite errors, attempt recovery
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (this.retryCount < this.maxRetries) {
+        console.warn(`⚠️  Database initialization failed (attempt ${this.retryCount + 1}/${this.maxRetries})`);
+        console.warn(`   Error: ${errorMsg}`);
+
+        // Attempt to recover by switching to JSON
+        console.log('🔄 Switching to JSON storage as fallback...');
+        this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
+        this.dbType = 'json';
+        this.retryCount++;
+
+        // Retry initialization with JSON provider
+        await this.initialize();
+      } else {
+        throw error;
+      }
+    }
   }
 
   async store(key: string, value: any, namespace: string = 'default'): Promise<void> {

package/src/core/config.ts

@@ -81,7 +81,7 @@ const FORMAT_PARSERS: Record<string, FormatParser> = {
       // Simple YAML parser for basic key-value pairs
       const lines = content.split('\n');
       const result: any = {};
-      let current = result;
+      const current = result;
       const stack: any[] = [result];
 
       for (const line of lines) {

package/src/enterprise/audit-manager.ts

@@ -728,7 +728,7 @@ export class AuditManager extends EventEmitter {
     let totalEntries = 0;
     let verifiedEntries = 0;
     let corruptedEntries = 0;
-    let missingEntries = 0;
+    const missingEntries = 0;
 
     const trails = trailId
       ? ([this.auditTrails.get(trailId)].filter(Boolean) as AuditTrail[])

package/src/providers/openai-provider.ts

@@ -292,8 +292,8 @@ export class OpenAIProvider extends BaseProvider {
       const reader = response.body!.getReader();
       const decoder = new TextDecoder();
       let buffer = '';
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
+      const totalPromptTokens = 0;
+      const totalCompletionTokens = 0;
 
       while (true) {
         const { done, value } = await reader.read();

package/src/sdk/checkpoint-manager.ts

@@ -70,7 +70,7 @@ export class RealCheckpointManager extends EventEmitter {
     queryGenerator: Query,
     autoCheckpoint: boolean = false
   ): Promise<void> {
-    let messages = this.sessionMessages.get(sessionId) || [];
+    const messages = this.sessionMessages.get(sessionId) || [];
     this.sessionMessages.set(sessionId, messages);
 
     let messageCount = this.messageCounters.get(sessionId) || 0;