@girardelli/architect-core 8.1.0

package/src/core/locales/en.ts

@@ -0,0 +1,340 @@
+import { AppTranslation } from './pt-BR.js';
+
+export const en: AppTranslation = {
+  // === CLI ===
+  cli: {
+    phases: {
+      scan: { label: 'FILE SCANNER', verb: 'Scanning filesystem' },
+      dependencies: { label: 'DEPENDENCY MAPPER', verb: 'Mapping import graph' },
+      layers: { label: 'LAYER DETECTOR', verb: 'Classifying architecture' },
+      antipatterns: { label: 'PATTERN ANALYZER', verb: 'Detecting anti-patterns' },
+      scoring: { label: 'QUALITY ENGINE', verb: 'Computing quality metrics' },
+      normalize: { label: 'PATH NORMALIZER', verb: 'Normalizing paths' },
+      summarize: { label: 'AI SUMMARIZER', verb: 'Generating project summary' }
+    },
+    results: {
+      score: 'ARCHITECTURE SCORE',
+      completedIn: 'Completed in',
+      files: 'files',
+      lines: 'lines',
+      anitpatterns: 'anti-patterns',
+      steps: 'steps',
+      agents: 'agents'
+    }
+  },
+
+  // === AGONTS OUTPUTS ===
+  agents: {
+    generatedBy: 'Generated by Architect v8.1',
+    backend: {
+      description: '{lang} Backend Developer — APIs, services, business logic',
+      title: '🔧 {lang} BACKEND DEVELOPER',
+      specialistIn: 'Backend specialist in {fw} for {projectName}',
+      stack: 'Stack',
+      language: 'Language',
+      framework: 'Framework',
+      architecture: 'Architecture',
+      test: 'Test Framework',
+      packageManager: 'Package Manager',
+      currentScore: 'Current Score',
+      domainContext: 'Domain & Business Context',
+      principles: 'Principles (SOLID + Clean Architecture)',
+      modules: 'Project Modules',
+      projectStructure: 'Project Structure (Detected)',
+      implementationRules: 'Implementation Rules',
+      implementationRulesBody: `□ Controller MUST NEVER contain business logic (routing only)
+□ Service MUST NEVER access Request/Response directly
+□ Entity MUST NEVER be exposed directly in API (use DTO)
+□ Input validation in DTO / Guard / Pipe
+□ Errors thrown with clear messages and correct HTTP status
+□ Structured logging (never console.log)
+□ Unit tests for every service method
+□ Integration tests for every endpoint
+□ Coverage ≥ {coverage}%`,
+      afterImplementation: 'After Backend Implementation',
+      afterImplementationBody: `> **MANDATORY: Generate Integration Document before proceeding to frontend/app.**
+
+Document must contain:
+- All created/modified endpoints
+- Request and response payloads (with examples)
+- Error codes and messages
+- Business rules applied
+- Required headers (auth, pagination, etc.)`
+    },
+    frontend: {
+      description: '{fw} Frontend Developer — Components, UX, state management',
+      title: '🎨 {fw} FRONTEND DEVELOPER',
+      specialistIn: 'Frontend specialist in {fw} for {projectName}',
+      prerequisites: 'Prerequisites for Implementation',
+      prerequisitesBody: `╔══════════════════════════════════════════════╗
+║  BEFORE writing any UI component:            ║
+║                                              ║
+║  □ MOCKUP approved by human                  ║
+║  □ Integration Document available            ║
+║  □ User stories with acceptance criteria     ║
+║  □ BDD scenarios written                     ║
+╚══════════════════════════════════════════════╝`,
+      implementationRules: 'Implementation Rules',
+      implementationRulesBody: `□ Component follows approved MOCKUP (do not invent UI)
+□ ALL UI states implemented:
+  - ✅ Data present (normal state)
+  - 📭 Empty state
+  - ⏳ Loading state (skeleton)
+  - ❌ Error state (with clear message)
+□ Business logic in services (NEVER in the component)
+□ Proper state management (no prop drilling)
+□ Forms with client-side validation
+□ Responsive layout (mobile + desktop)
+□ Basic accessibility (labels, aria, contrast)
+□ Lazy loading where applicable
+□ Coverage ≥ {coverage}%`
+    },
+    security: {
+      description: 'Security Auditor — Threat analysis, compliance, vulnerability scanning',
+      title: '🛡️ SECURITY AUDITOR',
+      analysisFor: 'Security Analysis for {projectName}',
+      checklist: 'OWASP Top 10 Checklist',
+      checklistBody: `□ A01: Broken Access Control — RBAC implemented?
+□ A02: Cryptographic Failures — Sensitive data encrypted?
+□ A03: Injection — Inputs sanitized? Parameterized queries?
+□ A04: Insecure Design — Threat modeling performed?
+□ A05: Security Misconfiguration — Secure headers, CORS?
+□ A06: Vulnerable Components — Dependencies updated?
+□ A07: Auth Failures — Brute-force protected? Session managed?
+□ A08: Software Integrity — Supply chain verified?
+□ A09: Logging Failures — Audit logs for sensitive actions?
+□ A10: SSRF — Server-side requests validated?`,
+      whenToActivate: 'When To Activate',
+      whenToActivateBody: `- Any feature handling: auth, personal data, payments
+- New public APIs
+- External system integrations
+- Infrastructure/Ops changes`,
+      expectedOutput: 'Expected Output',
+      expectedOutputBody: `1. Findings list with severity levels (CRITICAL/HIGH/MEDIUM/LOW)
+2. Mitigation recommendations
+3. Threat model (if applicable)`
+    },
+    qa: {
+      description: 'QA Test Engineer — Test planning, BDD/TDD, coverage analysis',
+      title: '🧪 QA TEST ENGINEER',
+      qualityFor: 'Test Quality mapping for {projectName}',
+      nonNegotiable: 'Non-Negotiable Targets',
+      nonNegotiableBody: `╔══════════════════════════════════════════╗
+║  Minimum Coverage: {coverage}%                ║
+║  No tests = no delivery, no completion   ║
+║  NON-NEGOTIABLE.                         ║
+╚══════════════════════════════════════════╝`,
+      pyramid: 'Testing Pyramid',
+      pyramidBody: `         ╱╲
+        ╱ E2E╲         → Few, slow, high value
+       ╱──────╲
+      ╱Integration╲    → Medium, validate integration
+     ╱──────────────╲
+    ╱   Unit Tests    ╲ → Many, fast, cheap
+   ╱════════════════════╲`,
+      process: 'Testing Process',
+      processBody: `1. **BDD first** — Gherkin scenarios before code
+2. **TDD** — RED → GREEN → REFACTOR
+3. **Coverage** — verify after each implementation
+4. **Regression** — ALL previous tests must pass
+5. **Review** — tests are reviewed alongside the code`,
+      refactoringRoadmap: 'Refactoring Roadmap'
+    },
+    techDebt: {
+      description: 'Tech Debt Controller — Technical debt backlog and score enforcement',
+      title: '📊 TECH DEBT CONTROLLER',
+      controlFor: 'Tech debt tracking for {projectName}',
+      currentState: 'Current State',
+      stateTable: `| Metric | Value |
+|---------|-------|
+| Score | {score}/100 |
+| Target | {target}/100 |
+| Anti-patterns | {antiPatterns} |
+| Pending Refactors | {refactoringSteps} |
+| Estimated Gain | +{improvement} points |`,
+      refactoringRoadmap: 'Refactoring Roadmap',
+      scoreTargets: 'Score Targets',
+      scoreTargetsBody: `Current Score:          {score}/100
+Short-Term Target:      {targetShort}/100
+Mid-Term Target:        {targetMedium}/100
+Minimum Acceptable:     {threshold}/100`,
+      rules: 'Enforcement Rules',
+      rulesBody: `□ Score MUST NEVER regress after a PR
+□ Minimum allowed: {threshold}/100
+□ Critical: resolve within 1 sprint
+□ High: resolve within 2 sprints
+□ Medium: add to technical backlog
+□ Verify using: architect score ./src`
+    },
+    codeReview: {
+      description: 'Code Review Checklist — Mandatory review points',
+      title: '🔍 CODE REVIEW CHECKLIST — {projectName}',
+      mandatoryRule: '**Every PR must be verified against this checklist.**',
+      mandatory: 'Mandatory',
+      mandatoryBody: `□ Code compiles without errors
+□ All tests pass
+□ Coverage ≥ {coverage}%
+□ Lint passes without errors
+□ No hardcoded secrets
+□ Score has not regressed`,
+      functional: 'Functional',
+      functionalBody: `□ Meets acceptance criteria
+□ Edge cases handled
+□ Errors handled appropriately
+□ Exisiting features not broken`,
+      quality: 'Quality',
+      qualityBody: `□ Code readable without explanatory comments
+□ Naming is descriptive and consistent
+□ Functions are small and focused
+□ No code duplication (DRY)
+□ Complex logic is isolated and tested
+□ No large commented out code blocks`,
+      domainReviewItems: 'Domain-Specific Review Items: {domain}',
+      domainRules: {
+        fintech: `□ Are transactions idempotent?
+□ Complete audit of all operations?
+□ No sensitive data exposed in logs?
+□ Monetary values use Decimal (no floats)?
+□ PCI-DSS compliance verified?`,
+        healthtech: `□ GDPR/LGPD compliance verified?
+□ Sensitive data encrypted at rest?
+□ Access audited and logged?
+□ Anonymization implemented correctly?
+□ 2FA for sensitive operations?`,
+        ecommerce: `□ Cart is idempotent?
+□ Inventory updated correctly (race conditions)?
+□ Prices validated (no client-side manipulation)?
+□ Coupons/discounts applied correctly?
+□ Fraud detection implemented?`,
+        default: `□ Critical business workflow intact?
+□ Rollback is safe?
+□ Concurrency handled?
+□ Final state is consistent?`
+      },
+      stackReviewItems: 'Language-Specific Checklist: {stack}',
+      stackRules: {
+        ts: `□ \`strict: true\` in tsconfig (no unjustified 'any')?
+□ Circular imports?
+□ Async/await handled (no unhandled promises)?
+□ Memory leaks (EventListeners unsubscribed)?
+□ Console.log/debugger removed?`,
+        python: `□ Type hints on all public functions?
+□ Docstrings formatted (Google or NumPy style)?
+□ No mutable default arguments?
+□ Context managers used for resources?
+□ F-strings instead of % or .format()?
+□ No \`eval()\` or \`exec()\`?`,
+        go: `□ Errors handled (not ignored with _)?
+□ Defer for cleanup?
+□ Goroutines with context?
+□ Race conditions tested?
+□ Timeouts implemented?`,
+        dart: `□ Null-safety (! avoided)?
+□ Widgets have keys in lists?
+□ BuildContext accessed only in build?
+□ Listeners unsubscribed?
+□ Images/assets load lazily?`,
+        default: `□ Code follows project standards?
+□ Dependencies updated?
+□ No compiler/linter warnings?`
+      },
+      integrationReviewItems: 'Integration Review Items',
+      integrationRulesBody: `□ Endpoint handles all expected status codes?
+□ Input payload validation?
+{auth}
+{validation}
+□ Response follows the documented contract?
+□ Errors return clear messages?
+□ Rate limiting applied?
+□ Structured logging?`
+    }
+  },
+
+  // === DYNAMIC BLOCKS ===
+  dynamic: {
+    compliance: {
+      title: 'Detected Compliance Requirements',
+      reason: 'Reason',
+      mandatoryChecks: 'Mandatory Checks'
+    },
+    integrations: {
+      title: 'Integration Security',
+      threats: 'Threats',
+      types: {
+        payment: 'PCI-DSS, sensitive data encryption, tokenization',
+        auth: 'MFA, session hijacking, credential stuffing',
+        api: 'Rate limiting, API key rotation, required HTTPS',
+        database: 'SQL Injection, Encryption at rest, Backups',
+        government: 'Regulatory compliance, audit trails, data retention',
+        default: 'Input/output validation, rate limiting'
+      }
+    },
+    domainThreats: {
+      title: 'Domain-Specific Threats: {domain}',
+      fintech: `- **Data Manipulation:** Transaction audits, checksums, encryption
+- **Unauthorized Access:** MFA on privileged accounts, IP whitelist
+- **Compliance:** PCI-DSS, LGPD/GDPR, SOX
+- **Fraud:** Anomaly detection, rate limiting`,
+      healthtech: `- **Data Leakage:** End-to-end encryption, anonymization
+- **HIPAA/GDPR:** Audit trails, explicit consent
+- **Integrity:** Digital signatures, blockchain if applicable
+- **Access:** Granular RBAC, 2FA for sensitive data`,
+      ecommerce: `- **Payment Fraud:** CVV validation, 3D Secure
+- **Data Theft:** SSL/TLS, PCI-DSS, encryption at rest
+- **DoS:** Rate limiting, CAPTCHA, WAF
+- **Auth:** MFA, session timeout`,
+      default: `- **Confidentiality:** Data encrypted in transit and at rest
+- **Integrity:** Input validation, checksums
+- **Availability:** Backup, disaster recovery, monitoring
+- **Auditing:** Logging sensitive actions, retention policy`
+    },
+    qaDomain: {
+      title: 'Domain-Specific Test Scenarios: {domain}',
+      fintech: `### Business Tests
+- Create transaction with valid amounts
+- Reject transaction above limit
+- Process refund correctly
+- Audit logging of all transactions
+- Validate balance after multiple operations
+
+### Security Tests
+- Do not expose card data in logs
+- Validate PCI-DSS compliance
+- Test fraud detection`,
+      healthtech: `### Business Tests
+- Create patient record with GDPR compliance
+- Validate consent before sharing data
+- Anonymize data correctly
+- Respect right to be forgotten
+- Audit access to sensitive data
+
+### Security Tests
+- E2E encryption at rest
+- Validate 2FA for critical data
+- Test data retention`,
+      ecommerce: `### Business Tests
+- Create cart with multiple products
+- Apply discount/coupon correctly
+- Process payment with 3DS validation
+- Update inventory after sale
+- Generate order with correct status
+
+### Security Tests
+- Do not expose card data
+- Validate rate limiting on checkout
+- Test fraud protection`,
+      default: `### Business Tests
+- Main flow (happy path)
+- Edge cases and boundaries
+- Concurrency (race conditions)
+- Rollback after error
+- Idempotency
+
+### Security Tests
+- Invalid/malicious inputs
+- Unauthorized access
+- Rate limiting
+- Proper logging`
+    }
+  }
+};

package/src/core/locales/pt-BR.ts

@@ -0,0 +1,341 @@
+export const ptBR = {
+  // === CLI ===
+  cli: {
+    phases: {
+      scan: { label: 'FILE SCANNER', verb: 'Escaneando sistema de arquivos' },
+      dependencies: { label: 'DEPENDENCY MAPPER', verb: 'Mapeando grafo de importações' },
+      layers: { label: 'LAYER DETECTOR', verb: 'Classificando arquitetura' },
+      antipatterns: { label: 'PATTERN ANALYZER', verb: 'Detectando anti-patterns' },
+      scoring: { label: 'QUALITY ENGINE', verb: 'Computando métricas de qualidade' },
+      normalize: { label: 'PATH NORMALIZER', verb: 'Normalizando paths' },
+      summarize: { label: 'AI SUMMARIZER', verb: 'Gerando sumário do projeto' }
+    },
+    results: {
+      score: 'ARCHITECTURE SCORE',
+      completedIn: 'Completado em',
+      files: 'arquivos',
+      lines: 'linhas',
+      anitpatterns: 'anti-patterns',
+      steps: 'passos',
+      agents: 'agentes'
+    }
+  },
+
+  // === AGONTS OUTPUTS ===
+  agents: {
+    generatedBy: 'Gerado por Architect v8.1',
+    backend: {
+      description: '{lang} Backend Developer — APIs, serviços, lógica de negócio',
+      title: '🔧 {lang} BACKEND DEVELOPER',
+      specialistIn: 'Especialista em backend {fw} para {projectName}',
+      stack: 'Stack',
+      language: 'Linguagem',
+      framework: 'Framework',
+      architecture: 'Arquitetura',
+      test: 'Teste',
+      packageManager: 'Package Manager',
+      currentScore: 'Score Atual',
+      domainContext: 'Domínio & Contexto de Negócio',
+      principles: 'Princípios (SOLID + Clean Architecture)',
+      modules: 'Módulos do Projeto',
+      projectStructure: 'Estrutura do Projeto (Detectada)',
+      implementationRules: 'Regras de Implementação',
+      implementationRulesBody: `□ Controller NUNCA contém lógica de negócio (apenas routing)
+□ Service NUNCA acessa Request/Response diretamente
+□ Entity NUNCA é exposta diretamente na API (usar DTO)
+□ Validação de input no DTO / Guard / Pipe
+□ Erros com mensagens claras e códigos HTTP corretos
+□ Logging estruturado (não console.log)
+□ Testes unitários para cada service method
+□ Testes de integração para cada endpoint
+□ Cobertura ≥ {coverage}%`,
+      afterImplementation: 'Após Implementação Backend',
+      afterImplementationBody: `> **OBRIGATÓRIO: Gerar Documento de Integração antes de qualquer frontend/app.**
+
+O documento deve conter:
+- Todos os endpoints criados/modificados
+- Payloads de request e response (com exemplos)
+- Códigos de erro e mensagens
+- Regras de negócio aplicadas
+- Headers necessários (auth, pagination, etc.)`
+    },
+    frontend: {
+      description: '{fw} Frontend Developer — Componentes, UX, state management',
+      title: '🎨 {fw} FRONTEND DEVELOPER',
+      specialistIn: 'Especialista em frontend {fw} para {projectName}',
+      prerequisites: 'Pré-Requisitos para Implementar',
+      prerequisitesBody: `╔══════════════════════════════════════════════╗
+║  ANTES de escrever qualquer componente:     ║
+║                                              ║
+║  □ MOCKUP aprovado pelo humano              ║
+║  □ Documento de Integração disponível       ║
+║  □ User stories com critérios de aceite     ║
+║  □ BDD scenarios escritos                   ║
+╚══════════════════════════════════════════════╝`,
+      implementationRules: 'Regras de Implementação',
+      implementationRulesBody: `□ Componente segue MOCKUP aprovado (não inventar UI)
+□ TODOS os estados implementados:
+  - ✅ Com dados (estado normal)
+  - 📭 Vazio (empty state)
+  - ⏳ Carregando (loading state / skeleton)
+  - ❌ Erro (error state com mensagem clara)
+□ Lógica de negócio em services (NUNCA no componente)
+□ State management adequado (sem prop drilling)
+□ Formulários com validação client-side
+□ Responsivo (testar mobile + desktop)
+□ Acessibilidade básica (labels, aria, contraste)
+□ Lazy loading onde aplicável
+□ Cobertura ≥ {coverage}%`
+    },
+    security: {
+      description: 'Security Auditor — Análise de ameaças, compliance, vulnerabilidades',
+      title: '🛡️ SECURITY AUDITOR',
+      analysisFor: 'Análise de segurança para {projectName}',
+      checklist: 'Checklist OWASP Top 10',
+      checklistBody: `□ A01: Broken Access Control — RBAC implementado?
+□ A02: Cryptographic Failures — Dados sensíveis criptografados?
+□ A03: Injection — Inputs sanitizados? Queries parametrizadas?
+□ A04: Insecure Design — Threat model feito?
+□ A05: Security Misconfiguration — Headers, CORS, defaults?
+□ A06: Vulnerable Components — Deps atualizadas?
+□ A07: Auth Failures — Brute force protegido? Session management?
+□ A08: Software Integrity — Supply chain verificado?
+□ A09: Logging Failures — Audit log para ações sensíveis?
+□ A10: SSRF — Server-side requests validados?`,
+      whenToActivate: 'Quando Ativar',
+      whenToActivateBody: `- Qualquer feature que lida com: autenticação, autorização, dados pessoais, pagamentos
+- Novas APIs públicas
+- Integrações com sistemas externos
+- Mudanças em infra/deploy`,
+      expectedOutput: 'Output Esperado',
+      expectedOutputBody: `1. Lista de findings com severidade (CRITICAL/HIGH/MEDIUM/LOW)
+2. Recomendações de mitigação
+3. Threat model (se aplicável)`
+    },
+    qa: {
+      description: 'QA Test Engineer — Planos de teste, BDD/TDD, cobertura',
+      title: '🧪 QA TEST ENGINEER',
+      qualityFor: 'Qualidade de testes para {projectName}',
+      nonNegotiable: 'Metas Inegociáveis',
+      nonNegotiableBody: `╔══════════════════════════════════════════╗
+║  Cobertura mínima: {coverage}%                ║
+║  Sem testes, sem entrega, sem finalizar  ║
+║  INEGOCIÁVEL.                            ║
+╚══════════════════════════════════════════╝`,
+      pyramid: 'Pirâmide de Testes',
+      pyramidBody: `         ╱╲
+        ╱ E2E╲         → Poucos, lentos, alto valor
+       ╱──────╲
+      ╱Integration╲    → Médio, validam integração
+     ╱──────────────╲
+    ╱   Unit Tests    ╲ → Muitos, rápidos, baratos
+   ╱════════════════════╲`,
+      process: 'Processo',
+      processBody: `1. **BDD primeiro** — cenários Gherkin antes de código
+2. **TDD** — RED → GREEN → REFACTOR
+3. **Coverage** — verificar após cada implementação
+4. **Regressão** — TODOS os testes antigos devem continuar passando
+5. **Review** — testes são revisados junto com código`,
+      refactoringRoadmap: 'Refactoring Roadmap'
+    },
+    techDebt: {
+      description: 'Tech Debt Controller — Controle de débito técnico e metas de score',
+      title: '📊 TECH DEBT CONTROLLER',
+      controlFor: 'Controle de débito técnico para {projectName}',
+      currentState: 'Estado Atual',
+      stateTable: `| Métrica | Valor |
+|---------|-------|
+| Score | {score}/100 |
+| Meta | {target}/100 |
+| Anti-patterns | {antiPatterns} |
+| Refatorações pendentes | {refactoringSteps} |
+| Estimativa de Melhora | +{improvement} pontos |`,
+      refactoringRoadmap: 'Roadmap de Refatoração',
+      scoreTargets: 'Metas de Score',
+      scoreTargetsBody: `Score Atual:            {score}/100
+Meta Curto Prazo:       {targetShort}/100
+Meta Médio Prazo:       {targetMedium}/100
+Mínimo Aceitável:       {threshold}/100`,
+      rules: 'Regras',
+      rulesBody: `□ Score NUNCA pode regredir após um PR
+□ Mínimo: {threshold}/100
+□ Críticos: resolver dentro de 1 sprint
+□ Altos: resolver dentro de 2 sprints
+□ Médios: adicionar ao backlog técnico
+□ Verificar com: architect score ./src`
+    },
+    codeReview: {
+      description: 'Code Review Checklist — Pontos obrigatórios de revisão',
+      title: '🔍 CODE REVIEW CHECKLIST — {projectName}',
+      mandatoryRule: '**Todo PR deve ser verificado contra este checklist.**',
+      mandatory: 'Obrigatório',
+      mandatoryBody: `□ Código compila sem erros
+□ Todos os testes passam
+□ Cobertura ≥ {coverage}%
+□ Lint sem errors
+□ Nenhum secret hardcoded
+□ Score não regrediu`,
+      functional: 'Funcional',
+      functionalBody: `□ Atende aos critérios de aceite
+□ Edge cases tratados
+□ Erros tratados adequadamente
+□ Não quebra features existentes`,
+      quality: 'Qualidade',
+      qualityBody: `□ Código legível sem comentários explicativos
+□ Naming descritivo e consistente
+□ Funções pequenas e com responsabilidade única
+□ Sem código duplicado (DRY)
+□ Lógica complexa está isolada em funções testáveis
+□ Sem grandes blocos de código comentado`,
+      domainReviewItems: 'Itens de Revisão Específicos do Domínio: {domain}',
+      domainRules: {
+        fintech: `□ Transações são idempotentes?
+□ Auditoria completa de todas as operações?
+□ Sem exposição de dados sensíveis em logs?
+□ Valores monetários não usam float (usar Decimal)?
+□ PCI-DSS compliance verificado?`,
+        healthtech: `□ LGPD compliance verificado (consentimento, retenção)?
+□ Dados sensíveis criptografados em repouso?
+□ Acesso auditado e logado?
+□ Anonimização implementada corretamente?
+□ 2FA em operações sensíveis?`,
+        ecommerce: `□ Carrinho é idempotente?
+□ Inventário é atualizado corretamente (race conditions)?
+□ Preços são validados (sem manipulação client-side)?
+□ Cupons/descontos aplicados corretamente?
+□ Fraude detection implementado?`,
+        default: `□ Fluxo crítico de negócio não quebrou?
+□ Rollback é seguro?
+□ Concorrência tratada?
+□ State final é consistente?`
+      },
+      stackReviewItems: 'Checklist Específico para {stack}',
+      stackRules: {
+        ts: `□ \`strict: true\` em tsconfig (sem any sem justificativa)?
+□ Imports circulares?
+□ Async/await tratado (sem unhandled promises)?
+□ Memory leaks (EventListeners desinscritos)?
+□ Console.log/debugger removidos?`,
+        python: `□ Type hints em todas as funções públicas?
+□ Docstrings formatadas (Google ou NumPy style)?
+□ Sem mutable default arguments?
+□ Context managers usados para resources?
+□ F-strings em vez de % ou .format()?
+□ Sem \`eval()\` ou \`exec()\`?`,
+        go: `□ Erros tratados (não ignorados com _)?
+□ Defer para cleanup?
+□ Goroutines com contexto?
+□ Race conditions testadas?
+□ Timeouts implementados?`,
+        dart: `□ Null-safety (! evitado)?
+□ Widgets têm keys quando em listas?
+□ BuildContext acessado apenas em build?
+□ Listeners desinscritos?
+□ Imagens/assets fazem lazy-load?`,
+        default: `□ Código segue padrões do projeto?
+□ Dependencies atualizadas?
+□ Sem warnings do compilador/linter?`
+      },
+      integrationReviewItems: 'Itens de Revisão de Integração',
+      integrationRulesBody: `□ Endpoint trata todos os status codes esperados?
+□ Validação do payload de entrada?
+{auth}
+{validation}
+□ Resposta segue o contrato documentado?
+□ Erros retornam mensagens claras?
+□ Rate limiting aplicado?
+□ Logging estruturado?`
+    }
+  },
+
+  // === DYNAMIC BLOCKS ===
+  dynamic: {
+    compliance: {
+      title: 'Requisitos de Compliance Detectados',
+      reason: 'Motivo',
+      mandatoryChecks: 'Verificações Obrigatórias'
+    },
+    integrations: {
+      title: 'Segurança em Integrações',
+      threats: 'Ameaças',
+      types: {
+        payment: 'PCI-DSS, criptografia de dados sensíveis, tokenização',
+        auth: 'MFA, session hijacking, credential stuffing',
+        api: 'Rate limiting, API key rotation, HTTPS obrigatório',
+        database: 'SQL Injection, Encryption at rest, Backups',
+        government: 'Compliance regulatório, audit trails, data retention',
+        default: 'Validação de entrada/saída, rate limiting'
+      }
+    },
+    domainThreats: {
+      title: 'Ameaças Específicas do Domínio: {domain}',
+      fintech: `- **Manipulação de dados:** Auditoria de transações, checksums, criptografia
+- **Acesso não autorizado:** MFA em contas privilégiadas, IP whitelist
+- **Conformidade:** PCI-DSS, LGPD, SOX
+- **Fraude:** Detecção de anomalias, rate limiting`,
+      healthtech: `- **Vazamento de dados:** Criptografia end-to-end, anonimização
+- **HIPAA/LGPD:** Audit trails, consentimento explícito
+- **Integridade:** Assinatura digital, blockchain se aplicável
+- **Acesso:** RBAC granular, 2FA para dados sensíveis`,
+      ecommerce: `- **Fraude de pagamento:** CVV validation, 3D Secure
+- **Roubo de dados:** SSL/TLS, PCI-DSS, criptografia em repouso
+- **DoS:** Rate limiting, CAPTCHA, WAF
+- **Autenticação:** MFA, session timeout`,
+      default: `- **Confidencialidade:** Dados em trânsito e repouso criptografados
+- **Integridade:** Validação de entrada, checksums
+- **Disponibilidade:** Backup, disaster recovery, monitoring
+- **Auditoria:** Logging de ações sensíveis, retention policy`
+    },
+    qaDomain: {
+      title: 'Cenários de Teste Específicos do Domínio: {domain}',
+      fintech: `### Testes de Negócio
+- Criar transação com valores válidos
+- Rejeitar transação acima do limite
+- Processar reembolso corretamente
+- Auditoria de todas as transações
+- Validar saldo após múltiplas operações
+
+### Testes de Segurança
+- Não expor dados de cartão em logs
+- Validar PCI-DSS compliance
+- Testar detecção de fraude`,
+      healthtech: `### Testes de Negócio
+- Criar registro de paciente com LGPD compliance
+- Validar consentimento antes de compartilhar dados
+- Anonimizar dados corretamente
+- Respeitar direito ao esquecimento
+- Auditoria de acesso a dados sensíveis
+
+### Testes de Segurança
+- Criptografia end-to-end em repouso
+- Validar 2FA para dados críticos
+- Testar retenção de dados`,
+      ecommerce: `### Testes de Negócio
+- Criar carrinho com múltiplos produtos
+- Aplicar desconto/cupom corretamente
+- Processar pagamento com validação 3DS
+- Atualizar inventário após venda
+- Gerar pedido com status correto
+
+### Testes de Segurança
+- Não expor dados de cartão
+- Validar rate limiting em checkout
+- Testar proteção contra fraud`,
+      default: `### Testes de Negócio
+- Fluxo principal (happy path)
+- Edge cases e limites
+- Concorrência (race conditions)
+- Rollback após erro
+- Idempotência
+
+### Testes de Segurança
+- Inputs inválidos/maliciosos
+- Acesso não autorizado
+- Rate limiting
+- Logging correto`
+    }
+  }
+};
+
+// Types mapped from ptBR structure
+export type AppTranslation = typeof ptBR;