maestro-bundle 1.6.0 → 1.8.0

package/README.md

@@ -1,48 +1,85 @@
 # maestro-bundle
 
-Um comando. Bundle instalado. Agente governado. [GitHub Spec Kit](https://github.com/github/spec-kit) configurado.
+Um comando. Bundle instalado. Agente governado. Zero vibing code.
 
 ```bash
 npx maestro-bundle ai-agents claude
 ```
 
-## O que faz
+## Filosofia: Sem spec, sem código
 
-1. Instala **AGENTS.md** + **skills** no formato correto do seu editor
-2. Cria **PRD.md** — template de requisitos para o analista/dev preencher
-3. Instala [LangChain Skills](https://github.com/langchain-ai/langchain-skills) (11 skills extras, apenas para `ai-agents`)
-4. Instala o [GitHub Spec Kit](https://github.com/github/spec-kit) (`specify-cli@v0.4.3`) no projeto
-5. Roda `specify init` que registra os commands `/speckit.*` no editor
-6. Integra o `constitution.md` do bundle com os princípios do projeto
+O maestro-bundle instala tudo que o agente AI precisa para trabalhar de forma **governada** — e a peça central disso é o [GitHub Spec Kit](https://github.com/github/spec-kit).
 
-O dev abre o editor e já tem skills do bundle + LangChain skills + `/speckit.specify` funcionando.
+O Spec Kit implementa **Specification-Driven Development (SDD)**: toda demanda — nova ou em andamento — precisa ter uma spec antes de qualquer linha de código. O agente é instruído a **recusar** implementar qualquer coisa que não tenha passado pelo fluxo:
 
-### Skills extras do LangChain (apenas bundle ai-agents)
+```
+/speckit.specify → /speckit.plan → /speckit.tasks → /speckit.implement
+```
 
-Quando você instala o bundle `ai-agents`, o CLI também instala automaticamente as 11 skills oficiais do LangChain:
+Isso elimina o "vibing code" — aquele padrão onde o dev abre o Cursor e sai codando sem planejamento, sem requisitos, sem spec. Com o bundle instalado, o agente AI vai parar e perguntar: "Cadê a spec?"
 
-| Skill | O que faz |
-|---|---|
-| `framework-selection` | Escolher entre LangChain, LangGraph ou Deep Agents |
-| `langchain-fundamentals` | Criar agentes com `create_agent`, tools, middleware |
-| `langchain-middleware` | Human-in-the-loop, custom middleware, output estruturado |
-| `langchain-rag` | RAG: document loaders, embeddings, vector stores |
-| `langchain-dependencies` | Pacotes, versões, instalação |
-| `langgraph-fundamentals` | StateGraph, nodes, edges, streaming |
-| `langgraph-persistence` | Checkpointers, Store, time travel |
-| `langgraph-human-in-the-loop` | Interrupts, aprovação humana, resume |
-| `deep-agents-core` | Criar Deep Agents, harness, SKILL.md format |
-| `deep-agents-memory` | Memória e persistência para Deep Agents |
-| `deep-agents-orchestration` | Subagentes, planning, HITL |
+## O que instala
+
+1. **AGENTS.md** + **skills** no formato correto do editor — padrões, convenções e capacidades do agente
+2. **PRD.md** — template de requisitos para o analista/dev preencher
+3. **GitHub Spec Kit** — `specify-cli` instalado + `specify init` executado no projeto, registrando os commands `/speckit.*` no editor
+4. **Constitution** — princípios do projeto integrados ao Spec Kit
+5. **LangChain Skills** — 11 skills oficiais extras (apenas para `ai-agents`)
+
+## Fluxo de trabalho
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  1. Dev instala o bundle                                │
+│     npx maestro-bundle ai-agents claude                 │
+│                                                         │
+│  2. Analista/dev preenche o PRD.md                      │
+│     (requisitos, user stories, API spec)                │
+│                                                         │
+│  3. Dev abre o editor e pede uma feature                │
+│     "Cria o endpoint de demands"                        │
+│                                                         │
+│  4. Agente PARA e inicia o fluxo SDD:                   │
+│     /speckit.specify → spec.md                          │
+│     /speckit.plan    → plan.md                          │
+│     /speckit.tasks   → tasks.md                         │
+│     /speckit.implement → código                         │
+│                                                         │
+│  5. Código é produzido seguindo:                        │
+│     - A spec (O QUE construir)                          │
+│     - O AGENTS.md (COMO construir)                      │
+│     - As skills (capacidades específicas)               │
+│     - O PRD.md (requisitos do produto)                  │
+└─────────────────────────────────────────────────────────┘
+```
+
+Se a demanda já está no meio (spec existe), o agente continua de onde parou. Se é bug fix simples, pode corrigir direto. Mas feature nova sem spec? Não rola.
 
-## AGENTS.md vs PRD.md
+## Arquivos do projeto: quem faz o quê
 
-| Arquivo | Quem escreve | O que contém | Para que serve |
+| Arquivo | Quem escreve | Quando | Para quê |
 |---|---|---|---|
-| **AGENTS.md** | Bundle (automático) | Stack, padrões, estrutura, convenções | Define COMO o agente trabalha |
-| **PRD.md** | Analista / Dev | User stories, requisitos, API spec, modelo de dados | Define O QUE deve ser construído |
+| **AGENTS.md** | Bundle (automático) | Na instalação | Define COMO o agente trabalha (stack, padrões, convenções) |
+| **PRD.md** | Analista / Dev | Antes de codar | Define O QUE construir (user stories, API spec, modelo de dados) |
+| **`.specify/specs/*/spec.md`** | Agente via `/speckit.specify` | Antes de cada feature | Especificação detalhada da feature |
+| **`.specify/specs/*/plan.md`** | Agente via `/speckit.plan` | Após spec | Plano técnico (arquitetura, decisões) |
+| **`.specify/specs/*/tasks.md`** | Agente via `/speckit.tasks` | Após plan | Tasks atômicas implementáveis |
+| **skills/** | Bundle (automático) | Na instalação | Capacidades que o agente carrega sob demanda |
 
-O `AGENTS.md` vem pronto no bundle. O `PRD.md` vem como template — o dev/analista preenche com os requisitos do projeto antes de começar a codar. O agente AI usa ambos como contexto.
+## Commands do Spec Kit disponíveis no editor
+
+Após instalar o bundle, estes commands funcionam direto no editor:
+
+| Command | Fase | O que faz |
+|---|---|---|
+| `/speckit.constitution` | Setup | Definir princípios e padrões do projeto |
+| `/speckit.specify` | Spec | Especificar O QUE construir e POR QUÊ |
+| `/speckit.plan` | Plan | Planejar arquitetura, stack, decisões técnicas |
+| `/speckit.tasks` | Tasks | Quebrar em tasks atômicas implementáveis |
+| `/speckit.implement` | Build | Executar todas as tasks seguindo o plano |
+| `/speckit.clarify` | (opcional) | Perguntas para desambiguar requisitos |
+| `/speckit.analyze` | (opcional) | Verificar consistência entre artefatos |
+| `/speckit.checklist` | (opcional) | Gerar checklists de qualidade |
 
 ## Editores suportados
 
@@ -74,6 +111,8 @@ $ npx maestro-bundle ai-agents claude
   Editor:  Claude Code
 
   ✔ Claude Code: AGENTS.md, CLAUDE.md → @AGENTS.md, 14 skills em .claude/skills/
+  ✔ PRD.md template instalado (preencha com os requisitos do produto)
+  ✔ 11 LangChain Skills instaladas
   ✔ 14 skills canônicas em skills/
   ✔ references/ pronto
   ✔ specify-cli v0.4.3 instalado
@@ -90,92 +129,83 @@ $ npx maestro-bundle ai-agents claude
     /speckit.implement     — Executar as tasks
 
   Próximo passo:
-    Abra o projeto no editor AI e use /speckit.specify para começar
+    1. Preencha o PRD.md com os requisitos do produto
+    2. Abra o projeto no editor AI
+    3. Use /speckit.specify para começar a primeira feature
 ```
 
-## Estrutura instalada por editor
+## Estrutura instalada
 
 ### Claude Code
-
 ```
 seu-projeto/
-├── CLAUDE.md                                  # @AGENTS.md (aponta pro AGENTS.md)
-├── AGENTS.md                                  # Define COMO o agente trabalha
-├── PRD.md                                     # Define O QUE construir (preencher!)
+├── CLAUDE.md                                  # @AGENTS.md
+├── AGENTS.md                                  # COMO o agente trabalha
+├── PRD.md                                     # O QUE construir (preencher!)
 ├── .claude/
 │   ├── skills/                                # Skills do bundle
 │   │   ├── rag-pipeline/SKILL.md
 │   │   ├── clean-architecture/SKILL.md
-│   │   ├── commit-pattern/SKILL.md
 │   │   └── ...
-│   └── commands/                              # Commands do Spec Kit (gerado pelo specify init)
-│       ├── speckit.constitution.md
+│   └── commands/                              # /speckit.* (gerado pelo Spec Kit)
 │       ├── speckit.specify.md
 │       ├── speckit.plan.md
 │       ├── speckit.tasks.md
 │       └── speckit.implement.md
-├── .specify/                                  # Spec Kit (templates, scripts, constitution)
-│   ├── memory/constitution.md
-│   ├── scripts/
-│   └── templates/
-├── skills/                                    # Skills canônicas (para Deep Agents)
-└── references/
+├── .specify/                                  # Spec Kit
+│   ├── memory/constitution.md                 # Princípios do projeto
+│   ├── scripts/                               # Scripts auxiliares
+│   ├── templates/                             # Templates para spec, plan, tasks
+│   └── specs/                                 # Specs das features (criadas via /speckit.specify)
+│       └── 001-feature-name/
+│           ├── spec.md
+│           ├── plan.md
+│           └── tasks.md
+├── skills/                                    # Skills canônicas (Deep Agents)
+└── references/                                # Docs de referência
 ```
 
 ### Cursor
-
 ```
 seu-projeto/
-├── AGENTS.md                                  # Define COMO o agente trabalha
-├── PRD.md                                     # Define O QUE construir (preencher!)
+├── AGENTS.md                                  # COMO o agente trabalha
+├── PRD.md                                     # O QUE construir (preencher!)
 ├── .cursor/
 │   ├── skills/                                # Skills do bundle
-│   │   ├── rag-pipeline/SKILL.md
-│   │   └── ...
-│   └── commands/                              # Commands do Spec Kit
-│       ├── speckit.specify.md
-│       └── ...
-├── .specify/
-├── skills/
+│   └── commands/                              # /speckit.* commands
+├── .specify/                                  # Spec Kit (specs, plans, tasks)
+├── skills/                                    # Skills canônicas
 └── references/
 ```
 
 ### OpenAI Codex
-
 ```
 seu-projeto/
-├── AGENTS.md                                  # Define COMO o agente trabalha
-├── PRD.md                                     # Define O QUE construir (preencher!)
-├── .agents/
-│   └── skills/                                # Commands do Spec Kit (como skills)
-│       ├── speckit-constitution/SKILL.md
-│       ├── speckit-specify/SKILL.md
-│       └── ...
-├── .specify/
+├── AGENTS.md                                  # COMO o agente trabalha
+├── PRD.md                                     # O QUE construir (preencher!)
+├── .agents/skills/                            # speckit-* skills
+├── .specify/                                  # Spec Kit
 ├── skills/                                    # Skills canônicas
 └── references/
 ```
 
-## GitHub Spec Kit — SDD no editor
+## Skills extras do LangChain (bundle ai-agents)
 
-O bundle instala automaticamente o [GitHub Spec Kit](https://github.com/github/spec-kit) no projeto. Isso significa que ao abrir o editor o dev já pode usar:
+O bundle `ai-agents` instala automaticamente as 11 skills oficiais do [LangChain](https://github.com/langchain-ai/langchain-skills):
 
-| Command | O que faz |
+| Skill | O que faz |
 |---|---|
-| `/speckit.constitution` | Definir princípios e padrões do projeto |
-| `/speckit.specify` | Especificar O QUE construir e POR QUÊ |
-| `/speckit.plan` | Planejar arquitetura, stack, decisões técnicas |
-| `/speckit.tasks` | Quebrar em tasks atômicas implementáveis |
-| `/speckit.implement` | Executar todas as tasks |
-| `/speckit.clarify` | Fazer perguntas para desambiguar requisitos |
-| `/speckit.analyze` | Verificar consistência entre artefatos |
-| `/speckit.checklist` | Gerar checklists de qualidade |
-
-O fluxo SDD garante que ninguém sai codando sem spec:
-
-```
-/speckit.specify → /speckit.plan → /speckit.tasks → /speckit.implement
-```
+| `framework-selection` | Escolher entre LangChain, LangGraph ou Deep Agents |
+| `langchain-fundamentals` | Criar agentes com `create_agent`, tools, middleware |
+| `langchain-middleware` | Human-in-the-loop, custom middleware, output estruturado |
+| `langchain-rag` | RAG: document loaders, embeddings, vector stores |
+| `langchain-dependencies` | Pacotes, versões, instalação |
+| `langgraph-fundamentals` | StateGraph, nodes, edges, streaming |
+| `langgraph-persistence` | Checkpointers, Store, time travel |
+| `langgraph-human-in-the-loop` | Interrupts, aprovação humana, resume |
+| `deep-agents-core` | Criar Deep Agents, harness, SKILL.md format |
+| `deep-agents-memory` | Memória e persistência para Deep Agents |
+| `deep-agents-orchestration` | Subagentes, planning, HITL |
 
 ## Pré-requisitos
 
@@ -200,4 +230,5 @@ npx maestro-bundle --help
 
 - [AGENTS.md](https://agents.md/) — Padrão universal para instruções de agentes AI
 - [GitHub Spec Kit](https://github.com/github/spec-kit) — Specification-Driven Development
+- [LangChain Skills](https://github.com/langchain-ai/langchain-skills) — Skills oficiais LangChain
 - [Agent Skills](https://agentskills.io) — Padrão aberto para skills de agentes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maestro-bundle",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Instala bundles de governança para projetos com AI agents. Um comando, tudo configurado.",
   "bin": {
     "maestro-bundle": "./src/cli.mjs"

package/src/cli.mjs

@@ -33,6 +33,10 @@ const BUNDLES = {
     name: "Frontend SPA",
     desc: "React + TypeScript + Tailwind + Vite",
   },
+  "ai-agents-deep": {
+    name: "Deep Agent (tipo Claude Code)",
+    desc: "Python + Deep Agents SDK + LangGraph + Subagentes + Skills",
+  },
 };
 
 // ============================================================
@@ -321,8 +325,8 @@ async function main() {
   }
   spinner2.succeed(`${skills.length} skills canônicas em skills/`);
 
-  // 3. LangChain Skills (apenas para bundle ai-agents)
-  if (bundleName === "ai-agents") {
+  // 3. LangChain Skills (para bundles de AI)
+  if (bundleName === "ai-agents" || bundleName === "ai-agents-deep") {
     const spinnerLc = ora("Instalando LangChain Skills (langchain-ai/langchain-skills)").start();
     try {
       // Instalar todas as 11 skills do LangChain para o editor escolhido

package/templates/bundle-ai-agents/AGENTS.md

@@ -4,15 +4,12 @@ Você está construindo um sistema de agentes AI com orquestração, RAG e execu
 
 ## Specification-Driven Development (SDD)
 
-Este projeto usa **GitHub Spec Kit** para governança. Antes de implementar qualquer demanda:
+A regra fundamental de SDD está definida no bundle-base (AGENTS.md base) e é inegociável:
+**Sem spec, sem código. Sem exceção.** O agente deve recusar implementar qualquer demanda que
+não tenha passado pelo fluxo `/speckit.specify` → `/speckit.plan` → `/speckit.tasks` → `/speckit.implement`.
 
-1. Rodar `/speckit.constitution` — se `.spec/constitution.md` não existir
-2. Rodar `/speckit.specify` — descrever O QUE e POR QUÊ (não como)
-3. Rodar `/speckit.plan` — arquitetura e decisões técnicas
-4. Rodar `/speckit.tasks` — quebrar em tasks atômicas
-5. Rodar `/speckit.implement` — executar as tasks
-
-Nunca pular direto para código. Spec primeiro, código depois.
+Se o usuário pedir para codar algo sem spec, PARE e inicie o fluxo SDD primeiro.
+Consulte `.specify/specs/` para verificar se já existe spec para a demanda.
 
 ## Product Requirements Document
 

package/templates/bundle-ai-agents-deep/.spec/constitution.md

@@ -0,0 +1,24 @@
+# Constitution — Projeto Deep Agent
+
+## Princípios
+
+1. **Spec primeiro, código depois** — Toda demanda passa pelo fluxo SDD antes de implementação
+2. **Agent harness completo** — Todo Deep Agent tem: tools, system prompt, middleware, backend, checkpointer
+3. **Subagentes para isolamento** — Tarefas especializadas vão para subagentes, nunca bloat no main
+4. **Human-in-the-loop obrigatório** — Operações destrutivas sempre pedem aprovação
+5. **Skills on-demand** — Carregar conhecimento quando relevante, não no startup
+
+## Padrões de desenvolvimento
+
+- Python 3.11+, type hints, Black + Ruff
+- Tools com schemas Pydantic e descrições claras
+- System prompts versionados em código
+- Checkpointer obrigatório (MemorySaver dev, PostgresSaver prod)
+- Backend explícito (nunca confiar no StateBackend default em prod)
+
+## Padrões de qualidade
+
+- Evals com golden dataset antes de deploy
+- Middleware de logging em todo agente
+- Testes unitários para tools e middleware
+- Cobertura mínima: 80%

package/templates/bundle-ai-agents-deep/AGENTS.md

@@ -0,0 +1,105 @@
+# Projeto: Deep Agent (tipo Claude Code)
+
+Você está construindo um Deep Agent — um agente AI autônomo que pode planejar, executar tarefas, gerenciar arquivos, delegar para subagentes e interagir com o usuário. Similar ao Claude Code, Cursor Agent ou Codex. Construído com o framework Deep Agents do LangChain.
+
+## Specification-Driven Development (SDD)
+
+A regra fundamental de SDD está definida no bundle-base (AGENTS.md base) e é inegociável:
+**Sem spec, sem código. Sem exceção.** O agente deve recusar implementar qualquer demanda que
+não tenha passado pelo fluxo `/speckit.specify` → `/speckit.plan` → `/speckit.tasks` → `/speckit.implement`.
+
+Se o usuário pedir para codar algo sem spec, PARE e inicie o fluxo SDD primeiro.
+Consulte `.specify/specs/` para verificar se já existe spec para a demanda.
+
+## Product Requirements Document
+
+O arquivo `PRD.md` na raiz do projeto contém os requisitos do produto definidos pelo analista/dev. Consulte-o para entender O QUE construir. Este AGENTS.md define COMO o agente deve trabalhar; o PRD define O QUE deve ser construído.
+
+- `PRD.md` — Requisitos do produto, user stories, API spec, modelo de dados
+
+## Stack do projeto
+
+- **Linguagem:** Python 3.11+
+- **Framework:** Deep Agents SDK (`deepagents`)
+- **Execução:** LangGraph (por baixo)
+- **Modelos:** Claude (Anthropic), GPT (OpenAI), Gemini (Google), Ollama (local)
+- **Backends:** StateBackend, FilesystemBackend, StoreBackend, LocalShellBackend, Sandboxes
+- **API:** FastAPI (para servir o agente como API)
+- **Observabilidade:** LangSmith ou Langfuse
+- **Testes:** Pytest + evals customizados
+
+## Estrutura do projeto
+
+```
+src/
+├── agent/                      # Definição do Deep Agent principal
+│   ├── main.py                 # create_deep_agent + configuração
+│   ├── tools.py                # Tools customizadas
+│   ├── subagents.py            # Definição de subagentes
+│   ├── middleware.py            # Middleware customizado
+│   └── prompts.py              # System prompts versionados
+├── skills/                     # Skills que o agente pode carregar
+│   ├── code-review/SKILL.md
+│   ├── deploy/SKILL.md
+│   └── ...
+├── backends/                   # Configuração de backends
+│   ├── filesystem.py
+│   ├── store.py
+│   └── composite.py
+├── api/                        # Servir agente como API (opcional)
+│   ├── server.py               # FastAPI
+│   └── websocket.py            # Streaming via WebSocket
+├── evals/                      # Avaliação do agente
+│   ├── golden_dataset.json
+│   ├── evaluators.py
+│   └── run_evals.py
+└── config/
+    ├── settings.py
+    └── models.py
+```
+
+## Padrões de código
+
+- Máximo 500 linhas por arquivo, 20 linhas por função
+- Type hints em funções públicas
+- f-strings, Black + Ruff
+- Nomes descritivos, guard clauses
+- Tratar exceções com tipos específicos
+
+## Padrões de Deep Agent
+
+- System prompts versionados em `prompts.py`, nunca hardcoded
+- Tools com schemas Pydantic e descrições claras
+- Cada subagente tem UMA responsabilidade
+- Human-in-the-loop para operações destrutivas (delete, deploy, email)
+- Timeout e max_iterations em todo agente
+- Checkpointer obrigatório para persistência de estado
+- Backend explícito (nunca confiar no default em produção)
+- Skills carregadas on-demand, nunca todas no system prompt
+
+## Middleware obrigatório
+
+O Deep Agent já vem com middleware padrão que não deve ser desabilitado:
+- **TodoListMiddleware** — Planejamento de tarefas
+- **FilesystemMiddleware** — Gerenciamento de arquivos
+- **SubAgentMiddleware** — Delegação para subagentes
+- **SummarizationMiddleware** — Compressão de contexto
+
+## Git
+
+- Commits: `feat(agent): adicionar tool de busca semântica`
+- Branches: `feature/<componente>-<descricao>`
+- Nunca commitar API keys, .env
+
+## Testes
+
+- Testes unitários para tools e middleware
+- Testes de integração para o agente completo
+- Evals com golden dataset + LLM-as-judge
+- Cobertura mínima: 80%
+
+## References
+
+- `references/deep-agents-api.md` — API reference do Deep Agents SDK
+- `references/backends-guide.md` — Guia de backends e quando usar cada um
+- `references/middleware-guide.md` — Middleware padrão e customizado

package/templates/bundle-ai-agents-deep/PRD_TEMPLATE.md

@@ -0,0 +1,161 @@
+# Product Requirements Document (PRD)
+
+> Este documento define os requisitos do produto. Deve ser preenchido pelo analista de requisitos e/ou pelo dev antes de iniciar o desenvolvimento. O agente AI usa este documento como contexto para entender O QUE construir.
+
+## 1. Resumo Executivo
+
+<!-- Descreva em 2-3 frases o que é o produto e qual problema resolve -->
+
+## 2. Usuários Alvo
+
+<!-- Quem vai usar o sistema? Descreva as personas -->
+
+### Persona 1: [Nome]
+- **Perfil:**
+- **Objetivos:**
+- **Dores:**
+
+## 3. Escopo do MVP
+
+### Incluído no MVP
+- [ ] Feature 1
+- [ ] Feature 2
+- [ ] Feature 3
+
+### Fora do MVP (futuro)
+- [ ] Feature futura 1
+- [ ] Feature futura 2
+
+## 4. User Stories
+
+### US01: [Título]
+**Como** [persona], **quero** [ação], **para** [benefício].
+
+**Critérios de aceite:**
+- [ ] CA1:
+- [ ] CA2:
+
+### US02: [Título]
+**Como** [persona], **quero** [ação], **para** [benefício].
+
+**Critérios de aceite:**
+- [ ] CA1:
+- [ ] CA2:
+
+## 5. Arquitetura de Alto Nível
+
+<!-- Diagrama em Mermaid ou ASCII mostrando os componentes principais -->
+
+```mermaid
+graph LR
+    A[Frontend] --> B[API]
+    B --> C[Database]
+```
+
+### Estrutura de Diretórios
+
+```
+project/
+├── src/
+├── tests/
+└── ...
+```
+
+## 6. Features Detalhadas
+
+### Feature 1: [Nome]
+- **Descrição:**
+- **Regras de negócio:**
+  -
+- **Inputs:**
+- **Outputs:**
+- **Edge cases:**
+  -
+
+### Feature 2: [Nome]
+- **Descrição:**
+- **Regras de negócio:**
+  -
+
+## 7. Stack Tecnológica
+
+| Componente | Tecnologia | Justificativa |
+|---|---|---|
+| Backend | | |
+| Frontend | | |
+| Banco de dados | | |
+| Cache | | |
+| Deploy | | |
+
+## 8. API Specification
+
+### Endpoints
+
+#### `GET /api/v1/resource`
+- **Descrição:**
+- **Response:** `200 OK`
+```json
+{
+  "items": [],
+  "total": 0,
+  "page": 1,
+  "size": 20
+}
+```
+
+#### `POST /api/v1/resource`
+- **Descrição:**
+- **Body:**
+```json
+{
+  "field": "value"
+}
+```
+- **Response:** `201 Created`
+
+## 9. Modelo de Dados
+
+```sql
+CREATE TABLE example (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(100) NOT NULL,
+    created_at TIMESTAMP DEFAULT NOW()
+);
+```
+
+## 10. Requisitos Não-Funcionais
+
+| Requisito | Alvo | Prioridade |
+|---|---|---|
+| Performance | Response time < 500ms | Alta |
+| Disponibilidade | 99.9% uptime | Média |
+| Segurança | OWASP Top 10 | Alta |
+| Escalabilidade | Até X usuários simultâneos | Média |
+
+## 11. Fases de Implementação
+
+### Fase 1: Foundation
+- [ ] Setup do projeto
+- [ ] Modelo de dados
+- [ ] Endpoints básicos
+
+### Fase 2: Core Features
+- [ ] Feature 1 completa
+- [ ] Feature 2 completa
+
+### Fase 3: Polish
+- [ ] Testes E2E
+- [ ] Performance
+- [ ] Documentação
+
+## 12. Riscos e Mitigações
+
+| Risco | Impacto | Probabilidade | Mitigação |
+|---|---|---|---|
+| | | | |
+
+## 13. Critérios de Sucesso
+
+- [ ] Critério 1
+- [ ] Critério 2
+- [ ] Critério 3