siesa-agents 2.1.25 → 2.1.26-dev.0

package/README.md

@@ -1,4 +1,4 @@
-# SIESA Agents
+# SIESA BMAD Agents
 
 Paquete para instalar y configurar agentes SIESA en tu proyecto.
 
@@ -52,7 +52,6 @@ El paquete instala las siguientes carpetas en tu directorio actual:
 - **`.bmad-core/`** - Archivos principales del sistema BMAD
 - **`.vscode/`** - Configuración de Visual Studio Code
 - **`.github/`** - Configuración de GitHub Actions y workflows
-- **`.claude/`** - Configuración de Claude Code Commands y workflows
 
 ## Características
 
@@ -71,17 +70,22 @@ El paquete instala las siguientes carpetas en tu directorio actual:
 
 Para actualizar una instalación existente, simplemente ejecuta el comando nuevamente:
 
+**Versión estable (recomendado):**
 ```bash
 npx siesa-agents
 ```
 
+**Versión de desarrollo:**
+```bash
+npx siesa-agents@dev
+```
+
 El sistema detectará automáticamente que ya existe una instalación y la actualizará.
 
 ## Requisitos
 
 - Node.js >= 14.0.0
 - npm >= 6.0.0
-- Python >= 3.7 (requerido para hooks de Claude Code)
 
 ## Estructura de archivos instalados
 
@@ -95,6 +99,8 @@ tu-proyecto/
     └── [workflows y configuración de GitHub]
 ```
 
+
+
 ## Soporte
 
 Si encuentras algún problema durante la instalación, por favor verifica:
@@ -109,7 +115,4 @@ MIT
 
 ## Autor
 
-SIESA - Sistemas de Información Empresarial
-
----
-*Versión actualizada automáticamente por CI/CD*
+SIESA - Sistemas de Información Empresarial

package/bin/install.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const readline = require('readline');
 
+
 class SiesaBmadInstaller {
   constructor() {
     // Definir las carpetas primero (nombres en el paquete vs nombres finales)
@@ -15,18 +16,9 @@ class SiesaBmadInstaller {
       { source: 'kiro', target: '.kiro' },
       { source: 'resources', target: '.resources' }
     ];
-    
-    // Lista de archivos que se preservan automáticamente (no se crean backups)
-    this.ignoredFiles = [
-      'data/technical-preferences.md'
-    ];
-    
     this.targetDir = process.cwd();
     // Intentar múltiples ubicaciones posibles para el paquete
     this.packageDir = this.findPackageDir();
-    
-    // Almacenamiento temporal para contenido de archivos ignorados
-    this.preservedContent = new Map();
   }
 
   showBanner() {
@@ -37,7 +29,8 @@ class SiesaBmadInstaller {
     console.log('╚════██║██║██╔══╝  ╚════██║██╔══██║    ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ╚════██║');
     console.log('███████║██║███████╗███████║██║  ██║    ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████║');
     console.log('╚══════╝╚═╝╚══════╝╚══════╝╚═╝  ╚═╝    ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝');
-    console.log('');
+    console.log('Version de Desarrollador Prueba Arnol');
+    console.log('\n');
   }
 
   findPackageDir() {
@@ -134,8 +127,7 @@ class SiesaBmadInstaller {
               modifiedFiles.push({
                 folder: mapping.target,
                 file: relativePath,
-                fullPath: targetFile,
-                is_ignored: this.ignoredFiles.includes(relativePath)
+                fullPath: targetFile
               });
             }
           } catch (error) {
@@ -147,8 +139,7 @@ class SiesaBmadInstaller {
               modifiedFiles.push({
                 folder: mapping.target,
                 file: relativePath,
-                fullPath: targetFile,
-                is_ignored: this.ignoredFiles.includes(relativePath)
+                fullPath: targetFile
               });
             }
           }
@@ -179,10 +170,6 @@ class SiesaBmadInstaller {
   }
 
   async promptUser(modifiedFiles) {
-
-    const hasNonIgnoredFiles = modifiedFiles.some(file => file.is_ignored == false)
-    if (!hasNonIgnoredFiles) return '2'
-
     console.log('\n⚠️  Se detectaron archivos modificados:');
 
     // Agrupar por carpeta
@@ -223,12 +210,6 @@ class SiesaBmadInstaller {
     console.log('\n🔄 Creando backup de archivos modificados...');
 
     for (const item of modifiedFiles) {
-      // No crear backup de archivos ignorados
-      if (item.is_ignored) {
-        console.log(`✓ Preservando: ${item.file} (sin backup)`);
-        continue;
-      }
-
       const originalPath = item.fullPath;
       const backupPath = this.getBackupPath(originalPath);
 
@@ -292,20 +273,11 @@ class SiesaBmadInstaller {
   async copyWithBackupPreservation(sourcePath, targetPath) {
     // Obtener todos los archivos backup existentes
     const backupFiles = await this.findBackupFiles(targetPath);
-    
-    // Copiar la carpeta preservando technical-preferences.md
+
+    // Copiar la carpeta completa sobrescribiendo
     await fs.copy(sourcePath, targetPath, {
       overwrite: true,
-      recursive: true,
-      filter: (src) => {
-        const relativePath = path.relative(sourcePath, src);
-        // No sobrescribir archivos ignorados si ya existen
-        if (this.ignoredFiles.includes(relativePath)) {
-          const targetFile = path.join(targetPath, relativePath);
-          return !fs.existsSync(targetFile);
-        }
-        return true;
-      }
+      recursive: true
     });
 
     // Restaurar los archivos backup
@@ -360,16 +332,7 @@ class SiesaBmadInstaller {
       if (fs.existsSync(sourcePath)) {
         await fs.copy(sourcePath, targetPath, {
           overwrite: true,
-          recursive: true,
-          filter: (src) => {
-            const relativePath = path.relative(sourcePath, src);
-            // No sobrescribir archivos ignorados si ya existen
-            if (this.ignoredFiles.includes(relativePath)) {
-              const targetFile = path.join(targetPath, relativePath);
-              return !fs.existsSync(targetFile);
-            }
-            return true;
-          }
+          recursive: true
         });
       } else {
         console.warn(`⚠️  Carpeta ${mapping.source} no encontrada en el paquete`);
@@ -405,9 +368,6 @@ class SiesaBmadInstaller {
       await this.performUpdateWithBackups();
     } else {
       // Si no hay backups, hacer actualización normal (remover y copiar)
-      // Pero primero preservar archivos ignorados
-      await this.preserveIgnoredFiles();
-      
       for (const mapping of this.folderMappings) {
         const targetPath = path.join(this.targetDir, mapping.target);
 
@@ -418,64 +378,7 @@ class SiesaBmadInstaller {
 
       // Realizar instalación nueva
       await this.performInstallation();
-      
-      // Restaurar archivos ignorados
-      await this.restoreIgnoredFiles();
-    }
-  }
-
-  async preserveIgnoredFiles() {
-    console.log('🔒 Preservando archivos de configuración...');
-    
-    for (const mapping of this.folderMappings) {
-      const targetFolderPath = path.join(this.targetDir, mapping.target);
-      
-      if (!fs.existsSync(targetFolderPath)) {
-        continue;
-      }
-      
-      for (const ignoredFile of this.ignoredFiles) {
-        const filePath = path.join(targetFolderPath, ignoredFile);
-        
-        if (fs.existsSync(filePath)) {
-          try {
-            const content = await fs.readFile(filePath, 'utf8');
-            const key = `${mapping.target}/${ignoredFile}`;
-            this.preservedContent.set(key, content);
-            console.log(`✓ Preservando: ${ignoredFile}`);
-          } catch (error) {
-            console.warn(`⚠️  Error leyendo ${ignoredFile}: ${error.message}`);
-          }
-        }
-      }
-    }
-  }
-
-  async restoreIgnoredFiles() {
-    if (this.preservedContent.size === 0) {
-      return;
-    }
-    
-    console.log('🔄 Restaurando archivos de configuración...');
-    
-    for (const [key, content] of this.preservedContent) {
-      const [targetFolder, ...filePathParts] = key.split('/');
-      const filePath = path.join(this.targetDir, targetFolder, ...filePathParts);
-      
-      try {
-        // Asegurar que el directorio existe
-        await fs.ensureDir(path.dirname(filePath));
-        
-        // Restaurar el contenido
-        await fs.writeFile(filePath, content, 'utf8');
-        console.log(`✓ Restaurado: ${filePathParts.join('/')}`);
-      } catch (error) {
-        console.warn(`⚠️  Error restaurando ${filePathParts.join('/')}: ${error.message}`);
-      }
     }
-    
-    // Limpiar el mapa después de restaurar
-    this.preservedContent.clear();
   }
 
   showPostInstallMessage() {

package/bmad-core/agents/architect.md

@@ -81,8 +81,6 @@ dependencies:
     - architect-checklist.md
   data:
     - technical-preferences.md
-    - technology-stack.md
-    - architecture-patterns.md
   tasks:
     - create-deep-research-prompt.md
     - create-doc.md

package/bmad-core/agents/ux-expert.md

@@ -60,7 +60,6 @@ commands:
 dependencies:
   data:
     - technical-preferences.md
-    - technology-stack.md
     - technical-preferences-ux.md
   tasks:
     - create-doc.md

package/bmad-core/data/backend-standards.md

@@ -1,32 +1,43 @@
 # Backend Development Standards
 
-> **Note**: For architecture patterns and principles (Hexagonal Architecture, DDD, folder structure), see [architecture-patterns.md](./architecture-patterns.md)
+## Architecture Principles
+
+### Hexagonal Architecture Implementation
+- **Application Core**: Domain entities, value objects, aggregates, and domain services
+- **Primary Ports**: Use cases, commands, queries, and application services  
+- **Primary Adapters**: REST controllers, GraphQL resolvers, message handlers
+- **Secondary Ports**: Repository interfaces, external service interfaces
+- **Secondary Adapters**: Prisma repositories, HTTP clients, message publishers
+
+### Dependency Rules
+- Application core must not depend on external frameworks
+- All dependencies point inward toward the domain
+- Use dependency inversion for all external concerns
+- Interfaces defined in application layer, implementations in infrastructure
 
 ## Technology Stack Standards
 
 ### Core Technologies
 - **NestJS**: 10+ with TypeScript and decorators
 - **TypeScript**: Strict mode enabled, no `any` types
-- **Prisma**: ORM for database operations (no raw queries allowed)
-- **Jest + Supertest**: Unit, integration, and E2E testing
-- **Class-validator + Class-transformer**: DTO validation
+- **Prisma**: ORM for database operations (no raw queries)
+- **Jest**: Unit and integration testing
+- **Class-validator**: Request validation and transformation
 
-### Framework Standards
-- **Default Framework**: NestJS 10+ with TypeScript
-- **Database**: Prisma ORM only - no raw SQL queries
-- **Testing**: TDD approach with comprehensive test coverage
-- **Documentation**: Swagger/OpenAPI auto-generated from decorators
-- **Messaging**: NestJS Microservices (Redis, RabbitMQ, or gRPC)
+### Framework Selection Rules
+- **Default**: Always use NestJS 10+ with TypeScript
+- **Database**: Prisma ORM only - no raw SQL queries allowed
+- **Testing**: TDD approach with Jest and Supertest
+- **Documentation**: Swagger/OpenAPI for all endpoints
 
 ### Development Tools
-- **Nx**: MonoRepo management and build orchestration
+- **Nx**: MonoRepo management and build system
 - **ESLint + Prettier**: Code quality and formatting
-- **Husky**: Pre-commit hooks for quality gates
-- **Winston**: Structured logging with log levels
-- **Redis**: Caching, session storage, and message transport
-- **Passport + JWT**: Authentication and authorization
+- **Husky**: Git hooks for pre-commit validation
+- **Winston**: Structured logging
+- **Redis**: Caching and message transport
 
-## Domain-Driven Design Implementation
+## Domain-Driven Design Standards
 
 ### Entity Structure
 ```typescript
@@ -35,6 +46,7 @@ export class UserEntity extends AggregateRoot {
     public readonly id: UserId,
     private _email: EmailValueObject,
     private _name: NameValueObject,
+    private _createdAt: Date,
   ) {
     super();
   }
@@ -44,6 +56,7 @@ export class UserEntity extends AggregateRoot {
       UserId.generate(),
       EmailValueObject.create(props.email),
       NameValueObject.create(props.name),
+      new Date(),
     );
     user.addDomainEvent(new UserCreatedEvent(user.id));
     return user;
@@ -78,6 +91,11 @@ export class EmailValueObject {
     }
   }
 
+  private isValidEmail(email: string): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
   equals(other: EmailValueObject): boolean {
     return this.value === other.value;
   }
@@ -88,45 +106,15 @@ export class EmailValueObject {
 }
 ```
 
-### Repository Pattern
+### Repository Interface Pattern
 ```typescript
-// Interface (in application/ports/repositories)
 export interface UserRepositoryInterface {
   save(user: UserEntity): Promise<UserEntity>;
   findById(id: UserId): Promise<UserEntity | null>;
   findByEmail(email: EmailValueObject): Promise<UserEntity | null>;
+  findAll(criteria: FindUsersCriteria): Promise<UserEntity[]>;
   delete(id: UserId): Promise<void>;
 }
-
-// Implementation (in infrastructure/repositories)
-@Injectable()
-export class PrismaUserRepository implements UserRepositoryInterface {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async save(user: UserEntity): Promise<UserEntity> {
-    const data = {
-      id: user.id.toString(),
-      email: user.email.toString(),
-      name: user.name.toString(),
-    };
-
-    const savedUser = await this.prisma.user.upsert({
-      where: { id: data.id },
-      update: data,
-      create: data,
-    });
-
-    return this.toDomain(savedUser);
-  }
-
-  private toDomain(prismaUser: User): UserEntity {
-    return UserEntity.reconstitute({
-      id: UserId.create(prismaUser.id),
-      email: EmailValueObject.create(prismaUser.email),
-      name: NameValueObject.create(prismaUser.name),
-    });
-  }
-}
 ```
 
 ## Use Case Standards
@@ -145,19 +133,20 @@ export class CreateUserUseCase {
   async execute(command: CreateUserCommand): Promise<UserResponseDto> {
     // 1. Validate business rules
     await this.validateUserDoesNotExist(command.email);
-
+    
     // 2. Create domain entity
     const user = UserEntity.create({
       email: command.email,
       name: command.name,
     });
-
+    
     // 3. Persist entity
     const savedUser = await this.userRepository.save(user);
-
+    
     // 4. Publish domain events
     await this.eventBus.publishAll(savedUser.getUncommittedEvents());
-
+    savedUser.markEventsAsCommitted();
+    
     // 5. Return response DTO
     return UserResponseDto.fromEntity(savedUser);
   }
@@ -183,16 +172,20 @@ export class CreateUserCommand {
   @IsNotEmpty()
   @Length(2, 50)
   readonly name: string;
+
+  @IsOptional()
+  @IsString()
+  readonly organizationId?: string;
 }
 ```
 
 ## Testing Standards
 
 ### Testing Strategy
-- **Unit Tests**: Domain entities, value objects, use cases (isolated logic)
-- **Integration Tests**: Repository implementations, database operations
-- **E2E Tests**: Complete API workflows with Supertest
-- **TDD Approach**: Write tests before implementation
+- **Unit Tests**: Domain entities, value objects, use cases
+- **Integration Tests**: Repository implementations, external services
+- **E2E Tests**: Complete API workflows
+- **Contract Tests**: External service integrations
 
 ### Test Structure
 ```typescript
@@ -205,8 +198,19 @@ describe('CreateUserUseCase', () => {
     const module = await Test.createTestingModule({
       providers: [
         CreateUserUseCase,
-        { provide: USER_REPOSITORY, useValue: { save: jest.fn(), findByEmail: jest.fn() } },
-        { provide: EVENT_BUS, useValue: { publishAll: jest.fn() } },
+        {
+          provide: USER_REPOSITORY,
+          useValue: {
+            save: jest.fn(),
+            findByEmail: jest.fn(),
+          },
+        },
+        {
+          provide: EVENT_BUS,
+          useValue: {
+            publishAll: jest.fn(),
+          },
+        },
       ],
     }).compile();
 
@@ -215,33 +219,46 @@ describe('CreateUserUseCase', () => {
     eventBus = module.get(EVENT_BUS);
   });
 
-  it('should create user successfully', async () => {
-    // Arrange
-    const command = new CreateUserCommand();
-    command.email = 'test@example.com';
-    command.name = 'Test User';
+  describe('execute', () => {
+    it('should create user successfully', async () => {
+      // Arrange
+      const command = new CreateUserCommand();
+      command.email = 'test@example.com';
+      command.name = 'Test User';
 
-    userRepository.findByEmail.mockResolvedValue(null);
-    userRepository.save.mockResolvedValue(UserEntity.create(command));
+      const expectedUser = UserEntity.create({
+        email: command.email,
+        name: command.name,
+      });
 
-    // Act
-    const result = await useCase.execute(command);
+      userRepository.findByEmail.mockResolvedValue(null);
+      userRepository.save.mockResolvedValue(expectedUser);
 
-    // Assert
-    expect(result.email).toBe(command.email);
-    expect(userRepository.save).toHaveBeenCalledWith(expect.any(UserEntity));
-    expect(eventBus.publishAll).toHaveBeenCalled();
-  });
+      // Act
+      const result = await useCase.execute(command);
 
-  it('should throw error when user already exists', async () => {
-    // Arrange
-    const command = new CreateUserCommand();
-    command.email = 'existing@example.com';
+      // Assert
+      expect(result.email).toBe(command.email);
+      expect(userRepository.save).toHaveBeenCalledWith(expect.any(UserEntity));
+      expect(eventBus.publishAll).toHaveBeenCalled();
+    });
 
-    userRepository.findByEmail.mockResolvedValue(UserEntity.create(command));
+    it('should throw error when user already exists', async () => {
+      // Arrange
+      const command = new CreateUserCommand();
+      command.email = 'existing@example.com';
+      command.name = 'Test User';
 
-    // Act & Assert
-    await expect(useCase.execute(command)).rejects.toThrow(UserAlreadyExistsException);
+      const existingUser = UserEntity.create({
+        email: command.email,
+        name: 'Existing User',
+      });
+
+      userRepository.findByEmail.mockResolvedValue(existingUser);
+
+      // Act & Assert
+      await expect(useCase.execute(command)).rejects.toThrow(UserAlreadyExistsException);
+    });
   });
 });
 ```
@@ -260,20 +277,23 @@ export class UserController {
 
   @Post()
   @ApiOperation({ summary: 'Create a new user' })
-  @ApiResponse({ status: 201, type: UserResponseDto })
+  @ApiResponse({ status: 201, description: 'User created successfully', type: UserResponseDto })
   @ApiResponse({ status: 400, description: 'Bad request' })
-  async createUser(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
+  @ApiResponse({ status: 409, description: 'User already exists' })
+  async createUser(@Body() createUserDto: CreateUserDto): Promise<UserResponseDto> {
     const command = new CreateUserCommand();
-    Object.assign(command, dto);
+    Object.assign(command, createUserDto);
     return this.createUserUseCase.execute(command);
   }
 
   @Get(':id')
   @ApiOperation({ summary: 'Get user by ID' })
-  @ApiResponse({ status: 200, type: UserResponseDto })
+  @ApiParam({ name: 'id', description: 'User ID' })
+  @ApiResponse({ status: 200, description: 'User found', type: UserResponseDto })
   @ApiResponse({ status: 404, description: 'User not found' })
   async getUser(@Param('id', ParseUUIDPipe) id: string): Promise<UserResponseDto> {
-    return this.getUserUseCase.execute(new GetUserQuery(id));
+    const query = new GetUserQuery(id);
+    return this.getUserUseCase.execute(query);
   }
 }
 ```
@@ -288,7 +308,9 @@ model User {
   name      String
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
-  orders    Order[]
+
+  // Relationships
+  orders Order[]
 
   @@map("users")
 }
@@ -298,6 +320,8 @@ model Order {
   total    Decimal     @db.Decimal(10, 2)
   status   OrderStatus
   userId   String
+  
+  // Relationships
   user     User        @relation(fields: [userId], references: [id])
   items    OrderItem[]
 
@@ -313,60 +337,104 @@ enum OrderStatus {
 }
 ```
 
-### Prisma Best Practices
-- Use enums for fixed value sets
-- Always add indexes on foreign keys
-- Use `@@map` for table naming (plural snake_case)
-- Include `createdAt` and `updatedAt` timestamps
-- Use `cuid()` for primary keys
-- No raw SQL queries - use Prisma Client only
+### Repository Implementation
+```typescript
+@Injectable()
+export class PrismaUserRepository implements UserRepositoryInterface {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async save(user: UserEntity): Promise<UserEntity> {
+    const data = {
+      id: user.id.toString(),
+      email: user.email.toString(),
+      name: user.name.toString(),
+    };
+
+    const savedUser = await this.prisma.user.upsert({
+      where: { id: data.id },
+      update: data,
+      create: data,
+    });
+
+    return this.toDomain(savedUser);
+  }
+
+  async findById(id: UserId): Promise<UserEntity | null> {
+    const user = await this.prisma.user.findUnique({
+      where: { id: id.toString() },
+    });
+
+    return user ? this.toDomain(user) : null;
+  }
+
+  private toDomain(prismaUser: User): UserEntity {
+    return UserEntity.reconstitute({
+      id: UserId.create(prismaUser.id),
+      email: EmailValueObject.create(prismaUser.email),
+      name: NameValueObject.create(prismaUser.name),
+      createdAt: prismaUser.createdAt,
+    });
+  }
+}
+```
 
 ## Security Standards
 
 ### Authentication & Authorization
-- **JWT Tokens**: Proper expiration and refresh token handling
-- **RBAC**: Role-based access control with Guards
-- **Validation**: Input validation on all endpoints (class-validator)
-- **Rate Limiting**: Throttle public endpoints to prevent abuse
-- **Environment**: HTTPS only in production, secrets in env variables
+- JWT tokens with proper expiration
+- Role-based access control (RBAC)
+- Input validation on all endpoints
+- Rate limiting for public endpoints
+- HTTPS only in production
 
 ### Data Protection
-- Encrypt sensitive data at rest and in transit
-- Never commit secrets to repository
-- Implement audit logging for critical operations
-- OWASP Top 10 compliance
-- Regular dependency security audits
+- Encrypt sensitive data at rest
+- Use environment variables for secrets
+- Implement audit logging
+- Regular security updates
+- OWASP compliance
 
 ## Performance Standards
 
 ### Database Optimization
-- Proper indexing on frequently queried fields
-- Connection pooling via Prisma
-- Pagination for large datasets (cursor-based preferred)
-- Avoid N+1 queries with Prisma `include`
-- Query monitoring and slow query logging
+- Proper indexing strategies
+- Connection pooling
+- Query optimization
+- Pagination for large datasets
+- Database monitoring
 
 ### Caching Strategy
-- **Redis**: Session data, rate limiting, and frequently accessed data
-- **Application Cache**: In-memory caching for configuration
-- **TTL Strategy**: Appropriate time-to-live for different data types
-- **Invalidation**: Event-driven cache invalidation
+- Redis for session data
+- Application-level caching
+- HTTP caching headers
+- CDN for static assets
+- Cache invalidation patterns
 
-## Error Handling
+## MonoRepo Organization
 
-### Exception Hierarchy
-- Domain exceptions for business rule violations
-- Application exceptions for use case errors
-- Infrastructure exceptions for external service failures
-- HTTP exception filters for API responses
+### Shared Libraries Structure
+```
+libs/
+├── common/
+│   ├── decorators/
+│   ├── filters/
+│   ├── guards/
+│   ├── interceptors/
+│   ├── pipes/
+│   └── utils/
+├── domain-core/
+│   ├── base/
+│   ├── interfaces/
+│   └── exceptions/
+└── database/
+    ├── base-repository.ts
+    ├── transaction.decorator.ts
+    └── prisma.service.ts
+```
 
-### Error Response Format
-```typescript
-{
-  "statusCode": 400,
-  "message": "User with email already exists",
-  "error": "UserAlreadyExistsException",
-  "timestamp": "2024-01-15T10:30:00Z",
-  "path": "/api/users"
-}
-```
+### Service Independence
+- Each microservice has its own database
+- Shared code through libraries only
+- Independent deployment pipelines
+- Service-to-service communication via events
+- No direct database access between services

package/claude/hooks/file-restriction-hook.py

@@ -0,0 +1,51 @@
+import sys
+import json
+import os
+
+try:
+    # Leer JSON desde stdin
+    data = json.load(sys.stdin)
+
+    # Obtener información del archivo y sesión
+    file_path = data.get('tool_input', {}).get('file_path', '')
+    extension = os.path.splitext(file_path)[1].lower() if file_path else ''
+    session_id = data.get('session_id', '')
+    cwd = data.get('cwd', '')
+
+    # Construir ruta relativa al log desde el cwd
+    log_file = os.path.join(cwd, '.claude', 'logs', 'active_agents.json')
+
+    # Agentes que solo pueden escribir markdown
+    MARKDOWN_ONLY_AGENTS = ['PO', 'SM', 'PM', 'ANALYST', 'ARCHITECT', 'UX-EXPERT']
+
+    # Verificar si la sesión actual tiene un agente activo
+    if session_id and os.path.exists(log_file):
+        try:
+            with open(log_file, 'r', encoding='utf-8') as f:
+                active_agents = json.load(f)
+            
+            # Si la sesión actual tiene un agente activo
+            if session_id in active_agents:
+                agent_type = active_agents[session_id]['agent']
+                
+                # Si el agente está en la lista de solo markdown
+                if agent_type in MARKDOWN_ONLY_AGENTS:
+                    # Solo permitir archivos markdown
+                    if extension != '.md':
+                        result = {
+                            "hookSpecificOutput": {
+                                "hookEventName": "PreToolUse",
+                                "permissionDecision": "deny",
+                                "permissionDecisionReason": f"⛔ El agente de tipo {agent_type} solo puede redactar archivos markdown"
+                            }
+                        }
+                        print(json.dumps(result))
+                        sys.exit(0)
+        except:
+            # Si hay error leyendo el log, permitir la operación
+            pass
+
+    # Si no está bloqueado, permitir la operación (no imprimir nada)
+except Exception as e:
+    # En caso de error, permitir la operación
+    pass

package/claude/hooks/track-agent.py

@@ -0,0 +1,67 @@
+import sys
+import json
+import os
+from datetime import datetime
+
+try:
+    # Leer JSON desde stdin
+    data = json.load(sys.stdin)
+    
+    session_id = data.get('session_id', '')
+    prompt = data.get('prompt', '').lower()
+    cwd = data.get('cwd', '')
+    
+    # Construir ruta relativa al log desde el cwd
+    log_file = os.path.join(cwd, '.claude', 'logs', 'active_agents.json')
+    
+    # Crear directorio si no existe
+    log_dir = os.path.dirname(log_file)
+    os.makedirs(log_dir, exist_ok=True)
+    
+    # Lista completa de agentes disponibles
+    agent_identifiers = {
+        'agents:po': 'PO',
+        'agents:sm': 'SM',
+        'agents:pm': 'PM',
+        'agents:analyst': 'ANALYST',
+        'agents:architect': 'ARCHITECT',
+        'agents:dev': 'DEV',
+        'agents:backend': 'BACKEND',
+        'agents:frontend': 'FRONTEND',
+        'agents:qa': 'QA',
+        'agents:ux-expert': 'UX-EXPERT',
+        'agents:bmad-master': 'BMAD-MASTER',
+        'agents:bmad-orchestrator': 'BMAD-ORCHESTRATOR'
+    }
+    
+    # Detectar si se está invocando un agente
+    agent_type = None
+    for identifier, agent_name in agent_identifiers.items():
+        if identifier in prompt or f'/bmad:{identifier}' in prompt:
+            agent_type = agent_name
+            break
+    
+    if agent_type and session_id:
+        # Leer log existente
+        active_agents = {}
+        if os.path.exists(log_file):
+            try:
+                with open(log_file, 'r', encoding='utf-8') as f:
+                    active_agents = json.load(f)
+            except:
+                active_agents = {}
+        
+        # Actualizar o agregar la sesión con el agente actual
+        active_agents[session_id] = {
+            'agent': agent_type,
+            'timestamp': datetime.now().isoformat(),
+            'last_prompt': prompt[:100]  # Guardar inicio del prompt para debug
+        }
+        
+        # Guardar log actualizado
+        with open(log_file, 'w', encoding='utf-8') as f:
+            json.dump(active_agents, f, indent=2, ensure_ascii=False)
+
+except Exception as e:
+    # En caso de error, no bloquear la operación
+    pass

package/claude/settings.local.json

@@ -16,5 +16,41 @@
     ],
     "deny": [],
     "ask": []
-  }
+  },
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python .claude/hooks/track-agent.py"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python .claude/hooks/file-restriction-hook.py"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python .claude/hooks/cleanup-agent.py"
+          }
+        ]
+      }
+    ]
+  },
+  "disableAllHooks": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siesa-agents",
-  "version": "2.1.25",
+  "version": "2.1.26-dev.0",
   "description": "Paquete para instalar y configurar agentes SIESA en tu proyecto",
   "main": "index.js",
   "bin": {

package/bmad-core/data/architecture-patterns.md

@@ -1,261 +0,0 @@
-# Architecture Patterns & Design Decisions
-
-## Frontend Architecture
-
-### Architecture Style
-- **Clean Architecture** + **Domain-Driven Design (DDD)**
-
-### Folder Structure
-
-Next.js 15 App Router Structure with Clean Architecture + DDD:
-
-```
-├── app/                         # Next.js App Router directory
-│   ├── (dashboard)/            # Route groups for dashboard
-│   ├── sales/                  # Routes for sales module
-│   │   ├── quotes/             # Quote management pages
-│   │   └── invoices/           # Invoice pages
-│   ├── inventory/              # Inventory routes
-│   ├── globals.css             # Global styles
-│   ├── layout.tsx              # Root layout component
-│   ├── page.tsx               # Home page
-│   ├── loading.tsx            # Global loading UI
-│   └── not-found.tsx          # 404 page
-│
-├── src/
-│   ├── modules/                # Business modules following DDD
-│   │   ├── sales/              # Sales module
-│   │   │   ├── quotes/         # Quote domain
-│   │   │   │   ├── cart/       # Shopping cart feature
-│   │   │   │   │   ├── domain/
-│   │   │   │   │   │   ├── entities/
-│   │   │   │   │   │   ├── repositories/
-│   │   │   │   │   │   ├── services/
-│   │   │   │   │   │   └── types/
-│   │   │   │   │   ├── application/
-│   │   │   │   │   │   ├── use-cases/
-│   │   │   │   │   │   ├── hooks/
-│   │   │   │   │   │   └── store/
-│   │   │   │   │   ├── infrastructure/
-│   │   │   │   │   │   ├── repositories/
-│   │   │   │   │   │   ├── api/
-│   │   │   │   │   │   └── adapters/
-│   │   │   │   │   └── presentation/
-│   │   │   │   │       └── components/    # Only components, pages in app/
-│   │   │   │   └── products/              # Products feature
-│   │   │   └── billing/                   # Billing domain
-│   │   ├── inventory/                     # Inventory module
-│   │   └── users/                         # User module
-│   │
-│   ├── shared/
-│   │   ├── components/         # Reusable UI components
-│   │   ├── hooks/              # Shared hooks
-│   │   ├── utils/              # Utility functions
-│   │   ├── types/              # Common TypeScript types
-│   │   └── constants/          # App constants
-│   │
-│   ├── providers/              # React context providers
-│   ├── store/                  # Global Zustand stores
-│   └── middleware.ts           # Next.js middleware
-│
-├── lib/                        # Next.js utilities and configurations
-├── components/                 # Global UI components (alternative to src/shared)
-├── public/                     # Static assets and PWA manifest
-└── styles/                     # Additional stylesheets
-```
-
-### Core Principles
-
-#### Clean Architecture First
-Strict separation of:
-- **Domain layer** - Business entities, repositories interfaces, domain services, and types
-- **Application layer** - Use cases, hooks, and state management (Zustand stores)
-- **Infrastructure layer** - Repository implementations, API clients, and adapters
-- **Presentation layer** - UI components (pages go in `app/`, components in `presentation/`)
-
-#### Domain-Driven Design
-Business logic drives architecture decisions. Organize by business modules and domains, not technical layers.
-
-#### Component Composition
-Build complex UIs from simple, reusable components.
-
-#### Type Safety
-Leverage TypeScript for compile-time safety and developer experience.
-
-#### Performance by Design
-- Lazy loading
-- Memoization
-- Bundle optimization
-
-#### Accessibility as Standard
-WCAG 2.1 AA compliance in all components.
-
-#### Test-Driven Development
-Unit tests for all use cases and components.
-
-#### Progressive Web App
-Offline-first approach with service workers.
-
-#### Minimal and Functional
-Only build what's explicitly requested, nothing more.
-
-#### User-Centered Design
-Start with user needs and work backward to implementation.
-
-#### MCP Shadcn Available
-Use MCP to install Shadcn components instead of creating manually.
-
-### Framework Selection Rules
-
-**Default**: Always use Next.js 15 with App Router unless explicitly told otherwise.
-
-**Exceptions**: Only use pure React + Vite when user specifically mentions offline-first functionality or requests non-Next.js setup.
-
-**Reasoning**: Next.js provides better developer experience, built-in optimization, and easier deployment while maintaining PWA capabilities.
-
-## Backend Architecture
-
-### Architecture Style
-- **Hexagonal Architecture** (Ports & Adapters) + **Domain-Driven Design (DDD)**
-
-### Folder Structure
-
-MonoRepo Structure with Hexagonal Architecture + DDD:
-
-```
-├── apps/                              # Microservices applications
-│   ├── sales-service/                 # Sales domain microservice
-│   │   ├── src/
-│   │   │   ├── modules/
-│   │   │   │   ├── quotes/           # Quote bounded context
-│   │   │   │   │   ├── application/
-│   │   │   │   │   │   ├── ports/              # Interfaces (secondary ports)
-│   │   │   │   │   │   │   ├── repositories/
-│   │   │   │   │   │   │   └── services/
-│   │   │   │   │   │   ├── use-cases/          # Primary ports
-│   │   │   │   │   │   ├── commands/
-│   │   │   │   │   │   ├── queries/
-│   │   │   │   │   │   └── dto/
-│   │   │   │   │   ├── domain/
-│   │   │   │   │   │   ├── entities/
-│   │   │   │   │   │   ├── value-objects/
-│   │   │   │   │   │   ├── aggregates/
-│   │   │   │   │   │   ├── events/
-│   │   │   │   │   │   └── services/           # Domain services
-│   │   │   │   │   └── infrastructure/        # Adapters (secondary adapters)
-│   │   │   │   │       ├── repositories/      # Prisma implementations
-│   │   │   │   │       ├── services/          # External service adapters
-│   │   │   │   │       └── events/
-│   │   │   │   └── products/                  # Product bounded context
-│   │   │   ├── api/                           # Primary adapters
-│   │   │   │   ├── controllers/
-│   │   │   │   ├── guards/
-│   │   │   │   ├── middlewares/
-│   │   │   │   └── filters/
-│   │   │   ├── config/
-│   │   │   ├── main.ts
-│   │   │   └── app.module.ts
-│   │   ├── test/
-│   │   ├── prisma/
-│   │   │   ├── schema.prisma
-│   │   │   └── migrations/
-│   │   └── package.json
-│   │
-│   ├── inventory-service/             # Inventory domain microservice
-│   └── user-service/                  # User domain microservice
-│
-├── libs/                              # Shared libraries
-│   ├── common/                       # Common utilities
-│   │   ├── src/
-│   │   │   ├── decorators/
-│   │   │   ├── filters/
-│   │   │   ├── guards/
-│   │   │   ├── interceptors/
-│   │   │   ├── pipes/
-│   │   │   ├── types/
-│   │   │   └── utils/
-│   │   └── package.json
-│   │
-│   ├── domain-core/                  # Shared domain concepts
-│   │   ├── src/
-│   │   │   ├── base/
-│   │   │   │   ├── aggregate-root.ts
-│   │   │   │   ├── entity.ts
-│   │   │   │   ├── value-object.ts
-│   │   │   │   └── domain-event.ts
-│   │   │   ├── interfaces/
-│   │   │   └── exceptions/
-│   │   └── package.json
-│   │
-│   └── database/                     # Shared database utilities
-│       ├── src/
-│       │   ├── base-repository.ts
-│       │   ├── transaction.decorator.ts
-│       │   └── prisma.service.ts
-│       └── package.json
-│
-├── tools/                            # Development tools
-├── nx.json                          # Nx workspace configuration
-├── package.json                     # Root package.json
-└── tsconfig.base.json               # Base TypeScript config
-```
-
-### Core Principles
-
-#### Hexagonal Architecture First
-Strict separation of concerns following ports & adapters pattern:
-- **Domain Layer**: Pure business logic with entities, value objects, aggregates, and domain services
-- **Application Layer**: Use cases orchestrating domain logic, defining ports (interfaces)
-- **Infrastructure Layer**: Adapters implementing ports (Prisma repos, HTTP clients, message publishers)
-- **API Layer**: Primary adapters exposing application via REST/GraphQL (controllers, resolvers)
-
-#### Domain-Driven Design
-Business logic drives all architectural decisions:
-- **Bounded Contexts**: Each module represents a bounded context (quotes, products, billing)
-- **Ubiquitous Language**: Code reflects business terminology
-- **Aggregates**: Consistency boundaries for domain entities
-- **Domain Events**: Communicate changes across bounded contexts
-- **Repository Pattern**: Abstract data access behind interfaces
-
-#### Dependency Rules
-- Domain layer has zero dependencies on frameworks or external libraries
-- All dependencies point inward toward the domain core
-- Use dependency inversion for all external concerns (databases, APIs, messaging)
-- Interfaces defined in application layer, implementations in infrastructure layer
-
-#### Microservices Independence
-- Each microservice has its own database (no shared databases)
-- Shared code through libraries only (common, domain-core, database)
-- Independent deployment pipelines per service
-- Service-to-service communication via events (async messaging)
-- No direct database access between services
-
-#### Test-Driven Development
-- Unit tests for domain entities, value objects, and use cases
-- Integration tests for repository implementations
-- E2E tests for complete API workflows
-- TDD approach: write tests before implementation
-
-#### Type Safety & Validation
-- Leverage TypeScript strict mode for compile-time safety
-- Domain validation in value objects and entities
-- DTO validation at API boundaries with class-validator
-- No `any` types allowed
-
-#### Security by Design
-- Authentication and authorization at every layer
-- Input validation on all endpoints
-- OWASP Top 10 compliance
-- Audit logging for critical operations
-
-### Framework Selection Rules
-
-**Default**: Always use NestJS 10+ with TypeScript for backend services.
-
-**Database**: Prisma ORM only - no raw SQL queries allowed.
-
-**Testing**: Jest + Supertest with TDD approach.
-
-**Documentation**: Swagger/OpenAPI auto-generated from decorators.
-
-**Reasoning**: NestJS provides excellent DI container, decorator-based development, and native support for microservices patterns while enforcing SOLID principles.

package/bmad-core/data/technology-stack.md

@@ -1,81 +0,0 @@
-# Technology Stack
-
-## Frontend Stack
-
-### Framework
-- **Next.js 15** with TypeScript (App Router)
-  - Default framework unless explicitly told otherwise
-  - Built-in Turbopack/Webpack for building
-  - File-based routing with App Router
-  - Exception: Use pure React + Vite only when user specifically mentions offline-first functionality or requests non-Next.js setup
-
-### State Management
-- **Zustand**
-
-### UI Framework & Styling
-- **Shadcn/ui** (component library)
-- **Radix UI** (primitives)
-- **TailwindCSS v4** (styling)
-
-### Architecture
-- **Clean Architecture** + **Domain-Driven Design (DDD)**
-
-### Testing
-- **Vitest** (test runner)
-- **React Testing Library** (component testing)
-- **MSW** (Mock Service Worker - API mocking)
-
-### Forms & Validation
-- **React Hook Form** (form management)
-- **Zod** (schema validation)
-
-### HTTP Client
-- **Axios** with interceptors
-
-### Progressive Web App (PWA)
-- **Next.js PWA plugin**
-- **Workbox** (service worker library)
-
-### Routing
-- **Next.js App Router** (file-based routing)
-
-## Core Principles
-
-### Clean Architecture First
-Strict separation of:
-- Domain layer
-- Application layer
-- Infrastructure layer
-- Presentation layer
-
-### Domain-Driven Design
-Business logic drives architecture decisions
-
-### Component Composition
-Build complex UIs from simple, reusable components
-
-### Type Safety
-Leverage TypeScript for compile-time safety and developer experience
-
-### Performance by Design
-- Lazy loading
-- Memoization
-- Bundle optimization
-
-### Accessibility as Standard
-WCAG 2.1 AA compliance in all components
-
-### Test-Driven Development
-Unit tests for all use cases and components
-
-### Progressive Web App
-Offline-first approach with service workers
-
-### Minimal and Functional
-Only build what's explicitly requested, nothing more
-
-### User-Centered Design
-Start with user needs and work backward to implementation
-
-### MCP Shadcn Available
-Use MCP to install Shadcn components instead of creating manually