claude-flow-novice 2.15.5 → 2.15.6

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

@@ -0,0 +1,1464 @@
+/**
+ * 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();
+    });
+  });
+});