siesa-agents 2.1.35 → 2.1.37

package/{bmad-core/data → _bmad/bmm/workflows/3-solutioning/create-architecture/data/company-standards}/technology-stack.md

@@ -1,235 +1,235 @@
-# Technology Stack
-
-## Frontend Stack
-
-### Framework
-- **Next.js 16** 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
-
-## Backend Stack
-
-### Core Framework & Language
-- **.NET 10**
-- **C# Minimal API** - Lightweight and modern API approach
-- **Entity Framework Core 10** - ORM for data access (matches .NET 10 version)
-- **FluentValidation** - Validation for models and DTOs
-- **linq2db** - Ultra-lightweight, high-performance ORM for complex optimized queries
-- **DynamicLinq** - Dynamic query construction from strings (runtime filters)
-- **LinqKit** - Composable and reusable LINQ expressions with type safety
-
-### ORM Strategy & When to Use Each Tool
-
-#### Entity Framework Core 10 (Primary ORM)
-**Use for:**
-- Standard CRUD operations
-- DDD entities with tracking (Aggregate Roots, Domain Events)
-- Simple to moderate queries
-- Queries that participate in aggregate lifecycle
-- Navigation properties and relationships
-- Change tracking scenarios
-
-#### linq2db
-**Ultra-lightweight ORM for maximum performance and SQL control**
-
-✔ **Use when:**
-- Need highly optimized complex queries
-- Advanced subqueries and complex projections
-- Multiple joins with dynamic conditions
-- Queries that EF Core cannot translate efficiently
-- Endpoints require extreme performance:
-  - Dashboards
-  - Analytics
-  - Fast transactional reports
-  - High data volumes
-- Microservice requires pure queries without tracking (linq2db operates naturally without tracking → faster)
-- EF Core generates inefficient SQL and you need alternatives without changing stack
-- Want SQL nearly as efficient as hand-written, but without explicit SQL
-
-🚫 **Do NOT use when:**
-- Need complete DDD entities (aggregate roots, tracking, events)
-- Query participates in aggregate lifecycle
-- Only need simple filters or trivial pagination
-
-#### DynamicLinq
-**Dynamic query generation from strings for runtime filters**
-
-✔ **Use when:**
-- Microservice offers dynamic filter system:
-  - Example: `?filter=Age > 30 AND Country == "CO"`
-  - Example: `?sort=Name desc`
-- Building simplified OData-style API without using OData
-- Generic queries over tables
-- Variable column searches
-- Data explorers or configurable grids
-- Want to avoid manually generating Expression Trees (DynamicLinq is much simpler)
-
-🚫 **Do NOT use when:**
-- Filters are fully controlled in code
-- Don't want to interpret expressions at runtime
-- Require strict security (DynamicLinq requires sanitization)
-- Need maximum performance (use LinqKit or linq2db instead)
-
-#### LinqKit
-**Composable dynamic predicates with type safety**
-
-✔ **Use when:**
-- Have complex business rules in queries
-- Composable predicates example:
-  ```csharp
-  IsActive
-  RequiresApproval
-  BelongsToOrganization(user.OrgId)
-  ```
-- Want dynamic filters with type safety (no strings → expressions)
-- Combine multiple expressions in a single `Where()`:
-  - Especially useful in DDD repositories with:
-    - Multiple criteria
-    - Conditional searches
-    - Reusable queries
-- Need EF Core to translate the resulting expression (LinqKit is 100% compatible with EF Core)
-- Want to enhance EF Core when it fails to compose complex expressions
-
-🚫 **Do NOT use when:**
-- Filters are extremely simple
-- Query is highly dynamic and text-based (use DynamicLinq)
-- Need maximum performance (use linq2db)
-
-### Architecture & Design Patterns
-- **TDD (Test-Driven Development)** - Test-driven development approach
-- **DDD (Domain-Driven Design)** - Domain-oriented design
-- **Clean Architecture** - Clean architecture with layer separation
-- **Microservices** - Distributed services architecture
-- **REST API** - Primary communication protocol
-
-### Database & Data Management
-- **PostgreSQL** - Primary relational database (mandatory)
-- **Database per Microservice** - Each microservice has its own isolated database
-- **Primary Keys UUID** - Universal unique identifiers for all entities
-- **EF Core 10 Migrations** - Entity Framework migrations package for schema version control
-
-### Testing
-- **xUnit** - Unit and integration testing framework
-- **EF Core 10 InMemory** - In-memory database for fast tests
-- **PostgreSQL Test Containers** - PostgreSQL containers for real integration tests
-
-### Additional Libraries
-- **QuestPDF** - PDF document generation
-- **DynamicLinq** - Dynamic LINQ query construction
-- **LinqKit** - LINQ expression composition
-
-### API Documentation
-- **Scalar** - Modern API documentation (DO NOT use Swagger)
-
-### Infrastructure & DevOps
-- **Docker Ready** - Containerized applications ready for deployment (production only)
-- **Local Development** - Without Docker, direct execution with dotnet CLI
-- **Multiculture** - Support for internationalization (i18n) and localization (l10n)
-
-## Backend Core Principles
-
-### Clean Architecture First
-Strict separation of:
-- Domain layer (Entities, Value Objects, Aggregates, Domain Services)
-- Application layer (Commands, Queries, DTOs, Interfaces)
-- Infrastructure layer (Repositories, EF Core, External Services)
-- Presentation layer (Minimal API Endpoints)
-
-### Domain-Driven Design
-Business logic drives architecture decisions
-
-### Test-Driven Development
-- Write tests before or alongside implementation
-- xUnit for all backend tests
-- High test coverage requirement
-
-### Microservices Isolation
-- Each service is independent
-- Own PostgreSQL database per service
-- No shared databases between services
-
-### UUID Primary Keys
-All entities must use UUIDs (Guid in C#) as primary keys for distributed system compatibility
-
-### Type Safety
-Leverage C# strong typing for compile-time safety
-
-### Security by Design
-Implement security at every layer
-
-### Docker for Production Only
-- Development: dotnet run locally
-- Production: Docker containers
+# Technology Stack
+
+## Frontend Stack
+
+### Framework
+- **Next.js 16** 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
+
+## Backend Stack
+
+### Core Framework & Language
+- **.NET 10**
+- **C# Minimal API** - Lightweight and modern API approach
+- **Entity Framework Core 10** - ORM for data access (matches .NET 10 version)
+- **FluentValidation** - Validation for models and DTOs
+- **linq2db** - Ultra-lightweight, high-performance ORM for complex optimized queries
+- **DynamicLinq** - Dynamic query construction from strings (runtime filters)
+- **LinqKit** - Composable and reusable LINQ expressions with type safety
+
+### ORM Strategy & When to Use Each Tool
+
+#### Entity Framework Core 10 (Primary ORM)
+**Use for:**
+- Standard CRUD operations
+- DDD entities with tracking (Aggregate Roots, Domain Events)
+- Simple to moderate queries
+- Queries that participate in aggregate lifecycle
+- Navigation properties and relationships
+- Change tracking scenarios
+
+#### linq2db
+**Ultra-lightweight ORM for maximum performance and SQL control**
+
+✔ **Use when:**
+- Need highly optimized complex queries
+- Advanced subqueries and complex projections
+- Multiple joins with dynamic conditions
+- Queries that EF Core cannot translate efficiently
+- Endpoints require extreme performance:
+  - Dashboards
+  - Analytics
+  - Fast transactional reports
+  - High data volumes
+- Microservice requires pure queries without tracking (linq2db operates naturally without tracking → faster)
+- EF Core generates inefficient SQL and you need alternatives without changing stack
+- Want SQL nearly as efficient as hand-written, but without explicit SQL
+
+🚫 **Do NOT use when:**
+- Need complete DDD entities (aggregate roots, tracking, events)
+- Query participates in aggregate lifecycle
+- Only need simple filters or trivial pagination
+
+#### DynamicLinq
+**Dynamic query generation from strings for runtime filters**
+
+✔ **Use when:**
+- Microservice offers dynamic filter system:
+  - Example: `?filter=Age > 30 AND Country == "CO"`
+  - Example: `?sort=Name desc`
+- Building simplified OData-style API without using OData
+- Generic queries over tables
+- Variable column searches
+- Data explorers or configurable grids
+- Want to avoid manually generating Expression Trees (DynamicLinq is much simpler)
+
+🚫 **Do NOT use when:**
+- Filters are fully controlled in code
+- Don't want to interpret expressions at runtime
+- Require strict security (DynamicLinq requires sanitization)
+- Need maximum performance (use LinqKit or linq2db instead)
+
+#### LinqKit
+**Composable dynamic predicates with type safety**
+
+✔ **Use when:**
+- Have complex business rules in queries
+- Composable predicates example:
+  ```csharp
+  IsActive
+  RequiresApproval
+  BelongsToOrganization(user.OrgId)
+  ```
+- Want dynamic filters with type safety (no strings → expressions)
+- Combine multiple expressions in a single `Where()`:
+  - Especially useful in DDD repositories with:
+    - Multiple criteria
+    - Conditional searches
+    - Reusable queries
+- Need EF Core to translate the resulting expression (LinqKit is 100% compatible with EF Core)
+- Want to enhance EF Core when it fails to compose complex expressions
+
+🚫 **Do NOT use when:**
+- Filters are extremely simple
+- Query is highly dynamic and text-based (use DynamicLinq)
+- Need maximum performance (use linq2db)
+
+### Architecture & Design Patterns
+- **TDD (Test-Driven Development)** - Test-driven development approach
+- **DDD (Domain-Driven Design)** - Domain-oriented design
+- **Clean Architecture** - Clean architecture with layer separation
+- **Microservices** - Distributed services architecture
+- **REST API** - Primary communication protocol
+
+### Database & Data Management
+- **PostgreSQL** - Primary relational database (mandatory)
+- **Database per Microservice** - Each microservice has its own isolated database
+- **Primary Keys UUID** - Universal unique identifiers for all entities
+- **EF Core 10 Migrations** - Entity Framework migrations package for schema version control
+
+### Testing
+- **xUnit** - Unit and integration testing framework
+- **EF Core 10 InMemory** - In-memory database for fast tests
+- **PostgreSQL Test Containers** - PostgreSQL containers for real integration tests
+
+### Additional Libraries
+- **QuestPDF** - PDF document generation
+- **DynamicLinq** - Dynamic LINQ query construction
+- **LinqKit** - LINQ expression composition
+
+### API Documentation
+- **Scalar** - Modern API documentation (DO NOT use Swagger)
+
+### Infrastructure & DevOps
+- **Docker Ready** - Containerized applications ready for deployment (production only)
+- **Local Development** - Without Docker, direct execution with dotnet CLI
+- **Multiculture** - Support for internationalization (i18n) and localization (l10n)
+
+## Backend Core Principles
+
+### Clean Architecture First
+Strict separation of:
+- Domain layer (Entities, Value Objects, Aggregates, Domain Services)
+- Application layer (Commands, Queries, DTOs, Interfaces)
+- Infrastructure layer (Repositories, EF Core, External Services)
+- Presentation layer (Minimal API Endpoints)
+
+### Domain-Driven Design
+Business logic drives architecture decisions
+
+### Test-Driven Development
+- Write tests before or alongside implementation
+- xUnit for all backend tests
+- High test coverage requirement
+
+### Microservices Isolation
+- Each service is independent
+- Own PostgreSQL database per service
+- No shared databases between services
+
+### UUID Primary Keys
+All entities must use UUIDs (Guid in C#) as primary keys for distributed system compatibility
+
+### Type Safety
+Leverage C# strong typing for compile-time safety
+
+### Security by Design
+Implement security at every layer
+
+### Docker for Production Only
+- Development: dotnet run locally
+- Production: Docker containers

package/_bmad/bmm/workflows/3-solutioning/create-architecture/data/domain-complexity.csv

@@ -0,0 +1,11 @@
+domain,signals,complexity_level,suggested_workflow,web_searches
+e_commerce,"shopping,cart,checkout,payment,products,store",medium,standard,"ecommerce architecture patterns, payment processing, inventory management"
+fintech,"banking,payment,trading,finance,money,investment",high,enhanced,"financial security, PCI compliance, trading algorithms, fraud detection"
+healthcare,"medical,diagnostic,clinical,patient,hospital,health",high,enhanced,"HIPAA compliance, medical data security, FDA regulations, health tech"
+social,"social network,community,users,friends,posts,sharing",high,advanced,"social graph algorithms, feed ranking, notification systems, privacy"
+education,"learning,course,student,teacher,training,academic",medium,standard,"LMS architecture, progress tracking, assessment systems, video streaming"
+productivity,"productivity,workflow,tasks,management,business,tools",medium,standard,"collaboration patterns, real-time editing, notification systems, integration"
+media,"content,media,video,audio,streaming,broadcast",high,advanced,"CDN architecture, video encoding, streaming protocols, content delivery"
+iot,"IoT,sensors,devices,embedded,smart,connected",high,advanced,"device communication, real-time data processing, edge computing, security"
+government,"government,civic,public,admin,policy,regulation",high,enhanced,"accessibility standards, security clearance, data privacy, audit trails"
+gaming,"game,gaming,multiplayer,real-time,interactive,entertainment",high,advanced,"real-time multiplayer, game engine architecture, matchmaking, leaderboards"

package/_bmad/bmm/workflows/3-solutioning/create-architecture/data/project-types.csv

@@ -0,0 +1,7 @@
+project_type,detection_signals,description,typical_starters
+web_app,"website,web application,browser,frontend,UI,interface",Web-based applications running in browsers,Next.js, Vite, Remix
+mobile_app,"mobile,iOS,Android,app,smartphone,tablet",Native mobile applications,React Native, Expo, Flutter
+api_backend,"API,REST,GraphQL,backend,service,microservice",Backend services and APIs,NestJS, Express, Fastify
+full_stack,"full-stack,complete,web+mobile,frontend+backend",Applications with both frontend and backend,T3 App, RedwoodJS, Blitz
+cli_tool,"CLI,command line,terminal,console,tool",Command-line interface tools,oclif, Commander, Caporal
+desktop_app,"desktop,Electron,Tauri,native app,macOS,Windows",Desktop applications,Electron, Tauri, Flutter Desktop

package/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-01-init.md

@@ -0,0 +1,166 @@
+# Step 1: Architecture Workflow Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between architectural peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on initialization and setup only - don't look ahead to future steps
+- 🚪 DETECT existing workflow state and handle continuation properly
+- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 💾 Initialize document and update frontmatter
+- 📖 Set up frontmatter `stepsCompleted: [1]` before loading next step
+- 🚫 FORBIDDEN to load next step until setup is complete
+
+## CONTEXT BOUNDARIES:
+
+- Variables from workflow.md are available in memory
+- Previous context = what's in output document + frontmatter
+- Don't assume knowledge from other steps
+- Input document discovery happens in this step
+
+## YOUR TASK:
+
+Initialize the Architecture workflow by detecting continuation state, discovering input documents, and setting up the document for collaborative architectural decision making.
+
+## INITIALIZATION SEQUENCE:
+
+### 1. Check for Existing Workflow
+
+First, check if the output document already exists:
+
+- Look for existing {planning_artifacts}/`*architecture*.md`
+- If exists, read the complete file(s) including frontmatter
+- If not exists, this is a fresh workflow
+
+### 2. Handle Continuation (If Document Exists)
+
+If the document exists and has frontmatter with `stepsCompleted`:
+
+- **STOP here** and load `./step-01b-continue.md` immediately
+- Do not proceed with any initialization tasks
+- Let step-01b handle the continuation logic
+
+### 3. Fresh Workflow Setup (If No Document)
+
+If no document exists or no `stepsCompleted` in frontmatter:
+
+#### A. Input Document Discovery
+
+Discover and load context documents using smart discovery. Documents can be in the following locations:
+- {planning_artifacts}/**
+- {output_folder}/**
+- {product_knowledge}/**
+- docs/**
+
+Also - when searching - documents can be a single markdown file, or a folder with an index and multiple files. For Example, if searching for `*foo*.md` and not found, also search for a folder called *foo*/index.md (which indicates sharded content)
+
+Try to discover the following:
+- Product Brief (`*brief*.md`)
+- Product Requirements Document (`*prd*.md`)
+- UX Design (`*ux-design*.md`) and other
+- Research Documents (`*research*.md`)
+- Project Documentation (generally multiple documents might be found for this in the `{product_knowledge}` or `docs` folder.)
+- Project Context (`**/project-context.md`)
+
+<critical>Confirm what you have found with the user, along with asking if the user wants to provide anything else. Only after this confirmation will you proceed to follow the loading rules</critical>
+
+**Loading Rules:**
+
+- Load ALL discovered files completely that the user confirmed or provided (no offset/limit)
+- If there is a project context, whatever is relevant should try to be biased in the remainder of this whole workflow process
+- For sharded folders, load ALL files to get complete picture, using the index first to potentially know the potential of each document
+- index.md is a guide to what's relevant whenever available
+- Track all successfully loaded files in frontmatter `inputDocuments` array
+
+#### A2. Load Company Standards (If Exist)
+
+Check for company standards at `{company_standards_path}`:
+
+- If directory exists, load ALL .md files from it
+- Set `workflowMode` = "strict" if standards found, else "discovery"
+- Report: "✅ Estándares corporativos cargados. Modo: ESTRICTO"
+
+#### B. Validate Required Inputs
+
+Before proceeding, verify we have the essential inputs:
+
+**PRD Validation:**
+
+- If no PRD found: "Architecture requires a PRD to work from. Please run the PRD workflow first or provide the PRD file path."
+- Do NOT proceed without PRD
+
+**Other Input that might exist:**
+
+- UX Spec: "Provides UI/UX architectural requirements"
+
+**UI Kit Validation (if frontend project):**
+
+- Check `{project-root}/package.json` for "siesa-ui-kit"
+- If NOT found: "⚠️ siesa-ui-kit no instalado. Ejecuta: npm i siesa-ui-kit"
+
+#### C. Create Initial Document
+
+Copy the template from `{installed_path}/architecture-decision-template.md` to `{planning_artifacts}/architecture.md`
+
+#### D. Complete Initialization and Report
+
+Complete setup and report to user:
+
+**Document Setup:**
+
+- Created: `{planning_artifacts}/architecture.md` from template
+- Initialized frontmatter with workflow state
+
+**Input Documents Discovered:**
+Report what was found:
+"Welcome {{user_name}}! I've set up your Architecture workspace for {{project_name}}.
+
+**Documents Found:**
+
+- PRD: {number of PRD files loaded or "None found - REQUIRED"}
+- UX Design: {number of UX files loaded or "None found"}
+- Research: {number of research files loaded or "None found"}
+- Project docs: {number of project files loaded or "None found"}
+- Project context: {project_context_rules count of rules for AI agents found}
+
+**Files loaded:** {list of specific file names or "No additional documents found"}
+
+Ready to begin architectural decision making. Do you have any other documents you'd like me to include?
+
+[C] Continue to project context analysis
+
+## SUCCESS METRICS:
+
+✅ Existing workflow detected and handed off to step-01b correctly
+✅ Fresh workflow initialized with template and frontmatter
+✅ Input documents discovered and loaded using sharded-first logic
+✅ All discovered files tracked in frontmatter `inputDocuments`
+✅ PRD requirement validated and communicated
+✅ User confirmed document setup and can proceed
+
+## FAILURE MODES:
+
+❌ Proceeding with fresh initialization when existing workflow exists
+❌ Not updating frontmatter with discovered input documents
+❌ Creating document without proper template
+❌ Not checking sharded folders first before whole files
+❌ Not reporting what documents were found to user
+❌ Proceeding without validating PRD requirement
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## NEXT STEP:
+
+After user selects [C] to continue, only after ensuring all the template output has been created, then load `./step-02-context.md` to analyze the project context and begin architectural decision making.
+
+Remember: Do NOT proceed to step-02 until user explicitly selects [C] from the menu and setup is confirmed!