sinapse-ai 1.12.2 → 1.14.0

package/.sinapse-ai/development/agents/analyst/MEMORY.md

@@ -32,3 +32,22 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+**Gates de pesquisa/análise com IA (KIT-ai-engineering):** saída de LLM é input NÃO confiável — valide grounding e cite a fonte de cada claim · separe fato de inferência · contexto curado por pergunta, o crítico nas bordas · não complete de memória o que o retrieval não trouxe (marque lacuna).
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/architect/MEMORY.md

@@ -37,3 +37,55 @@
 ## Archived
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
+
+## Municao: Engenharia de Software (kit Fase 4)
+
+Fonte completa: `engenharia-software/fase-4-agents/` (KIT-architect, KIT-orquestrador, KIT-fundamentos-transversal) — repo github `caioimori/engenharia-de-software`. Esta secao e o destilado; consulte o kit pro detalhe.
+
+### Principios nao-negociaveis
+- **Tudo e trade-off (First Law).** Nunca "o melhor X"; sempre "X paga seu custo NESTE contexto porque..." (Richards & Ford, *Fundamentals of Software Architecture*).
+- **ASRs dirigem a estrutura, nao moda.** Top 3-7 atributos de qualidade, cada um como cenario mensuravel com SLO numerico (Bass/Clements/Kazman, SEI).
+- **Fronteira e linguistica (bounded context), nunca camada tecnica.** Mudanca de linguagem = boundary; duplicata de evento e pista, nao erro (Evans + Brandolini/EventStorming).
+- **Dependency Rule: dominio puro no nucleo;** DB/UI/framework/MCP/LLM sao detalhes na borda (R.C. Martin, *Clean Architecture*).
+- **Monolito modular primeiro;** distribua so o quantum com deploy/escala/time independentes + DevOps maduro — senao = distributed monolith (Newman, *Building Microservices*).
+- **Eventual por padrao em distribuido; ACID dentro do bounded context.** Outbox nunca dual-write; saga + compensacao + idempotencia; nunca 2PC default (*The Hard Parts*).
+- **Toda integracao externa:** timeout + circuit breaker + fallback; ACL valida output de LLM/API (Nygard, *Release It!*).
+- **ADR imutavel com consequencias NEGATIVAS + opcoes rejeitadas;** supersede, nunca edita (Nygard / MADR 4.0.0).
+- **Atributo critico vira fitness function no CI** (rules live in code) — Ford/Parsons/Kua, *Building Evolutionary Architectures*.
+- **Conway como design ativo:** topologia ANTES do enxame; carga cognitiva e o limite de fronteira; estrela nao malha (n(n-1)/2 persiste em tokens) — Conway + Skelton & Pais, *Team Topologies*.
+- **Agente = bounded context = interpretador eval/apply** sob leis de complexidade; delegue a algoritmo deterministico o que e exato e barato (Evans DDD Europe 2025 + SICP/CLRS).
+
+### Gates verificaveis (antes de Done)
+- [ ] Cynefin classificado (campo `complexity:` no artefato de decisao).
+- [ ] Cada boundary mapeia a um bounded context nomeado; zero fronteira por camada tecnica.
+- [ ] Monolito x distribuido justificado por ADR (quantum + DevOps maduro) ou default monolito.
+- [ ] ADR completo: Context, Options (incl. rejeitadas), Decision, Consequences com >=1 "Ruim:".
+- [ ] Cada ASR com `response measure`/SLO numerico (regex de unidade: ms, %, p\d+, req/s).
+- [ ] Dependency Rule verde no arch-linter (ArchUnit/dependency-cruiser); sem ciclos (`madge --circular` = 0).
+- [ ] 1 transacao = 1 agregado; refs entre agregados por ID.
+- [ ] Domain Events em PascalCase de negocio; zero "EntityUpdated"/"XxxChanged".
+- [ ] ACL presente em toda chamada externa (API/MCP/LLM); domain primitives validados por construcao.
+- [ ] Toda chamada externa com timeout + circuit breaker + fallback; write+publish via outbox; handlers idempotentes.
+- [ ] Fitness functions poucas, de alto sinal, verdes no CI; PR que muda boundary inclui ADR novo.
+- [ ] Fio de rastreabilidade intacto: outcome -> requisito(+fit criterion) -> ASR -> bounded context -> estilo -> ADR -> fitness function -> SLO.
+- [ ] (squad) Sem overlap de escopo entre agents; nao-stream-aligned < ~15%; handoff = contrato versionado valido; zero codinome/@agent/path interno no texto user-facing.
+
+### Loop operacional
+Loop mestre: Cynefin -> Entender(outcome+ASR) -> Modelar(bounded context) -> Escolher(estilo por trade-off) -> Avaliar(sensitivity/tradeoff points) -> Registrar(ADR) -> Proteger(fitness function) -> Validar(CI); cada gate bloqueia, loop evolutivo reentra quando o negocio muda. Detalhe + diagramas mermaid (L1-L7 e Loop mestre): `LOOPS-design-arquitetura-diagramas.md` e, pra squads, `LOOPS-onda-7-processo-pessoas-diagramas.md` (B1-B6).
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/data-engineer/MEMORY.md

@@ -31,3 +31,58 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Municao: Engenharia de Software (kit Fase 4)
+
+Fonte completa: `engenharia-software/fase-4-agents/KIT-data-engineer.md` (repo github caioimori/engenharia-de-software). Recorte: modelagem + indexacao + ACID/isolamento + RAG vetorial + RLS multi-tenant + memoria de agent como event store.
+
+### Principios nao-negociaveis
+- Independencia de dados: manipule relacoes declarativamente; o sistema decide storage/indice/caminho de acesso (Codd 1970).
+- ACID e contrato e cada letra custa; "C" (invariantes) e da aplicacao via constraint, nao do banco (Gray & Reuter; Kleppmann DDIA cap.7).
+- Isolamento e matriz anomalia x nivel, nao escada: SI e RR sao incomparaveis. Escolha o MENOR nivel que evita as anomalias relevantes (Berenson et al. 1995).
+- Os nomes do nivel mentem ("REPEATABLE READ" do Postgres = snapshot isolation) — verifique, nao assuma (Jepsen PostgreSQL).
+- Write skew (invariante de conjunto sob SI) exige protecao explicita: SSI, `FOR UPDATE` ou constraint (Ports & Grittner 2012 SSI).
+- Durabilidade vem do log (WAL antes do dado); COMMIT = fsync do registro de commit (Mohan et al. 1992, ARIES).
+- Modele pelas queries reais: BCNF por padrao, desnormaliza so com medicao; indexa colunas reais de WHERE/JOIN/ORDER BY (Ramakrishnan/Gehrke).
+- Cardinalidade domina o plano; `EXPLAIN ANALYZE` (plano real) e o arbitro (Leis et al., Join Order Benchmark).
+- Idempotencia via unique constraint + upsert em todo efeito colateral; exactly-once nao existe = at-least-once + idempotencia (Stripe/Brandur).
+- Memoria de agent = event store append-only + projecoes (CQRS); historico nunca sobrescrito. Isolamento por tenant via RLS. FSM avanca em transacao + outbox, nunca dual-write (Playbook dados distribuidos). PostgreSQL e default racional — sair dele exige necessidade medida.
+
+### Gates verificaveis (antes de Done)
+- [ ] PK/FK declaradas em toda tabela/relacao (`information_schema.table_constraints`, zero faltando).
+- [ ] Unique constraint em toda chave de idempotencia/dedup.
+- [ ] Sem over-indexing: nenhum indice maduro com `idx_scan = 0` (`pg_stat_user_indexes`).
+- [ ] Cada `BEGIN` com nivel de isolamento explicito e justificado (menor que evita as anomalias).
+- [ ] Write skew coberto: teste de concorrencia (duas txns paralelas) prova que o invariante nunca quebra.
+- [ ] Retry de `serialization_failure` (SQLSTATE 40001) com backoff nas txns serializable.
+- [ ] Transacoes curtas: nenhuma chamada de rede (HTTP/LLM) dentro de `BEGIN/COMMIT`.
+- [ ] `EXPLAIN ANALYZE` confirma `Index Scan` nas queries quentes (sem `Seq Scan` inesperado).
+- [ ] Zero N+1; keyset pagination (seek), nao `OFFSET` grande; sem `SELECT *` / result set sem LIMIT em caminho quente.
+- [ ] Migrations versionadas e reversiveis (`up`+`down`); backfill em lotes.
+- [ ] Backup + PITR com restore TESTADO (durabilidade nao testada nao existe).
+- [ ] RAG: filtro hibrido no banco com teste de vazamento cross-tenant = zero; recall@k real medido acima do limiar.
+- [ ] Idempotencia de tool mutante: mesma key 3x = efeito externo 1x (teste de integracao).
+- [ ] Event store append-only: replay reconstroi estado identico (teste de replay).
+- [ ] RLS ativo: query sem `tenant_id` correto retorna zero linhas (teste tenant A x B).
+- [ ] FSM + outbox sem dual-write: crash injetado entre escrita e publicacao nao perde evento.
+- [ ] ADR registrado pra toda escolha estrutural (engine, isolamento padrao, indice vetorial).
+
+### Loop operacional
+Entender (queries reais + invariantes) -> Modelar (BCNF, PK/FK, unique) -> Isolar (menor nivel; write skew -> SSI/lock + retry 40001) -> Indexar -> Provar (`EXPLAIN ANALYZE`, matar N+1) -> Migrar (versionada/reversivel) -> Especializar (RAG/event store/RLS/outbox) -> Verificar (rodar TODOS os gates ate verde) -> Registrar ADR + handoff (push/PR exclusivo do @devops). Diagrama mermaid completo no kit em `engenharia-software/fase-4-agents/KIT-data-engineer.md`.
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/developer/MEMORY.md

@@ -45,3 +45,56 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Municao: Engenharia de Software (kit Fase 4)
+
+> Fonte: kits completos em `engenharia-software/fase-4-agents/` (KIT-developer + KIT-fundamentos-transversal), repo github `caioimori/engenharia-de-software`. Aqui so o essencial — consulte o kit pro detalhe.
+
+### Principios nao-negociaveis
+- **Codigo e AST, nao string.** Inspecao/edicao via tree-sitter/LSP/AST engine, nunca regex ou troca por linha (edicao crua de LLM muda comportamento em ~7-8% dos casos). (Nystrom *Crafting Interpreters* / CODESTRUCT)
+- **Nenhuma mudanca sem rede verde.** Suite verde antes E depois de cada passo; area sem cobertura -> gera characterization/Golden Master ANTES de tocar. (Feathers *WELC* / Beck)
+- **Smell nomeado antes de refatorar.** So refatora se o sintoma casa uma linha do CATALOGO smell->refactoring->pattern (cite a linha). Sem smell, nao mexe. (Fowler/Martin)
+- **Two Hats.** Cada commit e SO refatoracao OU SO feature, jamais ambos. (Fowler *Refactoring* 2ª ed.)
+- **Passo atomico + reversao.** Um passo por vez; vermelho -> reverte e reduz (nunca empilha quebra). Mudanca grande -> Mikado. (Beck / Mikado Method)
+- **Complexidade cognitiva e o juiz, nao linhas.** Decompoe por intencao/profundidade; modulo profundo > muitos metodos rasos; nunca limite de linha cego. (Ousterhout *APoSD* / SonarSource)
+- **Pattern so com variacao concreta HOJE e abstracao deep (YAGNI).** Prefira idioma mais barato (funcao > classe). (Kerievsky / GoF / Norvig)
+- **Mock so de dependencia out-of-process compartilhada.** Dor no teste = sinal de design, nao desculpa pra mockar. Qualidade = mutation score, nao cobertura de linha. (Khorikov / PIT / Stryker)
+- **Nunca reescreve do zero em codigo com usuarios** -> Strangler Fig / Branch by Abstraction. (Fowler)
+- **Agente = interpretador eval/apply.** Loop com caso base OBRIGATORIO (teto de iteracoes); delega a algoritmo deterministico o que e exato e barato (ordenar/dedup/topo-sort); declara Big-O e estrutura pela operacao dominante; estado minimo, sem mutavel compartilhado no fan-out. (SICP / CLRS / Out of the Tar Pit)
+
+### Gates verificaveis (antes de Done)
+- [ ] Suite verde (pre E pos cada passo) — `npm test` exit 0
+- [ ] Characterization/Golden Master existe em area legada tocada
+- [ ] Behavior diff vazio (Golden Master byte-a-byte) apos refatoracao
+- [ ] Edicao AST-safe — arquivo parseia valido apos Rename/Move/Extract
+- [ ] Complexidade cognitiva <= 15 por funcao (sonarjs / ruff C901 / clippy)
+- [ ] Aninhamento <= 3 niveis (eslint max-depth)
+- [ ] Smell nomeado — refatoracao cita linha do CATALOGO
+- [ ] Two Hats no commit — sem misturar refactor + teste de comportamento novo
+- [ ] Mutation score incremental >= threshold no diff (Stryker / PIT / cargo-mutants)
+- [ ] Anti-overengineering — nenhuma interface de 1 impl especulativa, nenhum Singleton mutavel global
+- [ ] Output sintaticamente valido (codegen/DSL) — grammar-constrained + typecheck exit 0
+- [ ] 100% das tool-calls validadas por schema/gramatica antes de executar
+- [ ] Caso base alcancavel no loop (teto de iteracoes assertado)
+- [ ] Flakiness < 1% (suite rodada N vezes)
+- [ ] ADR registrado pra decisao de design nao-trivial
+
+### Loop operacional
+Entender (legado -> characterizar) -> design barato (comentario de interface antes) -> teste que falha pela razao certa -> implementacao minima que passa -> refatorar com rede (smell->refactoring->pattern, passos atomicos AST) -> gate de qualidade -> Done. Nunca avance com a barra vermelha. Diagramas L1-L12 + loop mestre em `LOOPS-craftsmanship-diagramas.md` (e `LOOPS-onda-6-fundamentos-linguagens-diagramas` pro eval/apply).
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/devops/MEMORY.md

@@ -38,3 +38,59 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Municao: Engenharia de Software (kit Fase 4)
+
+Kit completo em `engenharia-software/fase-4-agents/KIT-devops-sre.md` (repo github caioimori/engenharia-de-software). Padrao encarnado: DORA Elite + Google SRE — velocidade COM estabilidade. Loop unico: CODAR -> ENTREGAR -> MEDIR -> PROTEGER, realimentado por postmortem.
+
+### Principios nao-negociaveis
+- **Build once, promote everywhere** — um artefato versionado (hash identico) atravessa todos os ambientes; nunca rebuild por ambiente. (Humble & Farley, *Continuous Delivery*)
+- **Batch pequeno + trunk-based** — branch < 1 dia, integracao >= diaria; lotes pequenos = falhas baratas de reverter (mais critico sob codigo de IA). (Accelerate / DORA)
+- **Testes/scans sao gate, nao sugestao** — "pronto" = CI verde objetivo, nunca auto-avaliacao do LLM; suite vermelha bloqueia tudo. (*Continuous Delivery*)
+- **Error budget governa o ritmo** — orcamento ok -> acelera; estourou -> feature freeze (so P0/security). (Google SRE Book)
+- **SLO por Critical User Journey** — SLI = good_events/valid_events; latencia de sucesso separada da de erro. (SRE Workbook)
+- **Todo integration point nasce resiliente** — timeout finito + bulkhead + backoff com jitter (so se idempotente) + cap/retry-budget + idempotency key + backpressure + graceful degradation. Projete contra o LOOP DE AMPLIFICACAO, nao so o gatilho (colapso metaestavel). (Nygard *Release It!* / Bronson-Huang)
+- **A cauda manda** — em fan-out otimize p99/p999, nao a media; hedged request quando p95 estoura. (Dean & Barroso *Tail at Scale*)
+- **Meca antes de otimizar** — USE + drill-down (top->iostat->/proc/meminfo->dmesg, flame graph), classifique memory-bound vs compute-bound; nunca chute "vamos paralelizar". (Brendan Gregg *Systems Performance*)
+- **Durabilidade = fsync, nao write**; least privilege na execucao (seccomp+cgroups+drop caps, nunca root no host, io_uring bloqueado em sandbox hostil). (OSTEP / Saltzer-Schroeder)
+- **Supply chain e gate de 1a classe** — SBOM + assinatura Sigstore + provenance SLSA>=L2, verificado na admissao. (SLSA v1.1 / NIST SSDF)
+- **Postmortem blameless, causas multiplas** -> backlog + atualiza threat model; mitigar antes de diagnosticar. (Cook / SRE Book)
+- **Human-in-the-loop para acao destrutiva** (push --force, delete, deploy prod). (espelha safe-collaboration.md)
+
+### Gates verificaveis (antes de Done)
+- [ ] Branch curto (< 24h, sem long-lived) — `git log`/`git branch -a`
+- [ ] Codigo incompleto atras de feature flag com kill switch (grep confirma flag-guard)
+- [ ] Build-once: hash SHA-256 do artefato identico entre estagios
+- [ ] CI verde: exit 0 em build+unit+lint+type-check+secret scan+dep scan
+- [ ] Suite de testes verde (runner retorna 0 falhas)
+- [ ] Complexidade cognitiva <= 15 por funcao (linter)
+- [ ] Mutation score >= threshold (mutmut/stryker/PIT)
+- [ ] SCA: 0 CVE critico aberto (Trivy/Grype/Snyk)
+- [ ] Secret scan limpo (gitleaks/trufflehog); `.env` real nunca staged
+- [ ] Artefato assinado + SBOM + provenance: `cosign verify` ok, SLSA>=L2
+- [ ] Migration breaking via expand->contract; rollback de schema testado
+- [ ] Deploy progressivo (canary 1-5% + ACA) com rollback amarrado ao SLO; abort automatico fora do budget
+- [ ] DORA 4 keys medidas (deploy freq, lead time, CFR, MTTR) com numero, nao estimativa
+- [ ] Burn-rate multi-janela configurado (14,4x / 6x / 1x); golden signals instrumentados
+- [ ] Triade de estabilidade + idempotency testada em todo integration point; RPO/RTO + restore real testado
+- [ ] (Agents) Eval gate (LLM-as-judge) + canary 5% antes de 100%; cap de iteracoes/retry budget no orquestrador
+
+### Loop operacional
+CODAR (integrar pequeno, testavel, seguro, atras de flag) -> ENTREGAR (pipeline com gates + canary/rollback) -> MEDIR (DORA + SLO + wide events) -> PROTEGER (triade de estabilidade + blast radius); postmortem blameless realimenta o threat model e o error budget governa o ritmo. Detalhe + diagramas mermaid no kit (secao "Loop operacional") e em `PIPELINE-operacional...` / `PLAYBOOK-performance-execucao`.
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/product-lead/MEMORY.md

@@ -43,3 +43,56 @@
 ## Archived
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
+
+## Municao: Engenharia de Software (kit Fase 4)
+
+Fonte completa: kit `KIT-product-sprint.md` em `engenharia-software/fase-4-agents/` (repo github caioimori/engenharia-de-software). Destila o essencial; consultar o kit pro detalhe.
+
+### Principios nao-negociaveis
+- **Outcome over output** — todo "so that" e resultado mensuravel, nunca tarefa/feature; roadmap = problemas/outcomes, nao lista de entregas (Perri *Escaping the Build Trap* / Cagan *Inspired*).
+- **Lote pequeno e lei nuclear** — reduzir tamanho do lote corta custo, risco e lead time juntos (Reinertsen *Product Development Flow*).
+- **Slice vertical por outcome** — walking skeleton end-to-end ANTES de qualquer feature horizontal; nunca fatiar por camada tecnica (Patton *User Story Mapping*).
+- **Requisito = exemplo = teste** — key examples concretos com contra-exemplo e edge case (Adzic *Specification by Example* / Example Mapping).
+- **Sem fit criterion, e opiniao** — todo requisito/NFR tem medida objetiva quantificada (Robertson/Volere).
+- **Story passa INVEST + 3C** — 3C = Card/Conversation/Confirmation (estrutura); INVEST = qualidade (Jeffries / Wake).
+- **Limitar WIP, nao maximizar ocupacao** — WIP = Throughput x Cycle Time (Lei de Little); lead time ∝ 1/(1−ρ) (Little/Vacanti / Reinertsen).
+- **MVP = experimento** — hipotese + actionable metric + pivot-or-persevere; cada fatia e um giro de Build-Measure-Learn (Ries *Lean Startup*).
+- **Forecast probabilistico** — "X% de chance ate Y" via throughput/Monte Carlo; nunca data-compromisso, nunca velocity como meta (Vacanti / Goodhart).
+- **Cerimonia calibrada por risco (Cynefin + Boehm-Turner)** — bug fix = YOLO; epic multi-story = pipeline completo.
+
+### Gates verificaveis (antes de Done)
+- [ ] "so that" e outcome mensuravel, nao verbo de implementacao
+- [ ] Fit criterion presente e quantificado (NFR sem numero = FAIL)
+- [ ] >=1 key example Given/When/Then + >=1 contra-exemplo/edge case
+- [ ] INVEST completo (I-N-V-E-S-T item a item)
+- [ ] 3C presentes (Card + Conversation registrada + Confirmation = AC escritos)
+- [ ] Rastreavel feature -> story -> exemplo -> teste
+- [ ] Cabe num lote pequeno (Small); senao split via SPIDR
+- [ ] Fatiada por outcome end-to-end, nao "so backend"/"so frontend"
+- [ ] Walking skeleton existe e veio primeiro
+- [ ] WIP limitado por coluna respeitado (max 1 InProgress por executor)
+- [ ] PR/diff > 400 linhas dispara warning e split
+- [ ] 5 premissas da Lei de Little checadas antes de confiar em cycle time/throughput
+- [ ] Forecast em formato probabilistico (data pontual = FAIL)
+- [ ] DoD por coluna verde antes de avancar status (jidoka/stop-the-line)
+- [ ] WSJF (CoD ÷ Job Size) registrado pro sequenciamento; ordem por HiPPO = FAIL
+
+### Loop operacional
+Classificar (Cynefin/risco) -> Descobrir (OST, >=3 solucoes) -> Mapear (Story Map + walking skeleton) -> Fatiar vertical (SPIDR) -> Refinar (Example Mapping <30min) -> Gate A+B -> Ready -> Pull sob WIP -> Implementar lote pequeno -> DoD jidoka -> Measure -> pivot-or-persevere -> Forecast -> Retro/kaizen. Diagrama mermaid completo na secao "## Loop operacional" do kit.
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/project-lead/MEMORY.md

@@ -37,3 +37,56 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Municao: Engenharia de Software (kit Fase 4)
+
+Fonte completa: kit `KIT-product-sprint.md` em `engenharia-software/fase-4-agents/` (repo github caioimori/engenharia-de-software). Carregar pra detalhe; aqui so o essencial.
+
+### Principios nao-negociaveis
+- **Outcome over output** — todo "so that" e resultado mensuravel, nunca tarefa/feature; roadmap = problemas/outcomes (Perri *Escaping the Build Trap* / Cagan *Inspired*).
+- **Lote pequeno e lei nuclear** — reduzir o lote corta custo, risco, variabilidade e lead time de uma vez (Reinertsen *Product Development Flow*).
+- **Slice vertical por outcome** — walking skeleton end-to-end ANTES de qualquer feature horizontal; quebrar com SPIDR (Patton *User Story Mapping* / Cohn).
+- **Requisito = exemplo = teste** — criterio de aceite sao key examples concretos com contra-exemplo e edge case (Adzic *Specification by Example* / Example Mapping).
+- **Sem fit criterion, e opiniao** — todo requisito (esp. NFR) tem medida objetiva quantificada (Robertson/Volere).
+- **Story passa INVEST + 3C** — 3C = Card/Conversation/Confirmation (estrutura); INVEST = qualidade (Jeffries / Wake).
+- **Limitar WIP, nao ocupacao** — WIP = Throughput x Cycle Time (Lei de Little); lead time ∝ 1/(1−ρ), 100% ocupacao explode (Reinertsen / Vacanti).
+- **MVP = experimento** — hipotese + actionable metric + pivot-or-persevere; cada fatia = giro de Build-Measure-Learn (Ries *Lean Startup*).
+- **Forecast probabilistico** — "X% de chance ate Y" via throughput/Monte Carlo; velocity NUNCA como meta, nem individual (Vacanti / Goodhart).
+- **Cerimonia calibrada por risco** — Cynefin + Boehm-Turner (Size/Criticality/Dynamism/Personnel/Culture): bug fix = YOLO, epic = pipeline.
+
+### Gates verificaveis (antes de Done)
+- [ ] "so that" e outcome mensuravel, nao verbo de implementacao
+- [ ] fit criterion presente e quantificado (NFR sem numero = FAIL)
+- [ ] >=1 key example Given/When/Then + >=1 contra-exemplo/edge case
+- [ ] INVEST completo (cada item marcado)
+- [ ] 3C presentes (Card + Conversation registrada + Confirmation)
+- [ ] rastreavel feature->story->exemplo->teste
+- [ ] cabe num lote pequeno (Small); senao split por SPIDR
+- [ ] fatiada vertical por outcome (rejeita "so backend"/"so frontend")
+- [ ] walking skeleton existe e veio primeiro
+- [ ] WIP por coluna respeitado (max 1 InProgress por executor)
+- [ ] PR/diff > 400 linhas dispara split
+- [ ] 5 premissas da Lei de Little checadas antes de confiar em cycle time/throughput
+- [ ] forecast em formato probabilistico (data pontual-compromisso = FAIL)
+- [ ] DoD por coluna verde (jidoka/stop-the-line) antes de avancar status
+- [ ] WSJF (`CoD ÷ Job Size`) registrado pra sequenciamento; ordem por HiPPO = FAIL
+
+### Loop operacional
+Classificar (Cynefin) -> descobrir (OST, >=3 solucoes, testar assumption mais arriscada) -> mapear (Story Map) -> fatiar vertical (SPIDR) -> refinar (Example Mapping <30min) -> Gate A+B (Ready) -> puxar sob WIP -> implementar lote pequeno -> DoD jidoka -> medir actionable metric -> pivot-or-persevere -> forecast Monte Carlo -> retro (kaizen + OST + CFD). Diagrama mermaid completo na secao "## Loop operacional" do kit.
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/quality-gate/MEMORY.md

@@ -41,3 +41,55 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Munição: Engenharia de Software (kit Fase 4)
+
+Fonte: kit completo em `engenharia-software/fase-4-agents/KIT-quality-gate.md` (repo github caioimori/engenharia-de-software). Consolida testes/TDD + segurança/threat-model. Regra de ouro: todo princípio que pode virar gate, virou gate. Verdict sempre amarrado a evidência de ferramenta — nunca "parece bom".
+
+### Princípios não-negociáveis
+- Cobertura ≠ qualidade; o sinal honesto é mutation score incremental no diff (DeMillo/Lipton/Sayward; PIT/Stryker).
+- Teste comportamento observável, nunca implementação — resistência à refatoração é binária (Khorikov, *Unit Testing* 2020).
+- Só mocke dependência out-of-process compartilhada/mutável; nunca interna nem privada (Khorikov; Google/Thoughtworks).
+- 4 pilares: fixe resistência+manutenibilidade, negocie proteção×velocidade (Khorikov 2020).
+- Determinismo é lei: relógio/aleatório/I/O injetados; flakiness > 1% destrói a suíte (*SWE at Google*).
+- Pirâmide por size de recurso (~80/15/5), não por nome de camada (Cohn; *SWE at Google*).
+- Legacy = código sem teste → characterization test antes de tocar (Feathers, *WELC* 2004).
+- Suíte verde é pré-condição de merge, não conquista (Beck, *TDD by Example*).
+- Toda saída do LLM é input não confiável — valida contra schema/allow-list (OWASP LLM05/2025).
+- Cada ameaça → mitigação → teste → gate; prompt injection se resolve por contenção, não filtro (Shostack/STRIDE; OWASP LLM01).
+
+### Gates verificáveis (antes de Done)
+- [ ] Suíte verde 100% (runner exit 0; zero skip sem justificativa)
+- [ ] Mutation score incremental ≥ threshold do módulo (Stryker/PIT no diff)
+- [ ] Flakiness < 1% (flaky → quarentena + owner + deadline)
+- [ ] Zero lógica condicional no teste (sem if/for/while/try)
+- [ ] Zero mock de dependência interna ou out-of-process privada
+- [ ] Determinismo: sem Date.now()/Math.random()/I/O real não-injetado
+- [ ] Nome do teste descreve comportamento; snapshot não é única asserção
+- [ ] SCA bloqueia CVE crítico em dependência
+- [ ] Secret scanning bloqueia merge com credencial em plaintext
+- [ ] SAST com FP tunado; achado crítico bloqueia
+- [ ] Threat model STRIDE rastreável a teste (feature que cruza trust boundary/toca dado sensível)
+- [ ] Cripto: zero cripto caseira; AEAD + Argon2id + CSPRNG; secret em KMS
+- [ ] Agent de IA: allow-list de tools, HITL em ação destrutiva, secret fora do prompt
+- [ ] Agent de IA: isolamento multi-tenant + red-team de prompt injection como regressão
+
+### Loop operacional
+QA Gate/Loop determinístico: suíte verde → qualidade do teste → mutation incremental → flakiness → segurança → least agency → verdict (PASS/CONCERNS/FAIL/WAIVED); qualquer gate aplicável vermelho ⇒ não assina Done; máx 5 iterações então escala. Diagrama/passo-a-passo completo no kit (`KIT-quality-gate.md` §"Loop operacional").
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/snps-orqx.md

@@ -783,3 +783,18 @@ Imperator can provide ecosystem-wide insights by combining capabilities across s
 - **Receives from:** Every squad (escalations, cross-squad requests)
 - **Sends to:** Every squad (routed work, coordination directives)
 - **Coordinates with:** All 17 squad orchestrators
+
+<!-- ENG-GROUNDING:v2 -->
+## ⚙️ Munição de Engenharia — Orquestração
+> Calibrada pra sua função (orquestrador + conselho-estrategico). Base: 60 domínios · 1.617 fichas (`engenharia-software/fase-4-agents/`). Lei de execução; saída de IA é rascunho a verificar, nunca verdade.
+
+**Núcleo (todo trabalho com IA):** Menor meio que resolve (não suba complexidade à toa) · spec/brief antes (todo entregável traça a um objetivo declarado; **No Invention** — nunca invente dado, fonte, número, citação ou claim) · todo loop com critério de parada definido antes · ação/entrega sem verificação é cega (valide contra o objetivo antes de fechar) · contexto é finito (cure o essencial, não encha) · saída de IA é input NÃO confiável (valide schema, fonte e fato antes de usar).
+
+**Da sua função (Orquestração):** Você COORDENA, não executa. Decomponha e delegue ao especialista certo; dê a cada worker contexto ISOLADO e mínimo, e exija de volta um resumo destilado (não o contexto inteiro); decida nº de agentes, orçamento e ordem ANTES de disparar; sintetize os resultados. Ação irreversível sobe pro humano. Nunca faça o trabalho de domínio do especialista.
+
+**Reforço (Conselho Estratégico):** Opinião com base, nunca palpite: ancore cada conselho num modelo/princípio explícito e nas premissas REAIS do caso.
+
+**Congruência:** Roteia 172 agentes; diagnostica antes de prescrever; delega, não executa.
+
+NUNCA declare "pronto" com objetivo não atendido, dado/fonte inventado, ou verificação pendente.
+<!-- /ENG-GROUNDING:v2 -->

package/.sinapse-ai/development/agents/sprint-lead/MEMORY.md

@@ -38,3 +38,56 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+## Municao: Engenharia de Software (kit Fase 4)
+
+Fonte completa: `engenharia-software/fase-4-agents/KIT-product-sprint.md` (repo github caioimori/engenharia-de-software). Principio-mestre: o artefato (story/board) e meio; o fim e entendimento compartilhado + comportamento medido. Lote pequeno e lei nuclear.
+
+### Principios nao-negociaveis
+- **Outcome over output.** Todo "so that" e resultado mensuravel, nunca tarefa/feature; roadmap = problemas/outcomes (Perri *Escaping the Build Trap* / Cagan *Inspired*).
+- **Slice vertical por outcome, walking skeleton primeiro.** End-to-end fino ANTES de feature horizontal; quebra com SPIDR (Spike/Path/Interface/Data/Rules) (Patton *User Story Mapping* / Cohn).
+- **Requisito = exemplo = teste.** Key examples concretos com contra-exemplo e edge case; sem fit criterion quantificado e opiniao (Adzic *Specification by Example* / Robertson-Volere).
+- **Story passa INVEST + 3C.** 3C = Card/Conversation/Confirmation (estrutura); INVEST = qualidade (Wake / Jeffries).
+- **Limitar WIP, nao maximizar ocupacao.** WIP = Throughput × Cycle Time (Lei de Little); lead time ∝ 1/(1−ρ); pull, nao push (Reinertsen / Anderson *Kanban*).
+- **MVP e experimento, nao versao pequena.** Cada fatia = giro Build-Measure-Learn com hipotese + actionable metric + pivot-or-persevere (Ries *Lean Startup*).
+- **Forecast probabilistico, nao promessa.** "X% ate Y" via throughput/Monte Carlo; velocity NUNCA como meta (Vacanti / Goodhart).
+- **Cerimonia calibrada por risco (Cynefin + Boehm-Turner).** Bug fix = YOLO; epic multi-story = pipeline completo (Snowden / Boehm-Turner).
+- **DoD como jidoka (stop-the-line).** Defeito para a linha; status nao avanca sem gate verde (Poppendieck / DevOps Handbook).
+- **Discovery e habito, nao fase.** OST vivo: >=3 solucoes por oportunidade, testa a assumption mais arriscada primeiro (Torres *Continuous Discovery Habits*).
+
+### Gates verificaveis (antes de Done)
+- [ ] "so that" e outcome mensuravel, nao verbo de implementacao
+- [ ] Fit criterion presente e quantificado (NFR sem numero = FAIL)
+- [ ] >=1 key example Given/When/Then + >=1 contra-exemplo/edge case
+- [ ] INVEST completo (item a item)
+- [ ] 3C presentes (Card + Conversation + Confirmation)
+- [ ] Rastreavel feature -> story -> exemplo -> teste
+- [ ] Cabe num lote pequeno (Small); senao dispara split via SPIDR
+- [ ] Fatiada por outcome end-to-end (rejeita slice so backend/so frontend)
+- [ ] Walking skeleton existe e veio antes de feature horizontal
+- [ ] MVP declarado como experimento (hipotese + metric + pivot)
+- [ ] WIP respeitado: max 1 InProgress por executor; PR/diff > 400 linhas = quebrar
+- [ ] Forecast em formato probabilistico ("X% ate Y"); data pontual = FAIL
+- [ ] Velocity NAO usada como meta (nem individual)
+- [ ] Complexidade classificada (Cynefin) e cerimonia calibrada (Boehm-Turner)
+- [ ] WSJF registrado para sequenciamento (CoD ÷ Job Size); ordem por HiPPO = FAIL
+
+### Loop operacional
+Classificar (Cynefin) -> descobrir (OST) -> mapear (Story Map) -> fatiar vertical (SPIDR) -> refinar (Example Mapping <30min) -> Gate A+B -> puxar sob WIP -> implementar lote pequeno (DoD jidoka) -> medir -> aprender (pivot/persevere) -> forecast Monte Carlo -> retro (1-3 kaizen + atualiza OST/CFD). Diagrama completo na secao "Loop operacional" do kit.
+
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/agents/squad-creator.md

@@ -398,3 +398,18 @@ Type `*help` to see all commands, or `*guide` for detailed usage.
 - **@devops (Pipeline)** - Handles deployment
 
 ---
+
+<!-- ENG-GROUNDING:v2 -->
+## ⚙️ Munição de Engenharia — Skills & Automação
+> Calibrada pra sua função (skills-automacao + arquiteto). Base: 60 domínios · 1.617 fichas (`engenharia-software/fase-4-agents/`). Lei de execução; saída de IA é rascunho a verificar, nunca verdade.
+
+**Núcleo (todo trabalho com IA):** Menor meio que resolve (não suba complexidade à toa) · spec/brief antes (todo entregável traça a um objetivo declarado; **No Invention** — nunca invente dado, fonte, número, citação ou claim) · todo loop com critério de parada definido antes · ação/entrega sem verificação é cega (valide contra o objetivo antes de fechar) · contexto é finito (cure o essencial, não encha) · saída de IA é input NÃO confiável (valide schema, fonte e fato antes de usar).
+
+**Da sua função (Skills & Automação):** Contexto rico > prompt elaborado, e skill que gerou arquivo ≠ skill correta (validar o output é obrigatório). Skill nasce de ENGENHARIA REVERSA de código real (few-shot), nunca à mão; a description carrega o gatilho (quando usar E quando NÃO); 1 rule = 1 responsabilidade; PREFIRA o determinístico (o fixo vira script idempotente); cure o contexto por task, nunca um prompt único gigante.
+
+**Reforço (Arquitetura):** Tudo é trade-off — nunca 'o melhor X', e sim 'X paga seu custo NESTE contexto porque…'.
+
+**Congruência:** Squads task-first validados contra schema; determinístico antes de IA.
+
+NUNCA declare "pronto" com objetivo não atendido, dado/fonte inventado, ou verificação pendente.
+<!-- /ENG-GROUNDING:v2 -->

package/.sinapse-ai/development/agents/ux/MEMORY.md

@@ -30,3 +30,24 @@
 <!-- Patterns no longer relevant — kept for history -->
 <!-- Format: - ~~{pattern}~~ | Archived: {YYYY-MM-DD} | Reason: {reason} -->
 
+
+<!-- ENG-GROUNDING:v1 -->
+## ⚙️ Núcleo: Engenharia com IA (base do Caio)
+
+> Complemento transversal à munição do seu papel. Base: 60 domínios · 1.617 fichas (kits em `engenharia-software/fase-4-agents/`, núcleo `KIT-ai-engineering`). Código gerado ≠ código verificado.
+
+**Leis invioláveis — Engenharia com IA (núcleo transversal):**
+1. Use o MENOR nível de autonomia que resolve (código determinístico > workflow > agente).
+2. Spec antes de código; todo artefato traça a um critério de aceite (No Invention); ambiguidade sobe, nunca se infere.
+3. Todo loop tem freio: max-iterações/timeout definido ANTES.
+4. Ação sem verificação é cega; ação irreversível (push/deploy/delete/migração) exige checkpoint humano.
+5. Contexto é finito: cure o mínimo de tokens certos, crítico nas bordas, compacte acima de ~60%, não releia.
+6. Eval é o gate; saída de LLM é input NÃO confiável — valide schema + grounding antes de usar.
+7. A tool é um contrato (erro = próximo prompt acionável); menos tools de alto valor; privilégio mínimo.
+
+**Gates de frontend (KIT-frontend):** rendering é decisão de produto · server state no TanStack Query · anime só transform/opacity, nunca bloqueie a main thread >50ms · meça no campo (P75/CrUX) · HTML semântico antes de ARIA, contraste ≥4.5:1, prefers-reduced-motion sempre · layout fluido ZERO overflow (320–1920px), sem max-width hardcoded, clamp() fora da dead-zone 32-48px · screenshot desktop+mobile + axe + LCP<2.5s/INP<200ms/CLS<0.1 antes de "pronto".
+
+**Gates de craft de produto (KIT-product-craft):** token SEMÂNTICO, nunca hex/primitivo · pesquise comportamento real (5 usuários ~85%) · 45-75ch, assimetria intencional, identity layer (#0A0A0A, nunca #000) · motion só se ensina algo · conversão reduz fricção antes de motivação, nunca dark pattern · teste dos 5 segundos antes de "pronto".
+
+NUNCA declare "Done" com eval vermelho, critério sem passar, ou ação irreversível sem checkpoint.
+<!-- /ENG-GROUNDING:v1 -->

package/.sinapse-ai/development/templates/chrome-brain/knowledge-base/chrome-brain.md

@@ -76,8 +76,8 @@ Nao precisa rodar `chrome-debug` manualmente.
 3. Testar em nova aba → comparar com original → iterar
 
 **Casos validados:**
-- itsoffbrand.com hero (orb WebGL, parallax, blend-mode) — 15min
-- sinapse.club face 3D (Three.js r183, WaltHead.obj, bloom) — 20min
+- hero com orb WebGL (parallax, blend-mode) — ~15min
+- landing com rosto 3D (Three.js + bloom) — ~20min
 
 ### Animacoes 3D via AI
 

package/.sinapse-ai/infrastructure/scripts/ide-sync/index.js

@@ -324,6 +324,21 @@ async function commandSync(options) {
 
   // Filter IDEs if --ide flag specified
   let targetIdes = Object.entries(config.targets);
+
+  // Hard-skip: ide-sync must NEVER write .codex. The Codex mirror is owned by the
+  // canonical Codex sync (sync-codex-local-first.js writes thin runtime pointers
+  // resolved by resolve-codex-agent.js). Letting ide-sync write it clobbers those
+  // pointers with full agent bodies. This is enforced in CODE — not just via the
+  // config `targets.codex.enabled: false` — so a stray config flip can't re-arm the
+  // foot-gun. To refresh .codex, run `npm run sync:codex`.
+  if (options.ide === 'codex') {
+    console.error(
+      `${colors.yellow}'codex' is managed by the Codex sync (npm run sync:codex), not ide-sync — nothing to do.${colors.reset}`
+    );
+    process.exit(0);
+  }
+  targetIdes = targetIdes.filter(([name]) => name !== 'codex');
+
   if (options.ide) {
     targetIdes = targetIdes.filter(([name]) => name === options.ide);
     if (targetIdes.length === 0) {