claude-flow-novice 2.15.11 → 2.16.1

package/claude-assets/skills/cfn-docker-redis-coordination/tests/coordinator.test.ts

@@ -1,1464 +0,0 @@
-/**
- * Redis Coordinator Test Suite
- *
- * Comprehensive tests for RedisCoordinator with 90%+ code coverage
- * Tests include:
- * - Initialization and configuration
- * - Agent registration and status management
- * - Confidence tracking and completion signaling
- * - Loop waiting and timeout handling
- * - Consensus collection
- * - Error handling and validation
- * - Redis connection failures
- * - Security validation
- *
- * @module cfn-docker-redis-coordination/tests/coordinator.test.ts
- */
-
-import { RedisCoordinator } from '../src/coordinator';
-import {
-  CoordinatorConfig,
-  IRedisClient,
-  ILogger,
-  ValidationError,
-  SecurityError,
-  TimeoutError,
-  RedisConnectionError,
-} from '../src/types';
-
-// Mock Redis Client
-class MockRedisClient implements IRedisClient {
-  private data: Record<string, Record<string, string>> = {};
-  private lists: Record<string, string[]> = {};
-  private sets: Record<string, Set<string>> = {};
-  private expirations: Map<string, number> = new Map();
-
-  async exists(key: string): Promise<boolean> {
-    return key in this.data || key in this.lists || key in this.sets;
-  }
-
-  async del(key: string): Promise<number> {
-    let deleted = 0;
-    if (key in this.data) {
-      delete this.data[key];
-      deleted++;
-    }
-    if (key in this.lists) {
-      delete this.lists[key];
-      deleted++;
-    }
-    if (key in this.sets) {
-      delete this.sets[key];
-      deleted++;
-    }
-    this.expirations.delete(key);
-    return deleted;
-  }
-
-  async keys(pattern: string): Promise<string[]> {
-    const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
-    const allKeys = [
-      ...Object.keys(this.data),
-      ...Object.keys(this.lists),
-      ...Object.keys(this.sets),
-    ];
-    return allKeys.filter((key) => regex.test(key));
-  }
-
-  async dbsize(): Promise<number> {
-    const allKeys = new Set([
-      ...Object.keys(this.data),
-      ...Object.keys(this.lists),
-      ...Object.keys(this.sets),
-    ]);
-    return allKeys.size;
-  }
-
-  async flushdb(): Promise<string> {
-    this.data = {};
-    this.lists = {};
-    this.sets = {};
-    this.expirations.clear();
-    return 'OK';
-  }
-
-  async get(key: string): Promise<string | null> {
-    // Get first value from hash (simplified)
-    const hash = this.data[key];
-    return hash ? Object.values(hash)[0] || null : null;
-  }
-
-  async set(key: string, value: string): Promise<string> {
-    if (!this.data[key]) {
-      this.data[key] = {};
-    }
-    this.data[key]['value'] = value;
-    return 'OK';
-  }
-
-  async setex(
-    key: string,
-    seconds: number,
-    value: string
-  ): Promise<string> {
-    await this.set(key, value);
-    await this.expire(key, seconds);
-    return 'OK';
-  }
-
-  async hget(key: string, field: string): Promise<string | null> {
-    const hash = this.data[key];
-    return hash ? (hash[field] || null) : null;
-  }
-
-  async hset(
-    key: string,
-    fields: Record<string, string | number | boolean>
-  ): Promise<number> {
-    if (!this.data[key]) {
-      this.data[key] = {};
-    }
-    const hash = this.data[key];
-    let count = 0;
-    for (const [field, value] of Object.entries(fields)) {
-      hash[field] = String(value);
-      count++;
-    }
-    return count;
-  }
-
-  async hmset(
-    key: string,
-    fields: Record<string, string | number | boolean>
-  ): Promise<string> {
-    await this.hset(key, fields);
-    return 'OK';
-  }
-
-  async hgetall(key: string): Promise<Record<string, string>> {
-    return this.data[key] || {};
-  }
-
-  async hkeys(key: string): Promise<string[]> {
-    const hash = this.data[key];
-    return hash ? Object.keys(hash) : [];
-  }
-
-  async hvals(key: string): Promise<string[]> {
-    const hash = this.data[key];
-    return hash ? Object.values(hash) : [];
-  }
-
-  async lpush(key: string, values: string[]): Promise<number> {
-    if (!this.lists[key]) {
-      this.lists[key] = [];
-    }
-    this.lists[key].unshift(...values);
-    return this.lists[key].length;
-  }
-
-  async rpush(key: string, values: string[]): Promise<number> {
-    if (!this.lists[key]) {
-      this.lists[key] = [];
-    }
-    this.lists[key].push(...values);
-    return this.lists[key].length;
-  }
-
-  async blpop(
-    keys: string[],
-    timeout: number
-  ): Promise<[string, string] | null> {
-    for (const key of keys) {
-      const list = this.lists[key];
-      if (list && list.length > 0) {
-        const value = list.pop();
-        if (value) {
-          return [key, value];
-        }
-      }
-    }
-    return null;
-  }
-
-  async lrange(key: string, start: number, stop: number): Promise<string[]> {
-    const list = this.lists[key];
-    if (!list) return [];
-    // Handle negative indices
-    const len = list.length;
-    let actualStart = start < 0 ? Math.max(0, len + start) : start;
-    let actualStop = stop < 0 ? Math.max(-1, len + stop) : stop;
-
-    actualStart = Math.max(0, Math.min(actualStart, len - 1));
-    actualStop = Math.max(-1, Math.min(actualStop, len - 1));
-
-    if (actualStart > actualStop) return [];
-    return list.slice(actualStart, actualStop + 1);
-  }
-
-  async sadd(key: string, members: string[]): Promise<number> {
-    if (!this.sets[key]) {
-      this.sets[key] = new Set();
-    }
-    let count = 0;
-    for (const member of members) {
-      if (!this.sets[key].has(member)) {
-        this.sets[key].add(member);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  async smembers(key: string): Promise<string[]> {
-    const set = this.sets[key];
-    return set ? Array.from(set) : [];
-  }
-
-  async scard(key: string): Promise<number> {
-    const set = this.sets[key];
-    return set ? set.size : 0;
-  }
-
-  async expire(key: string, seconds: number): Promise<number> {
-    if (await this.exists(key)) {
-      this.expirations.set(key, Date.now() + seconds * 1000);
-      return 1;
-    }
-    return 0;
-  }
-
-  async pexpire(key: string, milliseconds: number): Promise<number> {
-    if (await this.exists(key)) {
-      this.expirations.set(key, Date.now() + milliseconds);
-      return 1;
-    }
-    return 0;
-  }
-
-  async ttl(key: string): Promise<number> {
-    const expiration = this.expirations.get(key);
-    if (!expiration) return -1;
-    const remaining = Math.floor((expiration - Date.now()) / 1000);
-    return remaining > 0 ? remaining : -2;
-  }
-
-  async ping(): Promise<string> {
-    return 'PONG';
-  }
-
-  async info(section?: string): Promise<string> {
-    if (section === 'memory') {
-      return '# Memory\nused_memory_human:1M\n';
-    }
-    return '# Server\nredis_version:6.0.0\n';
-  }
-
-  async quit(): Promise<void> {
-    this.data = {};
-    this.lists = {};
-    this.sets = {};
-    this.expirations.clear();
-  }
-}
-
-// Mock Logger
-class MockLogger implements ILogger {
-  public logs: Array<{ level: string; message: string }> = [];
-
-  log(message: string): void {
-    this.logs.push({ level: 'log', message });
-  }
-
-  info(message: string): void {
-    this.logs.push({ level: 'info', message });
-  }
-
-  warn(message: string): void {
-    this.logs.push({ level: 'warn', message });
-  }
-
-  error(message: string): void {
-    this.logs.push({ level: 'error', message });
-  }
-
-  debug(message: string): void {
-    this.logs.push({ level: 'debug', message });
-  }
-
-  clear(): void {
-    this.logs = [];
-  }
-}
-
-describe('RedisCoordinator', () => {
-  let coordinator: RedisCoordinator;
-  let mockRedis: MockRedisClient;
-  let mockLogger: MockLogger;
-  let config: CoordinatorConfig;
-
-  beforeEach(async () => {
-    mockRedis = new MockRedisClient();
-    mockLogger = new MockLogger();
-    config = {
-      redis: {
-        host: 'localhost',
-        port: 6379,
-        db: 0,
-      },
-      taskId: 'test-task-001',
-      defaultTimeout: 30,
-      defaultTTL: 3600,
-      mode: 'standard',
-    };
-
-    coordinator = new RedisCoordinator(config, mockLogger, mockRedis);
-  });
-
-  afterEach(async () => {
-    await mockRedis.flushdb();
-  });
-
-  describe('Constructor', () => {
-    it('should create coordinator with valid config', () => {
-      expect(coordinator).toBeDefined();
-    });
-
-    it('should throw ValidationError for invalid task ID', () => {
-      const invalidConfig = {
-        ...config,
-        taskId: 'invalid-task-with-special-chars!@#',
-      };
-
-      expect(
-        () => new RedisCoordinator(invalidConfig, mockLogger, mockRedis)
-      ).toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for empty task ID', () => {
-      const invalidConfig = {
-        ...config,
-        taskId: '',
-      };
-
-      expect(
-        () => new RedisCoordinator(invalidConfig, mockLogger, mockRedis)
-      ).toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for task ID exceeding max length', () => {
-      const invalidConfig = {
-        ...config,
-        taskId: 'a'.repeat(257),
-      };
-
-      expect(
-        () => new RedisCoordinator(invalidConfig, mockLogger, mockRedis)
-      ).toThrow(ValidationError);
-    });
-  });
-
-  describe('initTask', () => {
-    it('should initialize task without context', async () => {
-      await coordinator.initTask();
-
-      const exists = await mockRedis.exists('cfn_docker:task:test-task-001:meta');
-      expect(exists).toBe(true);
-
-      const meta = await mockRedis.hgetall('cfn_docker:task:test-task-001:meta');
-      expect(meta.created_by).toBe('cfn-docker-redis-coordination');
-      expect(meta.mode).toBe('standard');
-    });
-
-    it('should initialize task with context', async () => {
-      const context = {
-        branch: 'main',
-        iteration: 1,
-      };
-
-      await coordinator.initTask(context);
-
-      const contextData = await mockRedis.hgetall('cfn_docker:task:test-task-001:context');
-      expect(contextData.branch).toBe('main');
-      expect(contextData.iteration).toBe('1');
-    });
-
-    it('should set TTL on task metadata', async () => {
-      await coordinator.initTask();
-
-      const ttl = await mockRedis.ttl('cfn_docker:task:test-task-001:meta');
-      expect(ttl).toBeGreaterThan(0);
-      expect(ttl).toBeLessThanOrEqual(3600);
-    });
-
-    it('should throw SecurityError for oversized context value', async () => {
-      const coordinator2 = new RedisCoordinator(config, mockLogger, mockRedis);
-
-      const largeContext = {
-        oversized: 'x'.repeat(1024 * 1024 + 1), // Exceeds 1MB limit
-      };
-
-      await expect(coordinator2.initTask(largeContext)).rejects.toThrow(
-        SecurityError
-      );
-    });
-  });
-
-  describe('storeContext', () => {
-    it('should store context successfully', async () => {
-      const context = { key1: 'value1', key2: 'value2' };
-
-      await coordinator.storeContext(context);
-
-      const stored = await mockRedis.hgetall('cfn_docker:task:test-task-001:context');
-      expect(stored.key1).toBe('value1');
-      expect(stored.key2).toBe('value2');
-    });
-
-    it('should set TTL on context', async () => {
-      await coordinator.storeContext({ test: 'value' });
-
-      const ttl = await mockRedis.ttl('cfn_docker:task:test-task-001:context');
-      expect(ttl).toBeGreaterThan(0);
-    });
-  });
-
-  describe('getContext', () => {
-    it('should retrieve stored context', async () => {
-      const context = { branch: 'develop', revision: '1a2b3c' };
-      await coordinator.storeContext(context);
-
-      const retrieved = await coordinator.getContext();
-
-      expect(retrieved.branch).toBe('develop');
-      expect(retrieved.revision).toBe('1a2b3c');
-    });
-
-    it('should throw ValidationError if context not found', async () => {
-      await expect(coordinator.getContext()).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('registerAgent', () => {
-    it('should register agent successfully', async () => {
-      await coordinator.registerAgent('agent-001', 'backend-developer', 'container-123');
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.agent_id).toBe('agent-001');
-      expect(agentData.agent_type).toBe('backend-developer');
-      expect(agentData.container_id).toBe('container-123');
-      expect(agentData.status).toBe('spawning');
-    });
-
-    it('should register agent without container ID', async () => {
-      await coordinator.registerAgent('agent-002', 'frontend-developer');
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-002');
-      expect(agentData.agent_id).toBe('agent-002');
-      expect(agentData.container_id).toBe('');
-    });
-
-    it('should add agent to status history', async () => {
-      await coordinator.registerAgent('agent-003', 'tester');
-
-      const history = await mockRedis.lrange(
-        'cfn_docker:agent:agent-003:status_history',
-        0,
-        -1
-      );
-      expect(history.length).toBeGreaterThan(0);
-
-      const entry = JSON.parse(history[0]);
-      expect(entry.status).toBe('spawning');
-      expect(entry.timestamp).toBeDefined();
-    });
-
-    it('should throw ValidationError for invalid agent ID', async () => {
-      await expect(
-        coordinator.registerAgent('invalid@agent!', 'developer')
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for empty agent ID', async () => {
-      await expect(coordinator.registerAgent('', 'developer')).rejects.toThrow(
-        ValidationError
-      );
-    });
-
-    it('should set TTL on agent data', async () => {
-      await coordinator.registerAgent('agent-004', 'developer');
-
-      const ttl = await mockRedis.ttl('cfn_docker:agent:agent-004');
-      expect(ttl).toBeGreaterThan(0);
-    });
-  });
-
-  describe('updateStatus', () => {
-    beforeEach(async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-    });
-
-    it('should update agent status to running', async () => {
-      await coordinator.updateStatus('agent-001', 'running', 1);
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.status).toBe('running');
-      expect(agentData.iteration).toBe('1');
-    });
-
-    it('should update agent status to completed', async () => {
-      await coordinator.updateStatus('agent-001', 'completed', 2);
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.status).toBe('completed');
-      expect(agentData.iteration).toBe('2');
-    });
-
-    it('should add status to history', async () => {
-      await coordinator.updateStatus('agent-001', 'running');
-
-      const history = await mockRedis.lrange(
-        'cfn_docker:agent:agent-001:status_history',
-        0,
-        -1
-      );
-      expect(history.length).toBeGreaterThanOrEqual(2); // Initial spawning + running
-    });
-
-    it('should throw ValidationError for invalid agent ID', async () => {
-      await expect(
-        coordinator.updateStatus('invalid@id', 'running')
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid status', async () => {
-      await expect(
-        coordinator.updateStatus('agent-001', 'invalid-status' as any)
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('signalComplete', () => {
-    beforeEach(async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-    });
-
-    it('should signal completion with confidence', async () => {
-      await coordinator.signalComplete('agent-001', 0.85, 1);
-
-      const statusKey = 'cfn_docker:task:test-task-001:agent:agent-001:done';
-      const exists = await mockRedis.exists(statusKey);
-      expect(exists).toBe(true);
-
-      const confidenceKey =
-        'cfn_docker:task:test-task-001:confidence:agent-001';
-      const confidenceData = await mockRedis.hgetall(confidenceKey);
-      expect(confidenceData.confidence).toBe('0.85');
-      expect(confidenceData.iteration).toBe('1');
-      expect(confidenceData.agent_type).toBe('developer');
-    });
-
-    it('should signal completion with confidence 1.0', async () => {
-      await coordinator.signalComplete('agent-001', 1.0, 1);
-
-      const confidenceKey =
-        'cfn_docker:task:test-task-001:confidence:agent-001';
-      const confidenceData = await mockRedis.hgetall(confidenceKey);
-      expect(confidenceData.confidence).toBe('1');
-    });
-
-    it('should signal completion with confidence 0.0', async () => {
-      await coordinator.signalComplete('agent-001', 0.0, 1);
-
-      const confidenceKey =
-        'cfn_docker:task:test-task-001:confidence:agent-001';
-      const confidenceData = await mockRedis.hgetall(confidenceKey);
-      expect(confidenceData.confidence).toBe('0');
-    });
-
-    it('should update agent status to completed', async () => {
-      await coordinator.signalComplete('agent-001', 0.85, 1);
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.status).toBe('completed');
-    });
-
-    it('should throw ValidationError for invalid confidence < 0', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', -0.1)
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid confidence > 1', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', 1.1)
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid agent ID', async () => {
-      await expect(
-        coordinator.signalComplete('invalid@id', 0.85)
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('waitLoop', () => {
-    beforeEach(async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-      await coordinator.registerAgent('agent-002', 'developer');
-    });
-
-    it('should wait for loop completion when agents complete', async () => {
-      // Simulate agent completion
-      await coordinator.signalComplete('agent-001', 0.85);
-      await coordinator.signalComplete('agent-002', 0.90);
-
-      const result = await coordinator.waitLoop({
-        taskId: 'test-task-001',
-        loopNumber: 3,
-        agentCount: 2,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.completedAgents).toBe(2);
-      expect(result.expectedAgents).toBe(2);
-    });
-
-    it('should timeout when not all agents complete', async () => {
-      await coordinator.signalComplete('agent-001', 0.85);
-
-      const result = await coordinator.waitLoop({
-        taskId: 'test-task-001',
-        loopNumber: 3,
-        agentCount: 2,
-        timeout: 1,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.completedAgents).toBeLessThan(2);
-      expect(result.message).toContain('timeout');
-    });
-
-    it('should throw ValidationError for invalid task ID', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'invalid@task',
-          loopNumber: 3,
-          agentCount: 2,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid loop number < 1', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'test-task-001',
-          loopNumber: 0,
-          agentCount: 2,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid loop number > 4', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'test-task-001',
-          loopNumber: 5,
-          agentCount: 2,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid agent count < 1', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'test-task-001',
-          loopNumber: 3,
-          agentCount: 0,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for timeout out of range', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'test-task-001',
-          loopNumber: 3,
-          agentCount: 2,
-          timeout: 0,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for timeout exceeding max', async () => {
-      await expect(
-        coordinator.waitLoop({
-          taskId: 'test-task-001',
-          loopNumber: 3,
-          agentCount: 2,
-          timeout: 4000,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('collectConsensus', () => {
-    beforeEach(async () => {
-      // Register validators and simulate completion
-      for (let i = 1; i <= 3; i++) {
-        await coordinator.registerAgent(`validator-${i}`, 'validator');
-      }
-    });
-
-    it('should collect consensus when threshold met', async () => {
-      await coordinator.signalComplete('validator-1', 0.95, 1);
-      await coordinator.signalComplete('validator-2', 0.90, 1);
-      await coordinator.signalComplete('validator-3', 0.92, 1);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.responsesReceived).toBe(3);
-      expect(result.averageConfidence).toBeGreaterThanOrEqual(0.90);
-      expect(result.consensusReached).toBe(true);
-    });
-
-    it('should return PROCEED decision for high confidence', async () => {
-      await coordinator.signalComplete('validator-1', 0.92, 1);
-      await coordinator.signalComplete('validator-2', 0.91, 1);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 5,
-      });
-
-      expect(result.decision).toBe('PROCEED');
-    });
-
-    it('should return COMPLETE decision for very high confidence', async () => {
-      await coordinator.signalComplete('validator-1', 0.98, 1);
-      await coordinator.signalComplete('validator-2', 0.96, 1);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 5,
-      });
-
-      expect(result.decision).toBe('COMPLETE');
-    });
-
-    it('should timeout when consensus not reached', async () => {
-      await coordinator.signalComplete('validator-1', 0.70, 1);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 1,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.consensusReached).toBe(false);
-      expect(result.decision).toBe('ABORT');
-    });
-
-    it('should throw ValidationError for invalid task ID', async () => {
-      await expect(
-        coordinator.collectConsensus({
-          taskId: 'invalid@task',
-          loopNumber: 2,
-          requiredConsensus: 0.90,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid loop number', async () => {
-      await expect(
-        coordinator.collectConsensus({
-          taskId: 'test-task-001',
-          loopNumber: 0,
-          requiredConsensus: 0.90,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid consensus < 0', async () => {
-      await expect(
-        coordinator.collectConsensus({
-          taskId: 'test-task-001',
-          loopNumber: 2,
-          requiredConsensus: -0.1,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for invalid consensus > 1', async () => {
-      await expect(
-        coordinator.collectConsensus({
-          taskId: 'test-task-001',
-          loopNumber: 2,
-          requiredConsensus: 1.1,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for timeout out of range', async () => {
-      await expect(
-        coordinator.collectConsensus({
-          taskId: 'test-task-001',
-          loopNumber: 2,
-          requiredConsensus: 0.90,
-          timeout: 0,
-        })
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('healthCheck', () => {
-    it('should pass health check', async () => {
-      await expect(coordinator.healthCheck()).resolves.not.toThrow();
-    });
-
-    it('should log health check information', async () => {
-      mockLogger.clear();
-      await coordinator.healthCheck();
-
-      const logMessages = mockLogger.logs.map((l) => l.message);
-      expect(logMessages.some((msg) => msg.includes('health check'))).toBe(true);
-    });
-  });
-
-  describe('cleanup', () => {
-    it('should clean up task data', async () => {
-      await coordinator.initTask({ test: 'value' });
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      await coordinator.cleanup();
-
-      const taskExists = await mockRedis.exists(
-        'cfn_docker:task:test-task-001:meta'
-      );
-      expect(taskExists).toBe(false);
-    });
-  });
-
-  describe('disconnect', () => {
-    it('should disconnect from Redis', async () => {
-      await expect(coordinator.disconnect()).resolves.not.toThrow();
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should handle Redis connection errors gracefully', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        exists: jest.fn().mockRejectedValue(new Error('Connection failed')),
-      };
-
-      const failingCoordinator = new RedisCoordinator(
-        config,
-        mockLogger,
-        failingRedis
-      );
-
-      await expect(failingCoordinator.getContext()).rejects.toThrow();
-    });
-
-    it('should catch and log errors in initTask', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        hset: jest.fn().mockRejectedValue(new Error('Storage failed')),
-      };
-
-      const failingCoordinator = new RedisCoordinator(
-        config,
-        mockLogger,
-        failingRedis
-      );
-
-      mockLogger.clear();
-      await expect(failingCoordinator.initTask()).rejects.toThrow();
-      expect(
-        mockLogger.logs.some((l) => l.level === 'error')
-      ).toBe(true);
-    });
-  });
-
-  describe('Confidence validation', () => {
-    beforeEach(async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-    });
-
-    it('should accept confidence of 0.0', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', 0.0)
-      ).resolves.not.toThrow();
-    });
-
-    it('should accept confidence of 1.0', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', 1.0)
-      ).resolves.not.toThrow();
-    });
-
-    it('should accept confidence of 0.5', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', 0.5)
-      ).resolves.not.toThrow();
-    });
-
-    it('should reject NaN confidence', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', NaN)
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should reject Infinity confidence', async () => {
-      await expect(
-        coordinator.signalComplete('agent-001', Infinity)
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('Agent ID validation', () => {
-    it('should accept alphanumeric agent IDs', async () => {
-      await expect(
-        coordinator.registerAgent('agent123', 'developer')
-      ).resolves.not.toThrow();
-    });
-
-    it('should accept agent IDs with hyphens', async () => {
-      await expect(
-        coordinator.registerAgent('agent-001-backend', 'developer')
-      ).resolves.not.toThrow();
-    });
-
-    it('should accept agent IDs with underscores', async () => {
-      await expect(
-        coordinator.registerAgent('agent_001_backend', 'developer')
-      ).resolves.not.toThrow();
-    });
-
-    it('should reject agent IDs with special characters', async () => {
-      await expect(
-        coordinator.registerAgent('agent@001!', 'developer')
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should reject agent IDs with spaces', async () => {
-      await expect(
-        coordinator.registerAgent('agent 001', 'developer')
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should reject overly long agent IDs', async () => {
-      const longId = 'a'.repeat(257);
-      await expect(
-        coordinator.registerAgent(longId, 'developer')
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe('Mode-specific behavior', () => {
-    it('should initialize with standard mode', () => {
-      const stdConfig = { ...config, mode: 'standard' as const };
-      const stdCoordinator = new RedisCoordinator(
-        stdConfig,
-        mockLogger,
-        mockRedis
-      );
-      expect(stdCoordinator).toBeDefined();
-    });
-
-    it('should initialize with MVP mode', () => {
-      const mvpConfig = { ...config, mode: 'mvp' as const };
-      const mvpCoordinator = new RedisCoordinator(
-        mvpConfig,
-        mockLogger,
-        mockRedis
-      );
-      expect(mvpCoordinator).toBeDefined();
-    });
-
-    it('should initialize with enterprise mode', () => {
-      const enterpriseConfig = { ...config, mode: 'enterprise' as const };
-      const enterpriseCoordinator = new RedisCoordinator(
-        enterpriseConfig,
-        mockLogger,
-        mockRedis
-      );
-      expect(enterpriseCoordinator).toBeDefined();
-    });
-  });
-
-  describe('State persistence', () => {
-    it('should persist agent registration across operations', async () => {
-      await coordinator.registerAgent('agent-001', 'developer', 'container-123');
-      await coordinator.updateStatus('agent-001', 'running');
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.agent_id).toBe('agent-001');
-      expect(agentData.status).toBe('running');
-    });
-
-    it('should maintain confidence history', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-      await coordinator.signalComplete('agent-001', 0.85);
-      await coordinator.updateStatus('agent-001', 'running');
-      await coordinator.signalComplete('agent-001', 0.90);
-
-      const history = await mockRedis.lrange(
-        'cfn_docker:agent:agent-001:status_history',
-        0,
-        -1
-      );
-      expect(history.length).toBeGreaterThanOrEqual(3);
-    });
-  });
-
-  describe('Additional coverage tests', () => {
-    it('should handle empty agent list in waitLoop', async () => {
-      const result = await coordinator.waitLoop({
-        taskId: 'test-task-001',
-        loopNumber: 3,
-        agentCount: 1,
-        timeout: 1,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.completedAgents).toBe(0);
-    });
-
-    it('should handle agents with special types', async () => {
-      await coordinator.registerAgent('agent-001', 'tester');
-      await coordinator.registerAgent('agent-002', 'validator');
-      await coordinator.registerAgent('agent-003', 'product-owner');
-
-      await coordinator.signalComplete('agent-001', 0.88);
-      await coordinator.signalComplete('agent-002', 0.91);
-      await coordinator.signalComplete('agent-003', 0.87);
-
-      const agent1 = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agent1.agent_type).toBe('tester');
-
-      const agent2 = await mockRedis.hgetall('cfn_docker:agent:agent-002');
-      expect(agent2.agent_type).toBe('validator');
-
-      const agent3 = await mockRedis.hgetall('cfn_docker:agent:agent-003');
-      expect(agent3.agent_type).toBe('product-owner');
-    });
-
-    it('should handle multiple status updates in sequence', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      const statuses: AgentStatus[] = ['running', 'working', 'completed'];
-      for (let i = 0; i < statuses.length; i++) {
-        await coordinator.updateStatus('agent-001', statuses[i], i + 1);
-      }
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.status).toBe('completed');
-      expect(agentData.iteration).toBe('3');
-    });
-
-    it('should correctly store and retrieve consensus with metadata', async () => {
-      for (let i = 1; i <= 5; i++) {
-        await coordinator.registerAgent(`validator-${i}`, 'validator');
-        const confidence = 0.85 + i * 0.02;
-        await coordinator.signalComplete(`validator-${i}`, confidence);
-      }
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.88,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.responsesReceived).toBeGreaterThan(0);
-      expect(result.averageConfidence).toBeGreaterThanOrEqual(0.88);
-    });
-
-    it('should handle zero iteration in updateStatus', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-      await coordinator.updateStatus('agent-001', 'running', 0);
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.iteration).toBe('0');
-    });
-
-    it('should handle large iteration numbers', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-      const largeIteration = 99;
-      await coordinator.updateStatus('agent-001', 'completed', largeIteration);
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.iteration).toBe('99');
-    });
-
-    it('should handle context with numeric and boolean values', async () => {
-      const context = {
-        branch: 'main',
-        iteration: 5,
-        success: true,
-        failed: false,
-      };
-
-      await coordinator.storeContext(context);
-      const retrieved = await coordinator.getContext();
-
-      expect(retrieved.branch).toBe('main');
-      expect(retrieved.iteration).toBe('5');
-      expect(retrieved.success).toBe('true');
-      expect(retrieved.failed).toBe('false');
-    });
-
-    it('should handle consensus with single validator', async () => {
-      await coordinator.registerAgent('validator-1', 'validator');
-      await coordinator.signalComplete('validator-1', 0.95);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.responsesReceived).toBe(1);
-      expect(result.averageConfidence).toBe(0.95);
-    });
-
-    it('should handle partial consensus collection', async () => {
-      await coordinator.registerAgent('validator-1', 'validator');
-      await coordinator.registerAgent('validator-2', 'validator');
-
-      await coordinator.signalComplete('validator-1', 0.92);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.85,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.responsesReceived).toBe(1);
-    });
-
-    it('should handle consensus below threshold', async () => {
-      await coordinator.registerAgent('validator-1', 'validator');
-      await coordinator.registerAgent('validator-2', 'validator');
-
-      await coordinator.signalComplete('validator-1', 0.70);
-      await coordinator.signalComplete('validator-2', 0.72);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 1,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.consensusReached).toBe(false);
-      expect(result.decision).toBe('ABORT');
-    });
-
-    it('should log operations in verbose mode', async () => {
-      const verboseConfig = { ...config, verbose: true };
-      const verboseCoordinator = new RedisCoordinator(
-        verboseConfig,
-        mockLogger,
-        mockRedis
-      );
-
-      mockLogger.clear();
-      await verboseCoordinator.registerAgent('agent-001', 'developer');
-      expect(
-        mockLogger.logs.some((l) => l.message.includes('Agent registered'))
-      ).toBe(true);
-    });
-
-    it('should handle agent registration without container ID', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      const agentData = await mockRedis.hgetall('cfn_docker:agent:agent-001');
-      expect(agentData.container_id).toBe('');
-    });
-
-    it('should handle default timeout values', async () => {
-      const defaultConfig: CoordinatorConfig = {
-        redis: {
-          host: 'localhost',
-          port: 6379,
-          db: 0,
-        },
-        taskId: 'test-task-default',
-      };
-
-      const defaultCoordinator = new RedisCoordinator(
-        defaultConfig,
-        mockLogger,
-        mockRedis
-      );
-
-      await defaultCoordinator.registerAgent('agent-001', 'developer');
-      expect(defaultCoordinator).toBeDefined();
-    });
-
-    it('should handle confidence edge cases', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-      await coordinator.registerAgent('agent-002', 'developer');
-      await coordinator.registerAgent('agent-003', 'developer');
-
-      // Test edge confidence values
-      await coordinator.signalComplete('agent-001', 0.0);
-      await coordinator.signalComplete('agent-002', 0.5);
-      await coordinator.signalComplete('agent-003', 1.0);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.5,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.averageConfidence).toBeCloseTo(0.5, 1);
-    });
-
-    it('should correctly use mode configuration', async () => {
-      const modes: ExecutionMode[] = ['mvp', 'standard', 'enterprise'];
-
-      for (const mode of modes) {
-        const modeConfig: CoordinatorConfig = {
-          redis: {
-            host: 'localhost',
-            port: 6379,
-            db: 0,
-          },
-          taskId: `test-task-${mode}`,
-          mode,
-        };
-
-        const modeCoordinator = new RedisCoordinator(
-          modeConfig,
-          mockLogger,
-          mockRedis
-        );
-
-        await modeCoordinator.initTask();
-        const meta = await mockRedis.hgetall(
-          `cfn_docker:task:test-task-${mode}:meta`
-        );
-        expect(meta.mode).toBe(mode);
-      }
-    });
-
-    it('should handle initTask errors gracefully', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        hset: jest.fn().mockRejectedValue(new Error('Storage error')),
-        expire: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(false),
-      };
-
-      const errorCoordinator = new RedisCoordinator(config, mockLogger, failingRedis);
-
-      await expect(errorCoordinator.initTask()).rejects.toThrow();
-      expect(
-        mockLogger.logs.some((l) => l.level === 'error')
-      ).toBe(true);
-    });
-
-    it('should handle storeContext errors gracefully', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        hset: jest.fn().mockRejectedValue(new Error('Storage error')),
-        expire: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(false),
-      };
-
-      const errorCoordinator = new RedisCoordinator(config, mockLogger, failingRedis);
-
-      await expect(
-        errorCoordinator.storeContext({ test: 'value' })
-      ).rejects.toThrow();
-    });
-
-    it('should handle registerAgent errors gracefully', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        hset: jest.fn().mockRejectedValue(new Error('Registration error')),
-        lpush: jest.fn().mockResolvedValue(1),
-        expire: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(false),
-      };
-
-      const errorCoordinator = new RedisCoordinator(config, mockLogger, failingRedis);
-
-      await expect(
-        errorCoordinator.registerAgent('agent-001', 'developer')
-      ).rejects.toThrow();
-    });
-
-    it('should handle updateStatus errors gracefully', async () => {
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        hset: jest.fn().mockRejectedValue(new Error('Status update error')),
-        lpush: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(false),
-      };
-
-      const errorCoordinator = new RedisCoordinator(config, mockLogger, failingRedis);
-
-      await coordinator.registerAgent('agent-001', 'developer');
-      await expect(
-        errorCoordinator.updateStatus('agent-001', 'running')
-      ).rejects.toThrow();
-    });
-
-    it('should handle signalComplete errors gracefully', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      const failingRedis: IRedisClient = {
-        ...mockRedis,
-        lpush: jest.fn().mockRejectedValue(new Error('Signal error')),
-        hget: jest.fn().mockResolvedValue('developer'),
-        hset: jest.fn().mockResolvedValue(1),
-        expire: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(true),
-      };
-
-      const errorCoordinator = new RedisCoordinator(config, mockLogger, failingRedis);
-
-      await expect(
-        errorCoordinator.signalComplete('agent-001', 0.85)
-      ).rejects.toThrow();
-    });
-
-    it('should handle storeContext with very large values', async () => {
-      const largeValue = 'x'.repeat(1024 * 1024 + 1); // 1MB + 1 byte
-      const context = { large: largeValue };
-
-      await expect(coordinator.storeContext(context)).rejects.toThrow(
-        SecurityError
-      );
-    });
-
-    it('should handle negative confidence values', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      await expect(
-        coordinator.signalComplete('agent-001', -0.001)
-      ).rejects.toThrow(ValidationError);
-    });
-
-    it('should handle consensus timeout with no responses', async () => {
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.90,
-        timeout: 1,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.responsesReceived).toBe(0);
-      expect(result.decision).toBe('ABORT');
-    });
-
-    it('should handle cleanup with non-existent task', async () => {
-      const nonExistentConfig: CoordinatorConfig = {
-        redis: {
-          host: 'localhost',
-          port: 6379,
-          db: 0,
-        },
-        taskId: 'non-existent-task',
-      };
-
-      const cleanupCoordinator = new RedisCoordinator(
-        nonExistentConfig,
-        mockLogger,
-        mockRedis
-      );
-
-      await cleanupCoordinator.cleanup();
-      expect(
-        mockLogger.logs.some((l) => l.message.includes('Cleanup completed'))
-      ).toBe(true);
-    });
-
-    it('should handle healthCheck with mocked Redis', async () => {
-      mockLogger.clear();
-      await coordinator.healthCheck();
-
-      const healthLogs = mockLogger.logs.filter((l) =>
-        l.message.includes('health')
-      );
-      expect(healthLogs.length).toBeGreaterThan(0);
-    });
-
-    it('should validate agent status types', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      const validStatuses: AgentStatus[] = [
-        'spawning',
-        'running',
-        'working',
-        'completed',
-        'failed',
-        'timeout',
-      ];
-
-      for (const status of validStatuses) {
-        await expect(
-          coordinator.updateStatus('agent-001', status)
-        ).resolves.not.toThrow();
-      }
-    });
-
-    it('should handle consensus with fractional values', async () => {
-      await coordinator.registerAgent('validator-1', 'validator');
-      await coordinator.registerAgent('validator-2', 'validator');
-
-      await coordinator.signalComplete('validator-1', 0.333);
-      await coordinator.signalComplete('validator-2', 0.667);
-
-      const result = await coordinator.collectConsensus({
-        taskId: 'test-task-001',
-        loopNumber: 2,
-        requiredConsensus: 0.5,
-        timeout: 5,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.averageConfidence).toBeCloseTo(0.5, 0);
-    });
-
-    it('should handle very small timeout values', async () => {
-      await coordinator.registerAgent('agent-001', 'developer');
-
-      const result = await coordinator.waitLoop({
-        taskId: 'test-task-001',
-        loopNumber: 3,
-        agentCount: 1,
-        timeout: 1,
-      });
-
-      expect(result).toBeDefined();
-    });
-  });
-});