claude-flow-novice 2.15.11 → 2.16.1

package/dist/cli/spawn-agent-cli.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Agent Spawning CLI Entry Point
+ *
+ * Provides command-line interface for spawning agents.
+ * Fully backward compatible with bash version.
+ *
+ * Usage:
+ *   spawn-agent-cli <agent-type> --task-id <id> [--iteration N] [--mode mode]
+ *   spawn-agent-cli --help
+ *   spawn-agent-cli --version
+ */ import { AgentSpawner } from './agent-spawner';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// ESM-compatible __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Parse command-line arguments
+ */ function parseArgs(args) {
+    const parsed = {
+        background: true
+    };
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arg === '--help') {
+            parsed.help = true;
+        } else if (arg === '--version') {
+            parsed.version = true;
+        } else if (arg === '--json') {
+            parsed.json = true;
+        } else if (arg === '--foreground') {
+            parsed.background = false;
+        } else if (arg === '--background') {
+            parsed.background = true;
+        } else if (arg === '--task-id' || arg === '-t') {
+            parsed.taskId = args[++i];
+        } else if (arg === '--iteration' || arg === '-i') {
+            parsed.iteration = parseInt(args[++i], 10);
+        } else if (arg === '--mode' || arg === '-m') {
+            parsed.mode = args[++i];
+        } else if (arg === '--provider' || arg === '-p') {
+            parsed.provider = args[++i];
+        } else if (arg === '--model') {
+            parsed.model = args[++i];
+        } else if (arg === '--prompt') {
+            parsed.prompt = args[++i];
+        } else if (!arg.startsWith('-')) {
+            if (!parsed.agentType) {
+                parsed.agentType = arg;
+            }
+        }
+    }
+    return parsed;
+}
+/**
+ * Print help message
+ */ function printHelp() {
+    console.log(`
+Agent Spawning CLI
+
+USAGE:
+  spawn-agent-cli <agent-type> [OPTIONS]
+
+ARGUMENTS:
+  <agent-type>          Type of agent to spawn (e.g., backend-dev, tester)
+
+OPTIONS:
+  -t, --task-id <id>   Task ID for coordination (required for CLI mode)
+  -i, --iteration <n>  Iteration number (default: 1)
+  -m, --mode <mode>    Mode: mvp, standard, enterprise (default: standard)
+  -p, --provider <p>   Provider: zai, anthropic, etc. (default: auto-detect)
+      --model <model>  Explicit model name (default: auto-detect)
+      --prompt <text>  Task prompt/description to pass to agent
+      --foreground     Run in foreground (default: background)
+      --background     Run in background (default)
+      --json           Output result as JSON
+  -h, --help           Show this help message
+  -v, --version        Show version information
+
+EXAMPLES:
+  # Basic agent spawn
+  spawn-agent-cli backend-dev --task-id task-123
+
+  # With explicit iteration
+  spawn-agent-cli tester --task-id task-123 --iteration 2
+
+  # With custom provider
+  spawn-agent-cli reviewer --task-id task-123 --provider anthropic
+
+  # JSON output for integration
+  spawn-agent-cli coder --task-id task-123 --json
+
+ENVIRONMENT VARIABLES:
+  TASK_ID               Task ID (can be set instead of --task-id)
+  PROJECT_ROOT          Project root directory (default: cwd)
+  AGENT_ID              Custom agent ID (default: generated)
+`);
+}
+/**
+ * Print version information
+ */ function printVersion() {
+    try {
+        const packageJson = JSON.parse(readFileSync(resolve(__dirname, '../../package.json'), 'utf-8'));
+        console.log(`spawn-agent-cli v${packageJson.version}`);
+    } catch  {
+        console.log('spawn-agent-cli v1.0.0');
+    }
+}
+/**
+ * Phase 1: Mode Prefix Function for CLI/Trigger.dev Collision Mitigation
+ *
+ * Generates task ID with mode prefix to prevent Redis key collisions between
+ * CLI mode and Trigger.dev Docker mode. Both modes share identical Redis coordination
+ * patterns and must use isolated namespaces.
+ *
+ * @param rawTaskId - Original task ID without prefix
+ * @param mode - Execution mode: 'cli' for CLI mode, 'trigger' for Trigger.dev
+ * @returns Prefixed task ID in format "MODE:rawTaskId"
+ *
+ * Example:
+ *   generateTaskId('task-123', 'cli')     => 'cli:task-123'
+ *   generateTaskId('task-123', 'trigger') => 'trigger:task-123'
+ *
+ * Redis Key Isolation (After):
+ *   CLI:     cfn:task:cli:task-123:status
+ *   Trigger: cfn:task:trigger:task-123:status
+ */ function generateTaskId(rawTaskId, mode) {
+    // Don't add prefix if task ID already has a namespace prefix
+    if (/^[a-z]+:/.test(rawTaskId)) {
+        return rawTaskId;
+    }
+    return `${mode}:${rawTaskId}`;
+}
+/**
+ * Validate CLI arguments
+ */ function validateArgs(args) {
+    const errors = [];
+    if (!args.agentType) {
+        errors.push('Agent type is required');
+    }
+    const taskId = args.taskId || process.env.TASK_ID;
+    if (!taskId) {
+        errors.push('Task ID is required (--task-id or TASK_ID env var)');
+    }
+    // Allow optional namespace prefix (e.g., "cli:", "task:") for coordination routing
+    if (taskId && !/^([a-z]+:)?[a-zA-Z0-9_.-]{1,64}$/.test(taskId)) {
+        errors.push('Invalid task ID format');
+    }
+    if (args.iteration && (args.iteration < 1 || !Number.isInteger(args.iteration))) {
+        errors.push('Iteration must be a positive integer');
+    }
+    if (args.mode && ![
+        'mvp',
+        'standard',
+        'enterprise'
+    ].includes(args.mode)) {
+        errors.push('Mode must be mvp, standard, or enterprise');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Format output based on options
+ */ function formatOutput(result, json = false) {
+    if (json) {
+        return JSON.stringify(result, null, 2);
+    }
+    if (typeof result === 'object' && result !== null) {
+        const obj = result;
+        if (obj.status === 'failed') {
+            return `ERROR: ${obj.error || 'Failed to spawn agent'}`;
+        }
+        return `Agent spawned: ${obj.agentId} (PID: ${obj.pid})`;
+    }
+    return String(result);
+}
+/**
+ * Main CLI function
+ */ async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    // Handle flags
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (args.version) {
+        printVersion();
+        process.exit(0);
+    }
+    // Validate arguments
+    const taskId = args.taskId || process.env.TASK_ID;
+    const validation = validateArgs({
+        ...args,
+        taskId
+    });
+    if (!validation.valid) {
+        console.error('Argument validation failed:');
+        validation.errors.forEach((err)=>console.error(`  - ${err}`));
+        console.error('Use --help for usage information');
+        process.exit(1);
+    }
+    // Create spawner
+    const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+    const spawner = new AgentSpawner(projectRoot);
+    // Build config with CLI mode prefix for Redis key isolation (Phase 1)
+    const prefixedTaskId = generateTaskId(taskId, 'cli');
+    const config = {
+        agentType: args.agentType,
+        taskId: prefixedTaskId,
+        iteration: args.iteration || 1,
+        mode: args.mode || 'standard',
+        provider: args.provider,
+        model: args.model,
+        prompt: args.prompt,
+        background: args.background !== false,
+        env: {
+            TASK_ID: prefixedTaskId
+        }
+    };
+    try {
+        // Spawn agent
+        const result = await spawner.spawnAgent(config);
+        // Output result
+        console.log(formatOutput(result, args.json));
+        // Exit with appropriate code
+        process.exit(result.status === 'spawned' ? 0 : 1);
+    } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`ERROR: ${errorMsg}`);
+        process.exit(2);
+    }
+}
+// Run main function
+main().catch((error)=>{
+    console.error('Unexpected error:', error);
+    process.exit(2);
+});
+export { parseArgs, validateArgs, formatOutput, generateTaskId };
+
+//# sourceMappingURL=spawn-agent-cli.js.map

package/dist/cli/spawn-agent-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/spawn-agent-cli.ts"],"sourcesContent":["#!/usr/bin/env node\r\n/**\r\n * Agent Spawning CLI Entry Point\r\n *\r\n * Provides command-line interface for spawning agents.\r\n * Fully backward compatible with bash version.\r\n *\r\n * Usage:\r\n *   spawn-agent-cli <agent-type> --task-id <id> [--iteration N] [--mode mode]\r\n *   spawn-agent-cli --help\r\n *   spawn-agent-cli --version\r\n */\r\n\r\nimport { AgentSpawner } from './agent-spawner';\r\nimport { writeFileSync, readFileSync } from 'fs';\r\nimport { resolve, dirname } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\n// ESM-compatible __dirname\r\nconst __filename = fileURLToPath(import.meta.url);\r\nconst __dirname = dirname(__filename);\r\n\r\ninterface CLIArgs {\r\n  agentType?: string;\r\n  taskId?: string;\r\n  iteration?: number;\r\n  mode?: 'mvp' | 'standard' | 'enterprise';\r\n  provider?: string;\r\n  model?: string;\r\n  prompt?: string;\r\n  background?: boolean;\r\n  help?: boolean;\r\n  version?: boolean;\r\n  json?: boolean;\r\n  [key: string]: unknown;\r\n}\r\n\r\n/**\r\n * Parse command-line arguments\r\n */\r\nfunction parseArgs(args: string[]): CLIArgs {\r\n  const parsed: CLIArgs = {\r\n    background: true\r\n  };\r\n\r\n  for (let i = 0; i < args.length; i++) {\r\n    const arg = args[i];\r\n\r\n    if (arg === '--help') {\r\n      parsed.help = true;\r\n    } else if (arg === '--version') {\r\n      parsed.version = true;\r\n    } else if (arg === '--json') {\r\n      parsed.json = true;\r\n    } else if (arg === '--foreground') {\r\n      parsed.background = false;\r\n    } else if (arg === '--background') {\r\n      parsed.background = true;\r\n    } else if (arg === '--task-id' || arg === '-t') {\r\n      parsed.taskId = args[++i];\r\n    } else if (arg === '--iteration' || arg === '-i') {\r\n      parsed.iteration = parseInt(args[++i], 10);\r\n    } else if (arg === '--mode' || arg === '-m') {\r\n      parsed.mode = args[++i] as 'mvp' | 'standard' | 'enterprise';\r\n    } else if (arg === '--provider' || arg === '-p') {\r\n      parsed.provider = args[++i];\r\n    } else if (arg === '--model') {\r\n      parsed.model = args[++i];\r\n    } else if (arg === '--prompt') {\r\n      parsed.prompt = args[++i];\r\n    } else if (!arg.startsWith('-')) {\r\n      if (!parsed.agentType) {\r\n        parsed.agentType = arg;\r\n      }\r\n    }\r\n  }\r\n\r\n  return parsed;\r\n}\r\n\r\n/**\r\n * Print help message\r\n */\r\nfunction printHelp(): void {\r\n  console.log(`\r\nAgent Spawning CLI\r\n\r\nUSAGE:\r\n  spawn-agent-cli <agent-type> [OPTIONS]\r\n\r\nARGUMENTS:\r\n  <agent-type>          Type of agent to spawn (e.g., backend-dev, tester)\r\n\r\nOPTIONS:\r\n  -t, --task-id <id>   Task ID for coordination (required for CLI mode)\r\n  -i, --iteration <n>  Iteration number (default: 1)\r\n  -m, --mode <mode>    Mode: mvp, standard, enterprise (default: standard)\r\n  -p, --provider <p>   Provider: zai, anthropic, etc. (default: auto-detect)\r\n      --model <model>  Explicit model name (default: auto-detect)\r\n      --prompt <text>  Task prompt/description to pass to agent\r\n      --foreground     Run in foreground (default: background)\r\n      --background     Run in background (default)\r\n      --json           Output result as JSON\r\n  -h, --help           Show this help message\r\n  -v, --version        Show version information\r\n\r\nEXAMPLES:\r\n  # Basic agent spawn\r\n  spawn-agent-cli backend-dev --task-id task-123\r\n\r\n  # With explicit iteration\r\n  spawn-agent-cli tester --task-id task-123 --iteration 2\r\n\r\n  # With custom provider\r\n  spawn-agent-cli reviewer --task-id task-123 --provider anthropic\r\n\r\n  # JSON output for integration\r\n  spawn-agent-cli coder --task-id task-123 --json\r\n\r\nENVIRONMENT VARIABLES:\r\n  TASK_ID               Task ID (can be set instead of --task-id)\r\n  PROJECT_ROOT          Project root directory (default: cwd)\r\n  AGENT_ID              Custom agent ID (default: generated)\r\n`);\r\n}\r\n\r\n/**\r\n * Print version information\r\n */\r\nfunction printVersion(): void {\r\n  try {\r\n    const packageJson = JSON.parse(\r\n      readFileSync(resolve(__dirname, '../../package.json'), 'utf-8')\r\n    );\r\n    console.log(`spawn-agent-cli v${packageJson.version}`);\r\n  } catch {\r\n    console.log('spawn-agent-cli v1.0.0');\r\n  }\r\n}\r\n\r\n/**\r\n * Phase 1: Mode Prefix Function for CLI/Trigger.dev Collision Mitigation\r\n *\r\n * Generates task ID with mode prefix to prevent Redis key collisions between\r\n * CLI mode and Trigger.dev Docker mode. Both modes share identical Redis coordination\r\n * patterns and must use isolated namespaces.\r\n *\r\n * @param rawTaskId - Original task ID without prefix\r\n * @param mode - Execution mode: 'cli' for CLI mode, 'trigger' for Trigger.dev\r\n * @returns Prefixed task ID in format \"MODE:rawTaskId\"\r\n *\r\n * Example:\r\n *   generateTaskId('task-123', 'cli')     => 'cli:task-123'\r\n *   generateTaskId('task-123', 'trigger') => 'trigger:task-123'\r\n *\r\n * Redis Key Isolation (After):\r\n *   CLI:     cfn:task:cli:task-123:status\r\n *   Trigger: cfn:task:trigger:task-123:status\r\n */\r\nfunction generateTaskId(rawTaskId: string, mode: 'cli' | 'trigger'): string {\r\n  // Don't add prefix if task ID already has a namespace prefix\r\n  if (/^[a-z]+:/.test(rawTaskId)) {\r\n    return rawTaskId;\r\n  }\r\n  return `${mode}:${rawTaskId}`;\r\n}\r\n\r\n/**\r\n * Validate CLI arguments\r\n */\r\nfunction validateArgs(args: CLIArgs): { valid: boolean; errors: string[] } {\r\n  const errors: string[] = [];\r\n\r\n  if (!args.agentType) {\r\n    errors.push('Agent type is required');\r\n  }\r\n\r\n  const taskId = args.taskId || process.env.TASK_ID;\r\n  if (!taskId) {\r\n    errors.push('Task ID is required (--task-id or TASK_ID env var)');\r\n  }\r\n\r\n  // Allow optional namespace prefix (e.g., \"cli:\", \"task:\") for coordination routing\r\n  if (taskId && !/^([a-z]+:)?[a-zA-Z0-9_.-]{1,64}$/.test(taskId)) {\r\n    errors.push('Invalid task ID format');\r\n  }\r\n\r\n  if (args.iteration && (args.iteration < 1 || !Number.isInteger(args.iteration))) {\r\n    errors.push('Iteration must be a positive integer');\r\n  }\r\n\r\n  if (args.mode && !['mvp', 'standard', 'enterprise'].includes(args.mode)) {\r\n    errors.push('Mode must be mvp, standard, or enterprise');\r\n  }\r\n\r\n  return {\r\n    valid: errors.length === 0,\r\n    errors\r\n  };\r\n}\r\n\r\n/**\r\n * Format output based on options\r\n */\r\nfunction formatOutput(result: unknown, json: boolean = false): string {\r\n  if (json) {\r\n    return JSON.stringify(result, null, 2);\r\n  }\r\n\r\n  if (typeof result === 'object' && result !== null) {\r\n    const obj = result as Record<string, unknown>;\r\n    if (obj.status === 'failed') {\r\n      return `ERROR: ${obj.error || 'Failed to spawn agent'}`;\r\n    }\r\n    return `Agent spawned: ${obj.agentId} (PID: ${obj.pid})`;\r\n  }\r\n\r\n  return String(result);\r\n}\r\n\r\n/**\r\n * Main CLI function\r\n */\r\nasync function main(): Promise<void> {\r\n  const args = parseArgs(process.argv.slice(2));\r\n\r\n  // Handle flags\r\n  if (args.help) {\r\n    printHelp();\r\n    process.exit(0);\r\n  }\r\n\r\n  if (args.version) {\r\n    printVersion();\r\n    process.exit(0);\r\n  }\r\n\r\n  // Validate arguments\r\n  const taskId = args.taskId || process.env.TASK_ID;\r\n  const validation = validateArgs({ ...args, taskId });\r\n\r\n  if (!validation.valid) {\r\n    console.error('Argument validation failed:');\r\n    validation.errors.forEach(err => console.error(`  - ${err}`));\r\n    console.error('Use --help for usage information');\r\n    process.exit(1);\r\n  }\r\n\r\n  // Create spawner\r\n  const projectRoot = process.env.PROJECT_ROOT || process.cwd();\r\n  const spawner = new AgentSpawner(projectRoot);\r\n\r\n  // Build config with CLI mode prefix for Redis key isolation (Phase 1)\r\n  const prefixedTaskId = generateTaskId(taskId!, 'cli');\r\n  const config = {\r\n    agentType: args.agentType!,\r\n    taskId: prefixedTaskId,\r\n    iteration: args.iteration || 1,\r\n    mode: args.mode || 'standard' as const,\r\n    provider: args.provider,\r\n    model: args.model,\r\n    prompt: args.prompt,\r\n    background: args.background !== false,\r\n    env: {\r\n      TASK_ID: prefixedTaskId\r\n    }\r\n  };\r\n\r\n  try {\r\n    // Spawn agent\r\n    const result = await spawner.spawnAgent(config);\r\n\r\n    // Output result\r\n    console.log(formatOutput(result, args.json));\r\n\r\n    // Exit with appropriate code\r\n    process.exit(result.status === 'spawned' ? 0 : 1);\r\n  } catch (error) {\r\n    const errorMsg = error instanceof Error ? error.message : String(error);\r\n    console.error(`ERROR: ${errorMsg}`);\r\n    process.exit(2);\r\n  }\r\n}\r\n\r\n// Run main function\r\nmain().catch((error) => {\r\n  console.error('Unexpected error:', error);\r\n  process.exit(2);\r\n});\r\n\r\nexport { parseArgs, validateArgs, formatOutput, generateTaskId };\r\n"],"names":["AgentSpawner","readFileSync","resolve","dirname","fileURLToPath","__filename","url","__dirname","parseArgs","args","parsed","background","i","length","arg","help","version","json","taskId","iteration","parseInt","mode","provider","model","prompt","startsWith","agentType","printHelp","console","log","printVersion","packageJson","JSON","parse","generateTaskId","rawTaskId","test","validateArgs","errors","push","process","env","TASK_ID","Number","isInteger","includes","valid","formatOutput","result","stringify","obj","status","error","agentId","pid","String","main","argv","slice","exit","validation","forEach","err","projectRoot","PROJECT_ROOT","cwd","spawner","prefixedTaskId","config","spawnAgent","errorMsg","Error","message","catch"],"mappings":"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"}

package/dist/coordination/coordination-wrapper.js

@@ -0,0 +1,383 @@
+/**
+ * Unified TypeScript Coordination Wrapper
+ *
+ * Provides a type-safe interface for all Redis-based coordination operations
+ * in the CFN Loop critical path. Wraps the existing redis-coordinator with
+ * semantic coordination methods for:
+ * - Agent lifecycle management
+ * - Signal/wait primitives
+ * - Consensus collection
+ * - Task state management
+ *
+ * Key patterns:
+ * - swarm:* namespace for unified coordination
+ * - Backward compatible with cfn_loop:task:* legacy namespace
+ * - Type-safe agent state tracking
+ * - Automatic timeout handling
+ */ import Redis from 'ioredis';
+import { EventEmitter } from 'events';
+/**
+ * Unified Coordination Wrapper
+ *
+ * Provides semantic coordination methods that abstract away Redis key patterns
+ * and protocol details while maintaining type safety.
+ */ export class CoordinationWrapper extends EventEmitter {
+    redis;
+    taskId;
+    namespace;
+    defaultTimeout;
+    isConnected = false;
+    constructor(config){
+        super();
+        this.taskId = config.taskId;
+        this.namespace = config.namespace || 'swarm';
+        this.defaultTimeout = config.defaultTimeout || 120000; // 120 seconds
+        // Create Redis client with provided configuration
+        this.redis = new Redis({
+            host: config.redisHost,
+            port: config.redisPort,
+            db: config.redisDb || 0,
+            lazyConnect: true,
+            maxRetriesPerRequest: null,
+            enableReadyCheck: false
+        });
+        // Set up error handling
+        this.redis.on('error', (error)=>{
+            this.emit('redis-error', error);
+        });
+        this.redis.on('connect', ()=>{
+            this.isConnected = true;
+            this.emit('connected');
+        });
+        this.redis.on('disconnect', ()=>{
+            this.isConnected = false;
+            this.emit('disconnected');
+        });
+    }
+    /**
+   * Connect to Redis
+   */ async connect() {
+        if (!this.isConnected) {
+            await this.redis.connect();
+        }
+    }
+    /**
+   * Disconnect from Redis
+   */ async disconnect() {
+        if (this.isConnected) {
+            await this.redis.disconnect();
+        }
+    }
+    /**
+   * Check if connected to Redis
+   */ isReady() {
+        return this.isConnected;
+    }
+    /**
+   * AGENT LIFECYCLE MANAGEMENT
+   */ /**
+   * Register a spawned agent in the coordination system
+   */ async registerAgent(agentId, agentType) {
+        const state = {
+            agentId,
+            type: agentType,
+            status: 'spawned',
+            timestamp: new Date().toISOString()
+        };
+        const key = this.getAgentStateKey(agentId);
+        await this.redis.set(key, JSON.stringify(state), 'EX', 86400); // 24h expiry
+    }
+    /**
+   * Update agent status
+   */ async updateAgentStatus(agentId, status) {
+        const key = this.getAgentStateKey(agentId);
+        const state = await this.getAgentState(agentId);
+        if (!state) {
+            throw new Error(`Agent ${agentId} not registered`);
+        }
+        state.status = status;
+        state.timestamp = new Date().toISOString();
+        await this.redis.set(key, JSON.stringify(state), 'EX', 86400);
+    }
+    /**
+   * Signal agent completion with confidence score
+   */ async signalCompletion(agentId, confidence, options) {
+        const key = this.getAgentStateKey(agentId);
+        const state = await this.getAgentState(agentId);
+        if (!state) {
+            throw new Error(`Agent ${agentId} not registered`);
+        }
+        state.status = 'completed';
+        state.confidence = confidence;
+        state.testPassRate = options?.testPassRate;
+        state.testsRun = options?.testsRun;
+        state.testsPassed = options?.testsPassed;
+        state.result = options?.result;
+        state.iteration = options?.iteration;
+        state.timestamp = new Date().toISOString();
+        // Store in agent state with 24h expiry
+        await this.redis.set(key, JSON.stringify(state), 'EX', 86400);
+        // Also publish completion signal to waiting agents
+        const channel = this.getCompletionChannel(agentId);
+        await this.redis.publish(channel, JSON.stringify(state));
+        // Add to completion leaderboard for consensus collection
+        const leaderboardKey = this.getCompletionLeaderboardKey();
+        await this.redis.zadd(leaderboardKey, confidence * 100, JSON.stringify({
+            agentId,
+            confidence,
+            timestamp: state.timestamp
+        }));
+    }
+    /**
+   * Get agent state
+   */ async getAgentState(agentId) {
+        const key = this.getAgentStateKey(agentId);
+        const data = await this.redis.get(key);
+        if (!data) {
+            return null;
+        }
+        return JSON.parse(data);
+    }
+    /**
+   * Get all agents in current task
+   */ async getAllAgents() {
+        const pattern = this.getAgentStateKeyPattern();
+        const keys = await this.redis.keys(pattern);
+        const agents = [];
+        for (const key of keys){
+            const data = await this.redis.get(key);
+            if (data) {
+                agents.push(JSON.parse(data));
+            }
+        }
+        return agents;
+    }
+    /**
+   * COORDINATION PRIMITIVES
+   */ /**
+   * Wait for a coordination signal with timeout
+   */ async waitForSignal(channel, timeoutMs) {
+        const timeout = timeoutMs || this.defaultTimeout;
+        const timeoutSeconds = Math.ceil(timeout / 1000);
+        try {
+            // Use BLPOP to block-wait on a list
+            const listKey = this.getSignalKey(channel);
+            const result = await this.redis.blpop(listKey, timeoutSeconds);
+            if (result === null) {
+                return {
+                    received: false,
+                    timeout: true
+                };
+            }
+            return {
+                received: true,
+                message: result[1],
+                timestamp: new Date().toISOString(),
+                timeout: false
+            };
+        } catch (error) {
+            return {
+                received: false,
+                timeout: false
+            };
+        }
+    }
+    /**
+   * Broadcast a signal to all waiting agents
+   */ async broadcastSignal(channel, message) {
+        // Use pub/sub for broadcast (fire-and-forget to subscribers)
+        await this.redis.publish(channel, message);
+        // Also store in a list for new subscribers (via BLPOP pattern)
+        const listKey = this.getSignalKey(channel);
+        await this.redis.lpush(listKey, message);
+        // Keep only recent signals (last 100)
+        await this.redis.ltrim(listKey, 0, 99);
+        // Expire the list after 1 hour
+        await this.redis.expire(listKey, 3600);
+    }
+    /**
+   * Subscribe to signal channel (pub/sub pattern)
+   */ subscribeToSignal(channel, callback) {
+        // Create a separate subscriber for pub/sub
+        const subscriber = this.redis.duplicate();
+        subscriber.on('message', (chan, message)=>{
+            if (chan === channel) {
+                callback(message);
+            }
+        });
+        subscriber.subscribe(channel);
+        // Return unsubscribe function
+        return ()=>{
+            subscriber.unsubscribe(channel);
+            subscriber.disconnect();
+        };
+    }
+    /**
+   * CONSENSUS & VALIDATION
+   */ /**
+   * Collect consensus scores from multiple validators
+   */ async collectConsensus(agentIds, timeoutMs) {
+        const timeout = timeoutMs || this.defaultTimeout;
+        const startTime = Date.now();
+        const scores = [];
+        for (const agentId of agentIds){
+            const elapsed = Date.now() - startTime;
+            const remaining = Math.max(1, timeout - elapsed);
+            const remainingSeconds = Math.ceil(remaining / 1000);
+            // Wait for each validator to report consensus
+            const scoreKey = this.getConsensusKey(agentId);
+            const data = await this.redis.blpop(scoreKey, remainingSeconds);
+            if (data) {
+                const score = JSON.parse(data[1]);
+                scores.push(score);
+            }
+        }
+        return scores;
+    }
+    /**
+   * Report a consensus score
+   */ async reportConsensusScore(agentId, score, feedback) {
+        const consensusScore = {
+            agentId,
+            score,
+            feedback,
+            timestamp: new Date().toISOString()
+        };
+        const key = this.getConsensusKey(agentId);
+        await this.redis.lpush(key, JSON.stringify(consensusScore));
+        await this.redis.expire(key, 86400); // 24h expiry
+    }
+    /**
+   * Calculate average consensus from scores
+   */ calculateAverageConsensus(scores) {
+        if (scores.length === 0) {
+            return 0;
+        }
+        const sum = scores.reduce((acc, score)=>acc + score.score, 0);
+        return sum / scores.length;
+    }
+    /**
+   * TASK STATE MANAGEMENT
+   */ /**
+   * Store task context (usually CFN Loop parameters)
+   */ async storeTaskContext(context) {
+        const key = this.getTaskContextKey();
+        await this.redis.set(key, JSON.stringify(context), 'EX', 86400);
+    }
+    /**
+   * Load task context
+   */ async loadTaskContext() {
+        const key = this.getTaskContextKey();
+        const data = await this.redis.get(key);
+        if (!data) {
+            return null;
+        }
+        return JSON.parse(data);
+    }
+    /**
+   * Update task status
+   */ async updateTaskStatus(status, iteration) {
+        const key = this.getTaskStatusKey();
+        const state = {
+            taskId: this.taskId,
+            status,
+            updatedAt: new Date().toISOString()
+        };
+        if (iteration !== undefined) {
+            state.iteration = iteration;
+        }
+        // Get existing context if available
+        const contextData = await this.loadTaskContext();
+        if (contextData) {
+            state.context = contextData;
+        }
+        // Get all agents
+        state.agents = await this.getAllAgents();
+        await this.redis.set(key, JSON.stringify(state), 'EX', 86400);
+    }
+    /**
+   * Get full task state snapshot
+   */ async getTaskState() {
+        const key = this.getTaskStatusKey();
+        const data = await this.redis.get(key);
+        if (!data) {
+            return null;
+        }
+        return JSON.parse(data);
+    }
+    /**
+   * HELPER METHODS FOR KEY GENERATION
+   */ getAgentStateKey(agentId) {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:agent:${agentId}`;
+        }
+        return `${this.namespace}:${this.taskId}:agent:${agentId}`;
+    }
+    getAgentStateKeyPattern() {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:agent:*`;
+        }
+        return `${this.namespace}:${this.taskId}:agent:*`;
+    }
+    getCompletionChannel(agentId) {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:completion:${agentId}`;
+        }
+        return `${this.namespace}:${this.taskId}:completion`;
+    }
+    getCompletionLeaderboardKey() {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:completions`;
+        }
+        return `${this.namespace}:${this.taskId}:completions`;
+    }
+    getSignalKey(channel) {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:signal:${channel}`;
+        }
+        return `${this.namespace}:${this.taskId}:signal:${channel}`;
+    }
+    getConsensusKey(agentId) {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:consensus:${agentId}`;
+        }
+        return `${this.namespace}:${this.taskId}:consensus:${agentId}`;
+    }
+    getTaskContextKey() {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:context`;
+        }
+        return `${this.namespace}:${this.taskId}:context`;
+    }
+    getTaskStatusKey() {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:status`;
+        }
+        return `${this.namespace}:${this.taskId}:status`;
+    }
+    /**
+   * CLEANUP & UTILITIES
+   */ /**
+   * Clear all coordination state for this task
+   */ async clearTaskState() {
+        const pattern = this.getTaskKeysPattern();
+        const keys = await this.redis.keys(pattern);
+        if (keys.length > 0) {
+            await this.redis.del(...keys);
+        }
+    }
+    getTaskKeysPattern() {
+        if (this.namespace === 'cfn_loop') {
+            return `cfn_loop:task:${this.taskId}:*`;
+        }
+        return `${this.namespace}:${this.taskId}:*`;
+    }
+    /**
+   * Get Redis client for advanced operations
+   */ getRedisClient() {
+        return this.redis;
+    }
+}
+export default CoordinationWrapper;
+
+//# sourceMappingURL=coordination-wrapper.js.map