siesa-agents 2.1.25-dev.1 → 2.1.26

package/README.md

@@ -1,4 +1,4 @@
-# SIESA BMAD Agents
+# SIESA Agents
 
 Paquete para instalar y configurar agentes SIESA en tu proyecto.
 
@@ -52,6 +52,7 @@ 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
 
@@ -70,22 +71,17 @@ 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
 
@@ -99,8 +95,6 @@ tu-proyecto/
     └── [workflows y configuración de GitHub]
 ```
 
-
-
 ## Soporte
 
 Si encuentras algún problema durante la instalación, por favor verifica:
@@ -115,4 +109,7 @@ MIT
 
 ## Autor
 
-SIESA - Sistemas de Información Empresarial
+SIESA - Sistemas de Información Empresarial
+
+---
+*Versión actualizada automáticamente por CI/CD*

package/bin/install.js

@@ -4,7 +4,6 @@ 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)
@@ -16,10 +15,20 @@ 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() {
     console.log('\n');
@@ -29,8 +38,7 @@ class SiesaBmadInstaller {
     console.log('╚════██║██║██╔══╝  ╚════██║██╔══██║    ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ╚════██║');
     console.log('███████║██║███████╗███████║██║  ██║    ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████║');
     console.log('╚══════╝╚═╝╚══════╝╚══════╝╚═╝  ╚═╝    ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝');
-    console.log('Version de Desarrollador Prueba');
-    console.log('\n');
+    console.log('');
   }
 
   findPackageDir() {
@@ -127,7 +135,8 @@ class SiesaBmadInstaller {
               modifiedFiles.push({
                 folder: mapping.target,
                 file: relativePath,
-                fullPath: targetFile
+                fullPath: targetFile,
+                is_ignored: this.ignoredFiles.includes(relativePath)
               });
             }
           } catch (error) {
@@ -139,7 +148,8 @@ class SiesaBmadInstaller {
               modifiedFiles.push({
                 folder: mapping.target,
                 file: relativePath,
-                fullPath: targetFile
+                fullPath: targetFile,
+                is_ignored: this.ignoredFiles.includes(relativePath)
               });
             }
           }
@@ -170,6 +180,10 @@ 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
@@ -210,6 +224,12 @@ 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);
 
@@ -273,11 +293,20 @@ class SiesaBmadInstaller {
   async copyWithBackupPreservation(sourcePath, targetPath) {
     // Obtener todos los archivos backup existentes
     const backupFiles = await this.findBackupFiles(targetPath);
-
-    // Copiar la carpeta completa sobrescribiendo
+    
+    // Copiar la carpeta preservando technical-preferences.md
     await fs.copy(sourcePath, targetPath, {
       overwrite: true,
-      recursive: 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;
+      }
     });
 
     // Restaurar los archivos backup
@@ -332,7 +361,16 @@ class SiesaBmadInstaller {
       if (fs.existsSync(sourcePath)) {
         await fs.copy(sourcePath, targetPath, {
           overwrite: true,
-          recursive: 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;
+          }
         });
       } else {
         console.warn(`⚠️  Carpeta ${mapping.source} no encontrada en el paquete`);
@@ -368,6 +406,9 @@ 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);
 
@@ -378,7 +419,64 @@ 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,6 +81,8 @@ 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,6 +60,7 @@ commands:
 dependencies:
   data:
     - technical-preferences.md
+    - technology-stack.md
     - technical-preferences-ux.md
   tasks:
     - create-doc.md

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

@@ -0,0 +1,261 @@
+# 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/backend-standards.md

@@ -1,43 +1,32 @@
 # Backend Development Standards
 
-## 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
+> **Note**: For architecture patterns and principles (Hexagonal Architecture, DDD, folder structure), see [architecture-patterns.md](./architecture-patterns.md)
 
 ## 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)
-- **Jest**: Unit and integration testing
-- **Class-validator**: Request validation and transformation
+- **Prisma**: ORM for database operations (no raw queries allowed)
+- **Jest + Supertest**: Unit, integration, and E2E testing
+- **Class-validator + Class-transformer**: DTO validation
 
-### 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
+### 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)
 
 ### Development Tools
-- **Nx**: MonoRepo management and build system
+- **Nx**: MonoRepo management and build orchestration
 - **ESLint + Prettier**: Code quality and formatting
-- **Husky**: Git hooks for pre-commit validation
-- **Winston**: Structured logging
-- **Redis**: Caching and message transport
+- **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
 
-## Domain-Driven Design Standards
+## Domain-Driven Design Implementation
 
 ### Entity Structure
 ```typescript
@@ -46,7 +35,6 @@ export class UserEntity extends AggregateRoot {
     public readonly id: UserId,
     private _email: EmailValueObject,
     private _name: NameValueObject,
-    private _createdAt: Date,
   ) {
     super();
   }
@@ -56,7 +44,6 @@ 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;
@@ -91,11 +78,6 @@ 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;
   }
@@ -106,15 +88,45 @@ export class EmailValueObject {
 }
 ```
 
-### Repository Interface Pattern
+### Repository 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
@@ -133,20 +145,19 @@ 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);
   }
@@ -172,20 +183,16 @@ 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
-- **Integration Tests**: Repository implementations, external services
-- **E2E Tests**: Complete API workflows
-- **Contract Tests**: External service integrations
+- **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
 
 ### Test Structure
 ```typescript
@@ -198,19 +205,8 @@ 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();
 
@@ -219,46 +215,33 @@ describe('CreateUserUseCase', () => {
     eventBus = module.get(EVENT_BUS);
   });
 
-  describe('execute', () => {
-    it('should create user successfully', async () => {
-      // Arrange
-      const command = new CreateUserCommand();
-      command.email = 'test@example.com';
-      command.name = 'Test User';
-
-      const expectedUser = UserEntity.create({
-        email: command.email,
-        name: command.name,
-      });
-
-      userRepository.findByEmail.mockResolvedValue(null);
-      userRepository.save.mockResolvedValue(expectedUser);
+  it('should create user successfully', async () => {
+    // Arrange
+    const command = new CreateUserCommand();
+    command.email = 'test@example.com';
+    command.name = 'Test User';
 
-      // Act
-      const result = await useCase.execute(command);
+    userRepository.findByEmail.mockResolvedValue(null);
+    userRepository.save.mockResolvedValue(UserEntity.create(command));
 
-      // 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';
-      command.name = 'Test User';
+    // Assert
+    expect(result.email).toBe(command.email);
+    expect(userRepository.save).toHaveBeenCalledWith(expect.any(UserEntity));
+    expect(eventBus.publishAll).toHaveBeenCalled();
+  });
 
-      const existingUser = UserEntity.create({
-        email: command.email,
-        name: 'Existing User',
-      });
+  it('should throw error when user already exists', async () => {
+    // Arrange
+    const command = new CreateUserCommand();
+    command.email = 'existing@example.com';
 
-      userRepository.findByEmail.mockResolvedValue(existingUser);
+    userRepository.findByEmail.mockResolvedValue(UserEntity.create(command));
 
-      // Act & Assert
-      await expect(useCase.execute(command)).rejects.toThrow(UserAlreadyExistsException);
-    });
+    // Act & Assert
+    await expect(useCase.execute(command)).rejects.toThrow(UserAlreadyExistsException);
   });
 });
 ```
@@ -277,23 +260,20 @@ export class UserController {
 
   @Post()
   @ApiOperation({ summary: 'Create a new user' })
-  @ApiResponse({ status: 201, description: 'User created successfully', type: UserResponseDto })
+  @ApiResponse({ status: 201, type: UserResponseDto })
   @ApiResponse({ status: 400, description: 'Bad request' })
-  @ApiResponse({ status: 409, description: 'User already exists' })
-  async createUser(@Body() createUserDto: CreateUserDto): Promise<UserResponseDto> {
+  async createUser(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
     const command = new CreateUserCommand();
-    Object.assign(command, createUserDto);
+    Object.assign(command, dto);
     return this.createUserUseCase.execute(command);
   }
 
   @Get(':id')
   @ApiOperation({ summary: 'Get user by ID' })
-  @ApiParam({ name: 'id', description: 'User ID' })
-  @ApiResponse({ status: 200, description: 'User found', type: UserResponseDto })
+  @ApiResponse({ status: 200, type: UserResponseDto })
   @ApiResponse({ status: 404, description: 'User not found' })
   async getUser(@Param('id', ParseUUIDPipe) id: string): Promise<UserResponseDto> {
-    const query = new GetUserQuery(id);
-    return this.getUserUseCase.execute(query);
+    return this.getUserUseCase.execute(new GetUserQuery(id));
   }
 }
 ```
@@ -308,9 +288,7 @@ model User {
   name      String
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
-
-  // Relationships
-  orders Order[]
+  orders    Order[]
 
   @@map("users")
 }
@@ -320,8 +298,6 @@ model Order {
   total    Decimal     @db.Decimal(10, 2)
   status   OrderStatus
   userId   String
-  
-  // Relationships
   user     User        @relation(fields: [userId], references: [id])
   items    OrderItem[]
 
@@ -337,104 +313,60 @@ enum OrderStatus {
 }
 ```
 
-### 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,
-    });
-  }
-}
-```
+### 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
 
 ## Security Standards
 
 ### Authentication & Authorization
-- JWT tokens with proper expiration
-- Role-based access control (RBAC)
-- Input validation on all endpoints
-- Rate limiting for public endpoints
-- HTTPS only in production
+- **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
 
 ### Data Protection
-- Encrypt sensitive data at rest
-- Use environment variables for secrets
-- Implement audit logging
-- Regular security updates
-- OWASP compliance
+- 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
 
 ## Performance Standards
 
 ### Database Optimization
-- Proper indexing strategies
-- Connection pooling
-- Query optimization
-- Pagination for large datasets
-- Database monitoring
+- 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
 
 ### Caching Strategy
-- Redis for session data
-- Application-level caching
-- HTTP caching headers
-- CDN for static assets
-- Cache invalidation patterns
+- **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
 
-## MonoRepo Organization
+## Error Handling
 
-### 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
-```
+### 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
 
-### 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
+### Error Response Format
+```typescript
+{
+  "statusCode": 400,
+  "message": "User with email already exists",
+  "error": "UserAlreadyExistsException",
+  "timestamp": "2024-01-15T10:30:00Z",
+  "path": "/api/users"
+}
+```

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

@@ -0,0 +1,81 @@
+# 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

package/claude/settings.local.json

@@ -16,41 +16,5 @@
     ],
     "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-dev.1",
+  "version": "2.1.26",
   "description": "Paquete para instalar y configurar agentes SIESA en tu proyecto",
   "main": "index.js",
   "bin": {

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

@@ -1,51 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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