@ds9-solutions/mcp 0.1.0 → 0.3.0

package/content/skills/dart-frog/examples/route_test.dart

@@ -0,0 +1,33 @@
+// Caminho: test/routes/api/orders/index_test.dart
+// Rota testada como função, com RequestContext mockado; sempre cobre o 405.
+import 'dart:io';
+
+import 'package:dart_frog/dart_frog.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+import '../../../../routes/api/orders/index.dart' as route;
+import 'package:my_api/common/middleware/auth_middleware.dart';
+import 'package:my_api/orders/adapter/controllers/order_controller.dart';
+
+class _MockRequestContext extends Mock implements RequestContext {}
+
+class _MockOrderController extends Mock implements OrderController {}
+
+void main() {
+  late _MockRequestContext context;
+
+  setUp(() {
+    context = _MockRequestContext();
+    when(() => context.read<OrderController>()).thenReturn(_MockOrderController());
+    when(() => context.read<AuthenticatedUser>()).thenReturn(const AuthenticatedUser(id: 'u1'));
+  });
+
+  test('retorna 405 para método não suportado', () async {
+    when(() => context.request).thenReturn(Request.delete(Uri.parse('http://localhost/api/orders')));
+
+    final response = await route.onRequest(context);
+
+    expect(response.statusCode, equals(HttpStatus.methodNotAllowed));
+  });
+}

package/content/skills/dart-frog/examples/service.dart

@@ -0,0 +1,51 @@
+// Caminho: lib/orders/domain/services/order_service.dart
+import 'dart:io';
+
+import 'package:fpdart/fpdart.dart';
+
+import '../../../common/exception/exceptions.dart';
+import '../models/order.dart';
+import '../ports/order_repository_port.dart';
+
+/// Regras de negócio de pedidos.
+class OrderService {
+  /// Cria o serviço com o [_repository] injetado pelo middleware.
+  const OrderService(this._repository);
+
+  final OrderRepositoryPort _repository;
+
+  /// Busca o pedido [id] e garante que pertence a [requesterId].
+  TaskEither<BusinessException, Order> getOwnedById({
+    required String id,
+    required String requesterId,
+  }) {
+    return _repository.findById(id).flatMap((order) {
+      if (order == null) return TaskEither.left(_failure(HttpStatus.notFound, 'Pedido não encontrado.'));
+      if (order.ownerId != requesterId) {
+        return TaskEither.left(_failure(HttpStatus.forbidden, 'Acesso negado.'));
+      }
+      return TaskEither.right(order);
+    });
+  }
+
+  /// Cria um pedido para [ownerId]; rejeita [total] não positivo.
+  TaskEither<BusinessException, Order> create({
+    required String ownerId,
+    required double total,
+  }) {
+    if (total <= 0) {
+      return TaskEither.left(_failure(HttpStatus.badRequest, 'O total deve ser positivo.'));
+    }
+    return _repository.create(ownerId: ownerId, total: total);
+  }
+
+  BusinessException _failure(int statusCode, String message) {
+    return BusinessException(
+      domainName: 'order',
+      statusCode: statusCode,
+      message: message,
+      error: message,
+      stackTrace: StackTrace.current,
+    );
+  }
+}

package/content/skills/dart-frog/examples/service_test.dart

@@ -0,0 +1,55 @@
+// Caminho: test/orders/domain/services/order_service_test.dart
+// Service testado com fake do port, sem banco real.
+import 'dart:io';
+
+import 'package:fpdart/fpdart.dart';
+import 'package:test/test.dart';
+
+import 'package:my_api/common/exception/exceptions.dart';
+import 'package:my_api/orders/domain/models/order.dart';
+import 'package:my_api/orders/domain/ports/order_repository_port.dart';
+import 'package:my_api/orders/domain/services/order_service.dart';
+
+class _FakeRepository implements OrderRepositoryPort {
+  _FakeRepository(this.stored);
+
+  final Order? stored;
+
+  @override
+  TaskEither<BusinessException, Order?> findById(String id) => TaskEither.right(stored);
+
+  @override
+  TaskEither<BusinessException, Order> create({
+    required String ownerId,
+    required double total,
+  }) =>
+      TaskEither.right(Order(id: '1', ownerId: ownerId, total: total));
+}
+
+void main() {
+  group('OrderService.getOwnedById', () {
+    test('retorna Left 404 quando o pedido não existe', () async {
+      final service = OrderService(_FakeRepository(null));
+
+      final result = await service.getOwnedById(id: '1', requesterId: 'u1').run();
+
+      expect(result.getLeft().toNullable()?.statusCode, HttpStatus.notFound);
+    });
+
+    test('retorna Left 403 quando o pedido é de outro usuário', () async {
+      final service = OrderService(_FakeRepository(const Order(id: '1', ownerId: 'u2', total: 5)));
+
+      final result = await service.getOwnedById(id: '1', requesterId: 'u1').run();
+
+      expect(result.getLeft().toNullable()?.statusCode, HttpStatus.forbidden);
+    });
+
+    test('retorna Right quando o pedido pertence ao usuário', () async {
+      final service = OrderService(_FakeRepository(const Order(id: '1', ownerId: 'u1', total: 5)));
+
+      final result = await service.getOwnedById(id: '1', requesterId: 'u1').run();
+
+      expect(result.isRight(), isTrue);
+    });
+  });
+}

package/content/skills/dart-frog/references/checklist.md

@@ -0,0 +1,31 @@
+# Dart Frog — Checklist de review detalhado
+
+## Pré-requisitos
+- [ ] `dart_frog` e `fpdart` presentes no `pubspec.yaml` (senão, o usuário foi informado e autorizou a instalação).
+- [ ] Estrutura existente preservada; padrão aplicado ao código novo.
+
+## Inegociáveis
+- [ ] Contratos de port/service/repository/controller retornam `TaskEither`.
+- [ ] Operações que podem lançar usam `TaskEither.tryCatch`.
+- [ ] Toda rota termina o `switch` com `case _` → 405.
+- [ ] Dependências compostas só em `_middleware.dart` (`provider`/`context.read`).
+- [ ] `BusinessException`, `ClientException`, `MiddlewareException` nas camadas certas.
+- [ ] Domínio agnóstico de persistência (só ports).
+
+## Camadas
+- [ ] Rota fina; só a rota executa `.run()`.
+- [ ] Controller não acessa persistência nem tem regra de negócio.
+- [ ] Service sem HTTP, `RequestContext` ou SDK.
+- [ ] Repository sem regra de negócio; falhas convertidas em `BusinessException`.
+- [ ] Autorização de recurso no service, não no middleware.
+
+## Erros e segurança
+- [ ] Sem stack trace, SQL, `error` original ou mensagem de SDK na resposta.
+- [ ] Formato `{error:{code,message}}` único.
+- [ ] Segredos no ambiente; nada sensível em logs.
+- [ ] Papel/perfil do cliente nunca confiado sem validação no servidor.
+
+## Qualidade
+- [ ] Skill `dart` seguida (`///` nas declarações públicas, nomenclatura, OOP).
+- [ ] Arquivos gerados regenerados e não editados à mão.
+- [ ] Testes: service, controller, rota (com 405).

package/content/skills/dart-frog/references/error-handling.md

@@ -0,0 +1,48 @@
+# Dart Frog — Erros (referência)
+
+Complementa a seção 5 do `SKILL.md`. Exemplos: `examples/exceptions.dart`, `error_response.dart`.
+
+## Camadas fixas
+
+| Exceção | Quem lança (`Left`) | Campos |
+|---|---|---|
+| `BusinessException` | service, repository | `domainName`, `statusCode`, `message`, `error`, `stackTrace` |
+| `ClientException` | controller | `statusCode`, `message` |
+| `MiddlewareException` | middleware | `statusCode`, `message`, `stackTrace?` |
+
+- `message` é **sempre** segura para o cliente. `error` e `stackTrace` são só para log.
+- Ao converter entre camadas, preserve o `statusCode`. Para `5xx`, a mensagem ao cliente é genérica.
+- Não use `Exception` genérica como falha de `TaskEither`.
+
+## Status HTTP
+
+| Situação | Status |
+|---|---|
+| Entrada inválida, body malformado | 400 |
+| Não autenticado ou credencial inválida | 401 |
+| Autenticado sem permissão (ex.: recurso de outro usuário) | 403 |
+| Recurso inexistente | 404 |
+| Método não suportado | 405 |
+| Conflito de estado | 409 |
+| Falha interna ou de persistência | 500 |
+| Criação com sucesso | 201 |
+
+## Formato único
+
+```json
+{ "error": { "code": "not_found", "message": "Pedido não encontrado." } }
+```
+
+## Nunca
+
+- Enviar stack trace, SQL, causa original (`error`), caminhos, credenciais ou mensagens de SDK.
+- Devolver `f.error.toString()` ao cliente.
+- Capturar erro e responder sucesso vazio.
+- Logar tokens, documentos, e-mail, telefone ou conteúdo sensível completo.
+
+## Onde cada falha nasce
+
+- Formato de body/query/params: controller/DTO (`400`).
+- Regra de negócio e autorização de recurso: service (`403`/`404`/`409`).
+- Persistência ou integração: repository (`500`, com `error` original preservado).
+- Autenticação e rate limit: middleware (`401`/`429`).

package/content/skills/dart-frog/references/fpdart-taskeither.md

@@ -0,0 +1,53 @@
+# Dart Frog — `fpdart` e `TaskEither` (referência)
+
+Complementa a seção 4 do `SKILL.md`. Exemplos: `examples/repository.dart`, `service.dart`, `controller.dart`.
+
+## Pré-requisito: `fpdart` instalado
+
+1. Procure `fpdart` em `dependencies` no `pubspec.yaml`.
+2. Se não estiver, **informe que ele é obrigatório para seguir o padrão DS9** e peça autorização para instalar: `dart pub add fpdart`.
+3. Não gere código fora do padrão para contornar a ausência.
+
+## Regras
+
+- Todo contrato de camada que pode falhar retorna `TaskEither<Falha, T>`: `BusinessException` (port/service/repository), `ClientException` (controller).
+- Operação assíncrona que pode lançar vai dentro de `TaskEither.tryCatch(run, onError)`; `onError` converte a causa (`error`, `stackTrace`) na exceção da camada, sem perder a causa original.
+- Composição com `map`, `flatMap` e `mapLeft`. Regra violada: `TaskEither.left(...)`; sucesso: `TaskEither.right(...)`.
+- **Só a rota executa** (`.run()`), e usa `match` para produzir a `Response`.
+- Funções puras e sem I/O (validações locais, construtores, `toJson`) podem retornar valores comuns, ou `Either` quando houver falha de validação.
+- Proibido: `throw` que escape da camada, `catch (_)` amplo, `Exception` genérica como falha, falha convertida em sucesso vazio.
+
+## Padrões
+
+```dart
+// 1) Acesso externo (repository)
+TaskEither<BusinessException, Order?> findById(String id) => TaskEither.tryCatch(
+      () => _dataSource.read(id),
+      (error, stackTrace) => BusinessException(
+        domainName: 'order',
+        statusCode: HttpStatus.internalServerError,
+        message: 'Falha ao consultar o pedido.',
+        error: error,
+        stackTrace: stackTrace,
+      ),
+    );
+
+// 2) Regra de negócio (service)
+_repository.findById(id).flatMap(
+      (order) => order == null ? TaskEither.left(_notFound(id)) : TaskEither.right(order),
+    );
+
+// 3) Troca de camada de erro (controller)
+_service.getOwnedById(id: id, requesterId: userId).mapLeft(_toClient).map(OrderResponse.fromDomain);
+
+// 4) Execução (rota)
+final result = await controller.getById(id, user.id).run();
+return result.match(ErrorResponse.fromClient, (order) => Response.json(body: order.toJson()));
+```
+
+## Cuidados
+
+- Mantenha as cadeias legíveis: se passar de 3 ou 4 etapas, extraia métodos privados nomeados.
+- Não misture `Future` simples e `TaskEither` no mesmo contrato.
+- Teste `Left` e `Right` explicitamente (`result.isLeft()`, `result.getLeft()`, `result.getRight()`).
+- Esta é a exceção funcional aceita pela skill `dart`: vale só para os contratos entre camadas. O restante continua orientado a objetos.

package/content/skills/dart-frog/references/layers.md

@@ -0,0 +1,43 @@
+# Dart Frog — Responsabilidade por camada (referência)
+
+Complementa a seção 3 do `SKILL.md`. Exemplos: `examples/`.
+
+## Route (`routes/**`)
+
+Faz: `switch` no método HTTP, `context.read<Controller>()`, `.run()` do `TaskEither`, converte `Left`/`Right` em `Response`, `case _` com 405.
+Não faz: regra de negócio, query, SDK, instanciar dependência, ler body (isso é do controller).
+
+## Controller (`adapter/controllers`)
+
+Faz: lê body/query/path/providers do `RequestContext` recebido **por chamada**, converte para DTO e valida formato, chama o service, converte modelo → DTO, converte `BusinessException` em `ClientException`.
+Retorna `TaskEither<ClientException, T>`. Não acessa banco, não tem regra de negócio, não monta `Response`.
+O controller é um objeto **provido por middleware** com o service no construtor; o `RequestContext` entra como parâmetro dos métodos.
+
+## Service (`domain/services`)
+
+Faz: regras de negócio, autorização de domínio (ex.: o pedido pertence ao usuário), composição de ports com `flatMap`/`map`.
+Retorna `TaskEither<BusinessException, T>`. Recebe ports no construtor (`final`), não conhece HTTP, headers, `RequestContext`, SDK ou persistência, não instancia dependências.
+
+## Port (`domain/ports`)
+
+`abstract interface class` pequeno e focado. Assinaturas só com modelos de domínio e tipos simples (nunca DTO, `RequestContext`, `Response`, tipos de ORM ou SDK). Retorna `TaskEither<BusinessException, T>`.
+
+## Repository (`adapter/repository`)
+
+Implementa o port, acessa a persistência (via adapter/fonte de dados), mapeia linha → modelo, envolve cada acesso em `TaskEither.tryCatch` convertendo a causa em `BusinessException`. Sem regra de negócio ou de autorização. A tecnologia concreta é decidida pela skill de persistência do projeto.
+
+## DTO (`adapter/dtos`)
+
+Entrada: `fromJson` + `validate()` (formato). Saída: `fromDomain` + `toJson()`. Nome indica a operação (`CreateOrderRequest`, `OrderResponse`).
+
+## Model (`domain/models`)
+
+Classes imutáveis (`final`, `const`), sem conhecer DTO ou persistência. Invariantes validadas na criação quando possível.
+
+## Middleware
+
+Autentica, compõe providers, encerra com `MiddlewareException`. Não substitui a cadeia controller → service → repository nem contém regra de negócio.
+
+## Comunicação entre contextos
+
+Um contexto consome outro via port ou service público, nunca via repository concreto; sem dependência circular.

package/content/skills/dart-frog/references/middlewares-di.md

@@ -0,0 +1,45 @@
+# Dart Frog — Middlewares e injeção de dependência (referência)
+
+Complementa a seção 7 do `SKILL.md`. Exemplos: `examples/middleware_composition.dart`, `auth_middleware.dart`.
+
+## Regra
+
+A composição de dependências acontece **somente** em `routes/**/_middleware.dart`, com `provider<T>`; a leitura é `context.read<T>()`. Nunca instancie service, repository ou controller no handler, nem use service locator.
+
+## Um `_middleware.dart` por diretório
+
+Exporta `Handler middleware(Handler handler)` e vale para a pasta e subpastas. Encadeie com `handler.use(...)`.
+
+## Ordem de resolução
+
+A resolução é de baixo para cima: se `B` depende de `A`, declare `.use(B).use(A)`. Exemplo: controller → service → repository.
+
+## Cache
+
+`provider` é lazy e recria o valor a cada leitura. Para instâncias compartilhadas ou caras, faça cache em variável privada do arquivo: `_service ??= OrderService(...)`.
+
+## Distribuição por nível
+
+| Middleware | Provê |
+|---|---|
+| `routes/_middleware.dart` | CORS, infraestrutura compartilhada (conexão, configuração, rate limit) |
+| `routes/api/_middleware.dart` | autenticação, usuário autenticado |
+| `routes/admin/_middleware.dart` | autenticação + verificação de papel administrativo |
+| `routes/<grupo>/<recurso>/_middleware.dart` | controller/service/repository do recurso |
+
+Cada middleware específico provê só o necessário ao seu ramo.
+
+## Autenticação
+
+Middleware valida credenciais por um **port** (ex.: `TokenVerifierPort`), provê o usuário e encerra com `MiddlewareException` (`401`/`403`) quando inválido. Credenciais e chaves vêm do ambiente, nunca do código.
+
+## Proibido
+
+- Regra de negócio em middleware (inclusive verificar dono do recurso): isso é do service.
+- Ler parâmetro de caminho por posição (`pathSegments[n]`) em middleware: frágil e acoplado à URL. Receba o `id` na rota e valide no service.
+- `context.read` em models, ports, services e repositories.
+- Segundo ponto de composição fora de `_middleware.dart`.
+
+## Variáveis de ambiente
+
+Leia `Platform.environment` em um ponto único (`common/environment`) e proveja a configuração. `String.fromEnvironment` não funciona no Dart Frog.

package/content/skills/dart-frog/references/project-structure.md

@@ -0,0 +1,67 @@
+# Dart Frog — Estrutura de projeto (referência)
+
+Complementa a seção 2 do `SKILL.md`.
+
+## Árvore completa
+
+```text
+<projeto>/
+├── routes/
+│   ├── _middleware.dart              # raiz: CORS, infraestrutura compartilhada, rate limit
+│   ├── index.dart                    # GET /
+│   ├── public/                       # sem autenticação
+│   │   └── _middleware.dart
+│   ├── api/                          # usuários autenticados
+│   │   ├── _middleware.dart          # autenticação (provê o usuário)
+│   │   └── orders/
+│   │       ├── _middleware.dart      # composição do contexto
+│   │       ├── index.dart            # /api/orders
+│   │       └── [id].dart             # /api/orders/:id
+│   └── admin/                        # operações administrativas
+│       └── _middleware.dart          # autenticação + papel administrativo
+├── lib/
+│   ├── orders/                       # um contexto de negócio
+│   │   ├── domain/
+│   │   │   ├── models/               # entidades e valores
+│   │   │   ├── ports/                # contratos (abstract interface class)
+│   │   │   └── services/             # regras de negócio
+│   │   └── adapter/
+│   │       ├── controllers/          # HTTP -> domínio
+│   │       ├── dtos/                 # entrada e saída da API
+│   │       └── repository/           # domínio -> persistência
+│   └── common/
+│       ├── exception/                # BusinessException, ClientException, MiddlewareException
+│       ├── http/                     # formato de erro, helpers de resposta
+│       ├── middleware/               # auth, CORS, rate limit reutilizáveis
+│       ├── environment/              # leitura única de variáveis de ambiente
+│       ├── logger/
+│       └── models/                   # paginação e tipos compartilhados
+├── test/                             # espelha lib/ e routes/
+├── main.dart                         # só init() e run()
+├── pubspec.yaml
+└── analysis_options.yaml
+```
+
+## Variações permitidas
+
+- `application/use_case/` dentro de um contexto, **só** quando houver orquestração entre vários services/ports. Não crie por antecipação.
+- `adapter/<integração>/` (e-mail, mensageria, storage) para SDKs externos, sempre atrás de um port.
+- Infraestrutura de persistência compartilhada em `common/infra/` (detalhes na skill de persistência do projeto).
+- Não crie pasta `mappers/` por antecipação: o mapeamento fica no repository (linha → modelo) e no controller/DTO (modelo → DTO).
+
+## Nomenclatura de arquivos
+
+`snake_case.dart` com sufixo do papel: `_model`, `_dto`, `_service`, `_service_port`, `_repository`, `_repository_port`, `_controller`, `_middleware`, `_use_case`. Demais regras: skill `dart`.
+
+## Grupos de rota
+
+| Grupo | Pasta | Middleware |
+|---|---|---|
+| Base | `routes/index.dart` | raiz |
+| Pública | `routes/public/**` | rate limit, sem autenticação |
+| Autenticada | `routes/api/**` | autenticação, provê o usuário |
+| Administrativa | `routes/admin/**` | autenticação + papel administrativo |
+
+## Imports
+
+Dentro de `lib/`, use imports relativos (skill `dart`). Em `routes/`, `main.dart` e `test/` use `package:<nome_do_pacote>/...`.

package/content/skills/dart-frog/references/routing.md

@@ -0,0 +1,53 @@
+# Dart Frog — Rotas (referência)
+
+Complementa a seção 6 do `SKILL.md`. Exemplos: `examples/route_collection.dart`, `route_item.dart`.
+
+## Convenções do roteador
+
+- Uma rota = um arquivo em `routes/` que exporta `onRequest(RequestContext context, ...)`. `index.dart` mapeia para a pasta.
+- Rota dinâmica: `[id].dart` ou pasta `[id]/`; cada parâmetro vira argumento `String` posicional, na ordem do caminho.
+- Wildcard `[...rest].dart` deve ser o único arquivo da pasta.
+- Não coexistam `routes/api.dart` e `routes/api/index.dart` (conflito no build).
+- Handler assíncrono retorna `Future<Response>`.
+
+## 405 obrigatório
+
+Todo handler despacha por método e termina com o caso padrão:
+
+```dart
+switch (context.request.method) {
+  case HttpMethod.get:
+    // ...
+  case _:
+    return Response(statusCode: HttpStatus.methodNotAllowed);
+}
+```
+
+Rotas inexistentes (caminho não encontrado) são tratadas pelo próprio Dart Frog com 404; o 405 cobre método não suportado em uma rota existente.
+
+## Request e Response
+
+- O body só pode ser lido uma vez (`body()`, `json()` ou `formData()`); a leitura é do controller.
+- `json()` devolve `dynamic`: valide e converta para DTO tipado; payload inválido responde 400.
+- `formData()` lança `StateError` se o content-type não for de formulário: verifique antes.
+- Sucesso: `Response.json(body: ...)`; criação: `201`; use `HttpStatus` em vez de números.
+- Listagens mantêm o formato adotado pelo endpoint (lista direta ou objeto com dados e metadados).
+
+## Paginação
+
+Parâmetros `page` e `pageSize` na query, lidos no controller; o repository devolve itens, total, página e tamanho; o service só propaga. Defina um tipo compartilhado em `common/models` e mantenha o padrão em todos os endpoints.
+
+## CLI
+
+- `dart pub global activate dart_frog_cli` instala a CLI.
+- `dart_frog create <nome>`, `dart_frog dev` (hot reload; `--port`), `dart_frog build` (build de produção em `build/`, com Dockerfile).
+- `dart_frog new route "/caminho"` e `dart_frog new middleware "/caminho"`: prefira a CLI a criar à mão.
+- Versões da CLI e do pacote `dart_frog` devem ser compatíveis.
+
+## Estáticos
+
+Arquivos estáticos ficam em `public/` na raiz; não repita nomes existentes em `routes/`.
+
+## Ciclo de vida
+
+`main.dart` define só `init()` (execução única no start) e `run()` (entrypoint customizado; roda a cada hot reload). Não compõe services.

package/content/skills/dart-frog/references/testing.md

@@ -0,0 +1,24 @@
+# Dart Frog — Testes (referência)
+
+Complementa a seção 9 do `SKILL.md`. Exemplos: `examples/service_test.dart`, `route_test.dart`. Para criar e executar, use o agente `test-writer`.
+
+## Estrutura
+
+`test/` espelha `lib/` e `routes/` (ex.: `test/orders/domain/services/order_service_test.dart`, `test/routes/api/orders/index_test.dart`). Ferramentas: `package:test` e `package:mocktail`.
+
+## O que testar
+
+| Alvo | Como | Cobrir |
+|---|---|---|
+| Service | fake/mock do port, sem banco real | cada regra de negócio, `Left` com status correto e `Right` |
+| Controller | service mockado e `RequestContext` mockado | entrada válida, body inválido, validação, `Left`→`ClientException`, `Right` |
+| Repository | integração separada, quando houver persistência real | mapeamento e conversão de falha em `BusinessException` |
+| Rota | `RequestContext` mockado, handler como função | cada método suportado **e o 405** |
+| Middleware | `Handler` interno stubado | provê o valor; encerra com 401/403 |
+
+## Dicas
+
+- Mocke o `RequestContext` e faça stub de `context.request` (com `Request.get/post/delete` reais) e de `context.read<T>()`.
+- Verifique `Either` com `result.isLeft()`, `result.getLeft()`, `result.getRight()`.
+- Sem serviços externos reais em testes unitários.
+- Toda regra de negócio nova tem teste no service.

package/content/skills/docker/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: docker
-description: Diretrizes de containerização Docker para projetos NestJS/Node.js da DS9 — Dockerfile multi-stage, docker-compose para ambiente local, segurança de imagem e variáveis de ambiente. Use ao criar/revisar `Dockerfile`, `docker-compose.yml`, ou quando o usuário pedir "containerizar", "imagem Docker" ou "subir ambiente local".
+description: Diretrizes de containerização Docker para projetos Node.js da DS9 — Dockerfile multi-stage, docker-compose para ambiente local, segurança de imagem e variáveis de ambiente. Use ao criar/revisar `Dockerfile`, `docker-compose.yml`, ou quando o usuário pedir "containerizar", "imagem Docker" ou "subir ambiente local".
 ---
 
 # Docker — Diretrizes DS9
 
-Convenções para containerizar aplicações NestJS/Node.js e seus serviços de apoio (MySQL, etc.) nos projetos da empresa.
+Convenções para containerizar aplicações Node.js e seus serviços de apoio (MySQL, etc.) nos projetos da empresa.
 
 ## Dockerfile multi-stage (obrigatório)
 
@@ -42,7 +42,7 @@ Regras obrigatórias:
 
 ## Variáveis de ambiente e segredos
 
-- Nenhum segredo (senha de banco, JWT secret, API key) é copiado para dentro da imagem ou escrito em `ENV` no Dockerfile. Segredos entram em runtime via variáveis de ambiente/secret manager do orquestrador (ver skill `nestjs` para `ConfigService`).
+- Nenhum segredo (senha de banco, JWT secret, API key) é copiado para dentro da imagem ou escrito em `ENV` no Dockerfile. Segredos entram em runtime via variáveis de ambiente/secret manager do orquestrador (use o mecanismo de configuração do projeto).
 - `.env` usado em desenvolvimento local nunca é commitado (deve estar no `.gitignore`) nem copiado para a imagem (`.dockerignore`).
 - `docker-compose.yml` de desenvolvimento pode referenciar um `.env` local via `env_file`, mas o arquivo de exemplo versionado é `.env.example` sem valores reais.