sinapse-ai 1.12.1 → 1.13.0

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

@@ -31,3 +31,41 @@
 <!-- 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`.
+

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

@@ -45,3 +45,39 @@
 <!-- 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).
+

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

@@ -38,3 +38,42 @@
 <!-- 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`.
+

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

@@ -304,7 +304,6 @@ dependencies:
   utils:
     - branch-manager # Manages git branch operations and workflows
     - repository-detector # Detect repository context dynamically
-    - gitignore-manager # Manage gitignore rules per mode
     - version-tracker # Track version history and semantic versioning
     - git-wrapper # Abstracts git command execution for consistency
   scripts:

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

@@ -43,3 +43,39 @@
 ## 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.

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

@@ -37,3 +37,39 @@
 <!-- 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.
+

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

@@ -41,3 +41,38 @@
 <!-- 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").
+

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

@@ -207,7 +207,7 @@ dependencies:
   tasks:
     - qa-create-fix-request.md
     - qa-generate-tests.md
-    - manage-story-backlog.md
+    - po-manage-story-backlog.md
     - qa-nfr-assess.md
     - qa-gate.md
     - qa-review-build.md

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

@@ -697,6 +697,10 @@ framework_compatibility:
       - "Sinapse own domain expertise: branding, content, copy, growth, finance, etc."
       - "No overlap — clear boundary between dev workflow and domain expertise"
       - "@sinapse-orqx can invoke any squad directly via /{prefix}:agents:{orchestrator}"
+
+autoClaude:
+  version: '3.0'
+  migratedAt: '2026-06-21T05:17:50.359Z'
 ```
 
 ---

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

@@ -38,3 +38,39 @@
 <!-- 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.
+

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) {

package/.sinapse-ai/infrastructure/scripts/validate-agents.js

@@ -28,6 +28,10 @@ const yaml = require('js-yaml');
 // Paths
 const ROOT_DIR = path.join(__dirname, '..', '..');
 const AGENTS_DIR = path.join(ROOT_DIR, 'development', 'agents');
+// Squad agents live in the repo root under squads/<squad>/agents/*.md.
+// ROOT_DIR is .sinapse-ai/; the repo root is one level up.
+const REPO_ROOT = path.join(ROOT_DIR, '..');
+const SQUADS_DIR = path.join(REPO_ROOT, 'squads');
 const TASKS_DIR = path.join(ROOT_DIR, 'development', 'tasks');
 const TEMPLATES_DIR = path.join(ROOT_DIR, 'development', 'templates');
 const CHECKLISTS_DIR = path.join(ROOT_DIR, 'development', 'checklists');
@@ -93,9 +97,10 @@ function extractYamlFromMarkdown(content) {
 }
 
 /**
- * Load all agent files
+ * Load the 12 CORE agents (development/agents/*.md).
+ * Core agents are held to the STRICT schema (problems -> errors).
  */
-async function loadAllAgents() {
+async function loadCoreAgents() {
   const agents = [];
 
   try {
@@ -115,6 +120,8 @@ async function loadAllAgents() {
             commands: parsed.commands || [],
             dependencies: parsed.dependencies || {},
             parsed,
+            isCore: true,
+            tier: 'core',
           });
         }
       }
@@ -126,6 +133,100 @@ async function loadAllAgents() {
   return agents;
 }
 
+/**
+ * Load the SQUAD agents (squads/<squad>/agents/*.md).
+ *
+ * Non-breaking by design: squad agents carry KNOWN pre-existing debt (3
+ * different definition formats, malformed frontmatter, missing roster
+ * entries) that later waves will fix. Here they are classified as WARNINGS,
+ * never errors — the only thing that can ERROR is an unreadable file.
+ *
+ * Each record is tagged isCore:false so the validators downgrade their
+ * findings to warnings.
+ */
+async function loadSquadAgents() {
+  const agents = [];
+
+  let squadDirs;
+  try {
+    const entries = await fs.readdir(SQUADS_DIR, { withFileTypes: true });
+    squadDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    // No squads/ dir (e.g. a stripped checkout) -> nothing to add, not fatal.
+    return agents;
+  }
+
+  for (const squad of squadDirs) {
+    const agentsDir = path.join(SQUADS_DIR, squad, 'agents');
+    let files;
+    try {
+      files = await fs.readdir(agentsDir);
+    } catch {
+      continue; // squad without an agents/ dir -> skip
+    }
+
+    for (const file of files) {
+      if (!file.endsWith('.md') || file.startsWith('_')) continue;
+      const filePath = path.join(agentsDir, file);
+
+      let content;
+      try {
+        content = await fs.readFile(filePath, 'utf-8');
+      } catch (error) {
+        // Unreadable file is the ONE critical issue allowed to error for squads.
+        agents.push({
+          file: `${squad}/agents/${file}`,
+          path: filePath,
+          id: file.replace('.md', ''),
+          name: undefined,
+          commands: [],
+          dependencies: {},
+          parsed: null,
+          isCore: false,
+          tier: 'squad',
+          squad,
+          readError: error.message,
+        });
+        continue;
+      }
+
+      let parsed = null;
+      try {
+        parsed = extractYamlFromMarkdown(content);
+      } catch {
+        // Malformed frontmatter -> parsed stays null; surfaced as a WARNING.
+        parsed = null;
+      }
+
+      const agentBlock = parsed && parsed.agent ? parsed.agent : {};
+      agents.push({
+        file: `${squad}/agents/${file}`,
+        path: filePath,
+        id: agentBlock.id || file.replace('.md', ''),
+        name: agentBlock.name,
+        commands: (parsed && parsed.commands) || [],
+        dependencies: (parsed && parsed.dependencies) || {},
+        parsed,
+        isCore: false,
+        tier: 'squad',
+        squad,
+        parseFailed: parsed === null,
+      });
+    }
+  }
+
+  return agents;
+}
+
+/**
+ * Load all agent files (core + squad).
+ */
+async function loadAllAgents() {
+  const core = await loadCoreAgents();
+  const squad = await loadSquadAgents();
+  return [...core, ...squad];
+}
+
 /**
  * Check if a file exists
  */
@@ -171,21 +272,32 @@ function validateCommandUniqueness(agents) {
         agent: agent.id,
         file: agent.file,
         hasVisibility: cmd.visibility !== undefined,
+        isCore: agent.isCore === true,
       });
     }
   }
 
-  // Check for duplicates
+  // Check for duplicates.
+  // A collision is an ERROR only when it is entirely between CORE agents
+  // (the strict, long-standing guarantee). Any collision that involves a
+  // SQUAD agent is downgraded to a WARNING — squad agents carry pre-existing
+  // naming debt that later waves will reconcile, and they must not break CI.
   for (const [cmd, owners] of commandOwners) {
     if (owners.length > 1 && !SHARED_COMMANDS.has(cmd)) {
       const ownerList = owners.map((o) => `@${o.agent}`).join(', ');
-      errors.push({
+      const allCore = owners.every((o) => o.isCore);
+      const finding = {
         type: 'DUPLICATE_COMMAND',
         command: cmd,
         owners: owners.map((o) => o.agent),
         message: `Command "*${cmd}" has multiple owners: ${ownerList}`,
         suggestion: `Keep "*${cmd}" only in the primary owner agent and remove from others, or add to SHARED_COMMANDS if intentionally shared.`,
-      });
+      };
+      if (allCore) {
+        errors.push(finding);
+      } else {
+        warnings.push(finding);
+      }
     }
   }
 
@@ -282,9 +394,37 @@ function validateAgentFormat(agents) {
   for (const agent of agents) {
     const { parsed, file, id } = agent;
 
+    // SQUAD agents: known pre-existing debt. Every structural problem here is
+    // a WARNING (never an error) so the 160 squad agents never break CI. The
+    // single exception (unreadable file) is handled earlier in the loader.
+    // CORE agents keep the strict behavior — structural problems are errors.
+    const sink = agent.isCore ? errors : warnings;
+
+    // Unreadable file is the ONLY truly-critical squad issue -> error.
+    if (agent.readError) {
+      errors.push({
+        type: 'UNREADABLE_AGENT',
+        agent: id,
+        message: `Cannot read agent file ${file}: ${agent.readError}`,
+      });
+      continue;
+    }
+
+    // A squad agent whose YAML didn't parse at all -> one consolidated warning,
+    // then skip the field-by-field checks (parsed is null).
+    if (!parsed || !parsed.agent) {
+      warnings.push({
+        type: 'UNPARSEABLE_AGENT',
+        agent: id,
+        message: `Could not parse agent definition in ${file} (no agent block / malformed frontmatter) — squad debt, later wave`,
+        suggestion: 'Normalize the agent frontmatter to the standard schema (agent.id/name/title).',
+      });
+      continue;
+    }
+
     // Check required fields
     if (!parsed.agent.id) {
-      errors.push({
+      sink.push({
         type: 'MISSING_FIELD',
         agent: id,
         field: 'agent.id',
@@ -293,7 +433,7 @@ function validateAgentFormat(agents) {
     }
 
     if (!parsed.agent.name) {
-      errors.push({
+      sink.push({
         type: 'MISSING_FIELD',
         agent: id,
         field: 'agent.name',
@@ -302,7 +442,7 @@ function validateAgentFormat(agents) {
     }
 
     if (!parsed.agent.title) {
-      errors.push({
+      sink.push({
         type: 'MISSING_FIELD',
         agent: id,
         field: 'agent.title',
@@ -443,6 +583,10 @@ function formatResults(results, showSuggestions = false) {
   lines.push('  Summary');
   lines.push('━'.repeat(60));
   lines.push(`  Agents validated: ${summary.totalAgents}`);
+  if (summary.coreAgents !== undefined) {
+    lines.push(`    Core (strict):  ${summary.coreAgents}`);
+    lines.push(`    Squad (warn):   ${summary.squadAgents}`);
+  }
   lines.push(`  Errors: ${summary.totalErrors}`);
   lines.push(`  Warnings: ${summary.totalWarnings}`);
   lines.push('');
@@ -487,12 +631,17 @@ async function validateAgents(options = {}) {
     dependencyValidation.warnings.length +
     formatValidation.warnings.length;
 
+  const coreAgents = agents.filter((a) => a.isCore);
+  const squadAgents = agents.filter((a) => !a.isCore);
+
   const results = {
     commandValidation,
     dependencyValidation,
     formatValidation,
     summary: {
       totalAgents: agents.length,
+      coreAgents: coreAgents.length,
+      squadAgents: squadAgents.length,
       totalErrors,
       totalWarnings,
       valid: totalErrors === 0,
@@ -545,6 +694,8 @@ module.exports = {
   validateDependencies,
   validateAgentFormat,
   loadAllAgents,
+  loadCoreAgents,
+  loadSquadAgents,
 };
 
 // Run CLI if called directly