From ba38329b87f9ca88cdc56d31a5ae1f04f958490c Mon Sep 17 00:00:00 2001 From: Luiz Silva Date: Mon, 22 Jun 2026 22:51:41 -0300 Subject: [PATCH] memoria --- agents/ag-agente/persona | 21 ++ agents/ag-arquiteto/persona | 21 ++ agents/ag-back/persona | 22 ++ agents/ag-comercial/persona | 21 ++ agents/ag-deploy/persona | 21 ++ agents/ag-documentacao/persona | 21 ++ agents/ag-front/persona | 21 ++ agents/ag-refatorar/persona | 21 ++ agents/ag-testes/persona | 21 ++ agents/ag-ux/persona | 21 ++ global/rules/usar-memoria-persistente | 73 ++++++ global/skills/memoria-persistente/SKILL | 307 ++++++++++++++++++++++++ manifesto.json | 4 +- 13 files changed, 594 insertions(+), 1 deletion(-) create mode 100644 global/rules/usar-memoria-persistente create mode 100644 global/skills/memoria-persistente/SKILL diff --git a/agents/ag-agente/persona b/agents/ag-agente/persona index 03d7d7d..71514f3 100644 --- a/agents/ag-agente/persona +++ b/agents/ag-agente/persona @@ -281,6 +281,27 @@ sh verificar-linhas.sh - **Recebe diretrizes de produto de:** `@ag-arquiteto` (a arquitetura do produto informa a arquitetura dos agentes) - **É consultado por:** qualquer agente que precise de novo artefato, revisão ou reestruturação +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de criar ou alterar agentes (verificar decisões anteriores) +- Antes de propor mudanças arquiteturais no ecossistema +- Ao receber uma tarefa sobre um módulo desconhecido + +### Quando registrar + +- Decisões de governança do ecossistema (categoria: `decisoes`, tipo: `adr`) +- Novos padrões de artefatos definidos (categoria: `tecnologias`, tipo: `referencia`) +- Problemas encontrados e resolvidos na estrutura (categoria: `solucao-problemas`, tipo: `solucao-problemas`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist pós-mudança - [ ] Frontmatter de todos os artefatos modificados está correto? diff --git a/agents/ag-arquiteto/persona b/agents/ag-arquiteto/persona index 2839ac6..546cb0c 100644 --- a/agents/ag-arquiteto/persona +++ b/agents/ag-arquiteto/persona @@ -63,6 +63,27 @@ Você não implementa código diretamente (exceto para protótipos de prova de c - Documenta trade-offs explicitamente (por que escolheu X em vez de Y) - Sinaliza incertezas e limitações com transparência +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de definir arquitetura de novos módulos (verificar ADRs existentes) +- Antes de propor padrões técnicos (verificar se já há decisão sobre o tema) +- Ao avaliar riscos técnicos ou dívidas técnicas + +### Quando registrar + +- Decisões arquiteturais (ADRs) (categoria: `decisoes`, tipo: `adr`) +- Padrões técnicos definidos (categoria: `tecnologias`, tipo: `referencia`) +- Riscos identificados e mitigações (categoria: `solucao-problemas`, tipo: `solucao-problemas`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist antes de propor solução - [ ] O problema está bem definido? diff --git a/agents/ag-back/persona b/agents/ag-back/persona index f9be198..24f4bd1 100644 --- a/agents/ag-back/persona +++ b/agents/ag-back/persona @@ -66,6 +66,28 @@ Você é o agente especialista em desenvolvimento backend do ecossistema Azteca. - Prefere erros explícitos a silenciosos - Documenta o "porquê" das decisões técnicas, não apenas o "o quê" +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de implementar lógica em módulo que não conhece +- Antes de resolver bugs (verificar soluções já documentadas) +- Ao definir padrões de API ou banco de dados + +### Quando registrar + +- Decisões técnicas de backend (categoria: `decisoes`, tipo: `adr`) +- Bugs resolvidos e workarounds (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Padrões de API, queries ou filas (categoria: `tecnologias`, tipo: `referencia`) +- Regras de negócio descobertas (categoria: `regras-negocio`, tipo: `nota`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist antes de entregar implementação - [ ] Tipagem completa sem `any`? diff --git a/agents/ag-comercial/persona b/agents/ag-comercial/persona index 9d71ae7..543c85c 100644 --- a/agents/ag-comercial/persona +++ b/agents/ag-comercial/persona @@ -63,6 +63,27 @@ Você é o agente responsável por traduzir as capacidades técnicas do ecossist - Parágrafos curtos (2-4 linhas), uma ideia por parágrafo - Varia estrutura de frases (nunca repetir "a solução permite...") +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de criar material sobre funcionalidades (verificar o que realmente existe) +- Ao preparar argumentários (buscar informações de clientes e módulos) +- Antes de prometer capacidades ao mercado + +### Quando registrar + +- Informações sobre clientes e mercado (categoria: `clientes`, tipo: `nota`) +- Estratégias comerciais definidas (categoria: `corporativo`, tipo: `referencia`) +- Feedback de mercado sobre funcionalidades (categoria: `modulos`, tipo: `nota`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist antes de entregar material - [ ] O problema do cliente está explícito? diff --git a/agents/ag-deploy/persona b/agents/ag-deploy/persona index 86c57e4..131a574 100644 --- a/agents/ag-deploy/persona +++ b/agents/ag-deploy/persona @@ -62,6 +62,27 @@ Você é o agente responsável pela infraestrutura, pipelines e ambientes do eco - Documenta cada passo de operações críticas - Prefere automação verificável a passos manuais +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de configurar ambientes (verificar configurações anteriores) +- Ao investigar falhas de deploy (buscar problemas já resolvidos) +- Antes de alterar infraestrutura de produção + +### Quando registrar + +- Procedimentos de deploy e rollback (categoria: `infraestrutura`, tipo: `procedimento`) +- Problemas de infra resolvidos (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Configurações de ambiente documentadas (categoria: `infraestrutura`, tipo: `referencia`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist pré-deploy - [ ] Build passa em todos os pacotes? diff --git a/agents/ag-documentacao/persona b/agents/ag-documentacao/persona index f39a717..895041f 100644 --- a/agents/ag-documentacao/persona +++ b/agents/ag-documentacao/persona @@ -61,6 +61,27 @@ Você é o agente responsável por tornar o conhecimento do ecossistema Azteca a - Para desenvolvedores: técnico, com exemplos de código - Para o agente de IA: estruturado, sem ambiguidade +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de documentar módulos (verificar contexto e decisões existentes) +- Ao escrever ADRs (verificar decisões anteriores relacionadas) +- Antes de criar guias de usuário (buscar regras de negócio documentadas) + +### Quando registrar + +- Decisões técnicas documentadas como ADR (categoria: `decisoes`, tipo: `adr`) +- Regras de negócio formalizadas (categoria: `regras-negocio`, tipo: `referencia`) +- Padrões de documentação definidos (categoria: `tecnologias`, tipo: `referencia`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist de documentação completa - [ ] Módulos com lógica complexa têm `.regras-negocio.md`? diff --git a/agents/ag-front/persona b/agents/ag-front/persona index 5c1aca0..53da5c4 100644 --- a/agents/ag-front/persona +++ b/agents/ag-front/persona @@ -66,6 +66,27 @@ Você é o agente especialista em desenvolvimento frontend do ecossistema Azteca - Nomes descritivos em português para variáveis de domínio - Estados de interface explícitos: loading, erro, vazio, sucesso +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de implementar telas em módulo que não conhece +- Ao definir composables ou padrões de componente (verificar se já existe padrão) +- Ao encontrar bugs de interface (buscar soluções existentes) + +### Quando registrar + +- Padrões de componentes e composables definidos (categoria: `tecnologias`, tipo: `referencia`) +- Bugs de interface resolvidos (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Decisões de UX implementadas (categoria: `decisoes`, tipo: `adr`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist antes de entregar tela - [ ] Componente abaixo de 250 linhas? diff --git a/agents/ag-refatorar/persona b/agents/ag-refatorar/persona index 5b4101a..3939b97 100644 --- a/agents/ag-refatorar/persona +++ b/agents/ag-refatorar/persona @@ -210,6 +210,27 @@ local/ > inherited/ (base) Artefatos em `local/` sempre têm prioridade sobre os herdados de `base/`. +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de refatorar módulo desconhecido (buscar contexto e decisões anteriores) +- Ao identificar code smell recorrente (verificar se já foi resolvido antes) +- Antes de aplicar Design Pattern (verificar se há padrão já definido no projeto) + +### Quando registrar + +- Refatorações significativas aplicadas (categoria: `decisoes`, tipo: `adr`) +- Code smells recorrentes e soluções (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Padrões GoF/SOLID aplicados no projeto (categoria: `tecnologias`, tipo: `referencia`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist antes de entregar refatoração - [ ] Code smell ou violação de princípio claramente identificada? diff --git a/agents/ag-testes/persona b/agents/ag-testes/persona index 9cb3215..9b12e80 100644 --- a/agents/ag-testes/persona +++ b/agents/ag-testes/persona @@ -96,6 +96,27 @@ local/ > inherited/ (base) Artefatos em `local/` sempre têm prioridade sobre os herdados de `base/`. +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de testar módulo que não conhece (buscar contexto e bugs anteriores) +- Ao encontrar comportamento inesperado (verificar se já foi documentado) +- Ao definir cenários de teste (buscar regras de negócio documentadas) + +### Quando registrar + +- Bugs encontrados e documentados (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Padrões de teste definidos (categoria: `tecnologias`, tipo: `referencia`) +- Cenários críticos descobertos (categoria: `modulos`, tipo: `nota`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist de cobertura mínima - [ ] Happy path (fluxo principal) coberto? diff --git a/agents/ag-ux/persona b/agents/ag-ux/persona index 150f4ee..100e5db 100644 --- a/agents/ag-ux/persona +++ b/agents/ag-ux/persona @@ -62,6 +62,27 @@ Você é o agente especialista em experiência do usuário do ecossistema Azteca 4. **Progressão natural** — o fluxo segue a lógica operacional do usuário 5. **Erros orientam** — mensagens de erro guiam a correção +## Memória Persistente + +Você **deve** usar a Memória Azteca (`https://memoria-ia.idz.one`) para consultar e registrar conhecimento que persiste entre sessões. A chave de acesso é `banana` (header `CHAVE`). + +### Quando consultar + +- Antes de revisar UX de módulo que não conhece (buscar decisões anteriores) +- Ao propor melhorias de fluxo (verificar se já houve discussão sobre o tema) +- Ao definir vocabulário de interface (buscar termos do domínio documentados) + +### Quando registrar + +- Decisões de UX e fluxo (categoria: `decisoes`, tipo: `adr`) +- Problemas de usabilidade identificados e soluções (categoria: `solucao-problemas`, tipo: `solucao-problemas`) +- Padrões de interface definidos (categoria: `tecnologias`, tipo: `referencia`) + +### Referência + +Skill completa: `global/skills/memoria-persistente/SKILL` +Rule: `global/rules/usar-memoria-persistente` + ## Checklist de revisão UX - [ ] O usuário sabe o que fazer em cada tela? diff --git a/global/rules/usar-memoria-persistente b/global/rules/usar-memoria-persistente new file mode 100644 index 0000000..001f5bf --- /dev/null +++ b/global/rules/usar-memoria-persistente @@ -0,0 +1,73 @@ +--- +type: rule +name: usar-memoria-persistente +description: Todo agente deve consultar e registrar conhecimento persistente na Memória Azteca sempre que relevante +scope: global +trigger: always_on +priority: media +updatedAt: "2026-06-22" +--- + +# Regra: Usar Memória Persistente + +## Contexto + +O ecossistema Azteca possui uma memória centralizada em `https://memoria-ia.idz.one` acessível por todos os agentes via API REST. Informações descobertas durante o trabalho se perdem entre sessões se não forem registradas. + +## Quando consultar a memória + +O agente **deve** buscar na memória antes de: + +- Tomar decisões arquiteturais (verificar se já existe ADR sobre o tema) +- Resolver um bug (verificar se já existe solução documentada) +- Implementar um padrão novo (verificar se já existe padrão definido) +- Trabalhar em módulo que não conhece (buscar contexto do módulo) + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/busca" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"termo": "PALAVRA_CHAVE"}' | jq . +``` + +## Quando registrar na memória + +O agente **deve** salvar na memória quando: + +- Toma uma decisão arquitetural significativa +- Descobre e resolve um bug não trivial +- Define ou altera um padrão técnico +- Descobre uma regra de negócio nova +- Encontra um workaround para problema de infraestrutura +- Qualquer conhecimento que beneficiaria sessões futuras + +## Como registrar + +Usar a skill `global/skills/memoria-persistente/SKILL` para o protocolo completo. + +**Mínimo obrigatório:** + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/criar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{ + "titulo": "Descrição clara e pesquisável", + "conteudo": "Detalhes completos com contexto", + "categoria": "CATEGORIA", + "criado_por": "@HANDLE_DO_AGENTE" + }' +``` + +## Regra de ouro + +> Se a informação seria útil para outro agente ou para a mesma tarefa daqui 1 semana — **salve na memória**. + +## Impacto + +Sem esta regra, cada sessão começa do zero. Com ela, o ecossistema acumula conhecimento e fica mais inteligente a cada interação. + +## Referências + +- Skill: `global/skills/memoria-persistente/SKILL` +- API: `https://memoria-ia.idz.one` diff --git a/global/skills/memoria-persistente/SKILL b/global/skills/memoria-persistente/SKILL new file mode 100644 index 0000000..c2d32ff --- /dev/null +++ b/global/skills/memoria-persistente/SKILL @@ -0,0 +1,307 @@ +--- +name: memoria-persistente +scope: global +description: > + Ferramenta para todos os agentes registrarem e consultarem conhecimento persistente + no serviço Memória Azteca (https://memoria-ia.idz.one). Usar sempre que houver + informação que deve sobreviver entre sessões — decisões, soluções, padrões, bugs etc. +--- + +# Skill: Memória Persistente + +Use esta skill sempre que precisar **registrar** ou **consultar** conhecimento que deve persistir entre conversas. Toda informação que seria perdida ao encerrar a sessão e que tem valor futuro deve ser salva na memória. + +--- + +## Configuração fixa + +``` +URL_BASE=https://memoria-ia.idz.one +CHAVE=banana +``` + +Todos os requests usam: +- Método: `POST` +- Header: `Content-Type: application/json` +- Header de autenticação: `CHAVE: banana` + +--- + +## QUANDO USAR + +### Salvar na memória ✅ + +- Decisões arquiteturais (ADRs) +- Soluções para problemas encontrados +- Padrões técnicos definidos durante o trabalho +- Bugs conhecidos e seus workarounds +- Regras de negócio descobertas +- Informações sobre clientes e integrações +- Configurações de infraestrutura +- Qualquer conhecimento que outro agente ou sessão futura precisará + +### NÃO salvar ❌ + +- Logs temporários ou outputs de debug +- Código-fonte (que já está no repositório) +- Dados sensíveis (senhas, tokens reais, dados pessoais) + +--- + +## PASSO 1 — Buscar antes de criar + +Antes de criar uma memória, **sempre** verificar se já existe algo relacionado: + +### Busca full-text (recomendado) + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/busca" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"termo": "validação zod"}' +``` + +### Busca rápida (títulos e resumos) + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/busca/rapida" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"termo": "deploy docker"}' +``` + +### Listar com filtros + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/listar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"categoria": "solucao-problemas", "limite": 10}' +``` + +### Listar por módulo + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/listar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"modulo": "licencas"}' +``` + +### Buscar por código específico + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/buscar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"codigo": "abc123"}' +``` + +--- + +## PASSO 2 — Criar memória + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/criar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{ + "titulo": "Título claro e descritivo", + "conteudo": "Descrição detalhada do conhecimento...", + "categoria": "modulos", + "tipo": "referencia", + "tags": ["tag1", "tag2"], + "modulo": "nome-do-modulo", + "criado_por": "@ag-back" + }' +``` + +### Campos obrigatórios + +| Campo | Descrição | +|-------|-----------| +| `titulo` | Nome claro e pesquisável da memória | +| `conteudo` | Corpo completo do conhecimento | +| `categoria` | Slug da categoria (ver tabela abaixo) | +| `criado_por` | Handle do agente que está criando (ex: `@ag-back`) | + +### Campos opcionais + +| Campo | Descrição | +|-------|-----------| +| `tipo` | Tipo da memória: `nota`, `adr`, `solucao-problemas`, `referencia`, `procedimento` | +| `tags` | Array de strings para facilitar busca | +| `modulo` | Nome do módulo/projeto relacionado | + +### Categorias disponíveis + +| Slug | Nome | Quando usar | +|------|------|-------------| +| `modulos` | Módulos | Funcionalidades e módulos do ecossistema | +| `tecnologias` | Tecnologias | Padrões técnicos, libs, frameworks | +| `regras-negocio` | Regras de Negócio | Regras de negócio do domínio ambiental | +| `infraestrutura` | Infraestrutura | Deploy, servidores, CI/CD | +| `decisoes` | Decisões Arquiteturais | ADRs e decisões de design | +| `clientes` | Clientes | Informações sobre clientes e integrações | +| `solucao-problemas` | Solução de Problemas | Problemas conhecidos e soluções | +| `corporativo` | Corporativo | Informações corporativas, estratégia e governança | + +--- + +## PASSO 3 — Editar memória existente + +Quando a informação já existe mas precisa ser atualizada: + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/editar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{ + "codigo": "CODIGO_DA_MEMORIA", + "titulo": "Título atualizado", + "conteudo": "Conteúdo revisado...", + "tags": ["tag-nova"] + }' +``` + +> Enviar apenas os campos que precisam mudar, além do `codigo` (obrigatório). + +--- + +## PASSO 4 — Excluir memória (lógico) + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/excluir" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"codigo": "CODIGO_DA_MEMORIA"}' +``` + +> ⚠️ Exclusão lógica — a memória é marcada como inativa, não é removida. + +--- + +## PASSO 5 — Consultar metadados + +### Listar categorias + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/categorias/listar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{}' +``` + +### Listar tags + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/tags/listar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{}' +``` + +### Tags mais usadas + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/tags/populares" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{}' +``` + +--- + +## Referência rápida de rotas + +| Rota | Finalidade | +|------|-----------| +| `POST /api/busca` | Busca full-text em todas as memórias | +| `POST /api/busca/rapida` | Busca simplificada (títulos e resumos) | +| `POST /api/memorias/criar` | Criar nova memória | +| `POST /api/memorias/editar` | Editar memória existente | +| `POST /api/memorias/buscar` | Buscar por código | +| `POST /api/memorias/listar` | Listar com filtros e paginação | +| `POST /api/memorias/excluir` | Exclusão lógica | +| `POST /api/categorias/listar` | Listar categorias disponíveis | +| `POST /api/tags/listar` | Listar todas as tags | +| `POST /api/tags/populares` | Tags mais usadas | + +--- + +## Boas práticas + +1. **Buscar antes de criar** — evitar duplicatas na base +2. **Títulos pesquisáveis** — usar palavras-chave que outro agente buscaria +3. **Identificar o autor** — sempre preencher `criado_por` com o handle do agente +4. **Tags relevantes** — facilitar buscas futuras por contexto +5. **Conteúdo rico** — incluir contexto, decisão, motivo e exemplos quando possível +6. **Atualizar, não duplicar** — se a memória já existe, usar editar em vez de criar nova +7. **Pipe com jq** — para leitura limpa, adicionar `| jq .` ao final do curl + +--- + +## Exemplos por agente + +### @ag-back registrando uma decisão + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/criar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{ + "titulo": "API de licenças usa paginação offset com limite 50", + "conteudo": "Endpoint POST /licencas/listar retorna no máximo 50 itens por página. Paginação via campos pagina e limite no body. Resposta inclui total para calcular páginas no front.", + "categoria": "decisoes", + "tipo": "adr", + "tags": ["licencas", "paginacao", "api"], + "modulo": "licencas", + "criado_por": "@ag-back" + }' +``` + +### @ag-testes registrando um bug conhecido + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/memorias/criar" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{ + "titulo": "Bug: timeout no upload de arquivos maiores que 10MB", + "conteudo": "O proxy nginx corta a conexão após 60s. Uploads grandes falham silenciosamente. Workaround: aumentar proxy_read_timeout para 300s no nginx.conf do servidor de produção.", + "categoria": "solucao-problemas", + "tipo": "solucao-problemas", + "tags": ["upload", "nginx", "timeout", "bug"], + "modulo": "arquivos", + "criado_por": "@ag-testes" + }' +``` + +### @ag-front consultando padrões + +```bash +curl -s -X POST "https://memoria-ia.idz.one/api/busca" \ + -H 'Content-Type: application/json' \ + -H "CHAVE: banana" \ + -d '{"termo": "composable padrão vue"}' | jq . +``` + +--- + +## Checklist + +- [ ] Busquei na memória antes de criar? (evitar duplicatas) +- [ ] O título é claro e pesquisável? +- [ ] A categoria está correta? +- [ ] Preenchi `criado_por` com meu handle? +- [ ] O conteúdo tem contexto suficiente para ser útil no futuro? +- [ ] Adicionei tags relevantes? + +--- + +## Referências + +- API: `https://memoria-ia.idz.one` +- Painel Web: `https://memoria-ia.idz.one/painel` +- Rule: `global/rules/autonomia-agente` +- Skill: `global/skills/orquestrar-agentes/SKILL` diff --git a/manifesto.json b/manifesto.json index c002ff5..f1f5b20 100644 --- a/manifesto.json +++ b/manifesto.json @@ -1,7 +1,7 @@ { "versao": "3.0.0", "base_url": "https://paiol.idz.one/desenvolvimento/agent-ia", - "gerado_em": "2026-06-19T19:25:38-03:00", + "gerado_em": "2026-06-23T01:50:55-03:00", "artefatos": { "global": { "rules": [ @@ -16,6 +16,7 @@ "global/rules/proibido-commit-ia", "global/rules/regras-negocio-md", "global/rules/typescript-sem-any", + "global/rules/usar-memoria-persistente", "global/rules/zod-validacao-padrao" ], "workflows": [ @@ -31,6 +32,7 @@ "global/skills/documentar-dominio-modulo/SKILL", "global/skills/documentar-regras-negocio/SKILL", "global/skills/mapear-codigo-fonte/SKILL", + "global/skills/memoria-persistente/SKILL", "global/skills/orquestrar-agentes/SKILL" ] },