aiox-core 5.0.5 → 5.0.7

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_103.md

@@ -0,0 +1,60 @@
+# AN_KE_103 - Local Caching Over Live Database
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 160b90cc, aiox-stage — "ao invés de pegagarmos do banco, pegarmos de outputs locais"]
+
+## Purpose
+
+A performance transversal do Supabase degrada drasticamente quando se roda `fetch()` de campos Text Text massivos (VTT Transcripts, livros brutos). Muitas pipelines do ecossistema operam como Data Miners que precisam esmiuçar linguística profunda. A regra impõe que sistemas de consulta para processos batch ou análises LLM leiam primordialmente do File System (onde as transições ETL baixaram os docs pré-processados e purgados de erros). O banco relacional é para Estado e Rotas; Arquivos massivos repousam na máquina.
+
+## Configuration
+
+```yaml
+AN_KE_103:
+  name: "Local Caching Over Live Database"
+  zone: "genialidade"
+  trigger: "Criando pipelines de IA (RAG) ou processamento batch textual longo (chunks/livros)."
+
+  rule: |
+    SE precisar ler ou consumir ativos textuais/binários mastodônticos em execução interna
+    ENTÃO PREFIRA OS ASSETS LOCAIS (`outputs/transcriptions`, `/docs`) como fonte primária imutável.
+    Otimiza a janela temporal e economiza I/O da pool do banco remoto.
+
+  veto_condition:
+    trigger: "Agent constrói um iterador que faz 40 queries em série de `SELECT raw_transcript FROM content_vtt` num banco prod."
+    action: "VETO — 'analise se nao seria melhor pegarmos de /outputs/transcriptions onde elas já foram tratadas (...) e além disso nao precisa se coenctar no banco já estao locais'."
+
+  evidence:
+    - "[SOURCE: sessão 160b90cc, aiox-stage] 'ao invés de pegagarmos do banco, pegarmos de outputs/transcriptions onde elas já foram tratadas e estao sem tantos erros de portugues, e além disso nao precisa se coenctar no banco já estao locais'"
+
+  sys_tension:
+    tension_with: "AN_KE_067 (Database as Single Source of Truth) — Conflito entre FS local para leitura imutável vs Banco como fonte canônica."
+    resolution: "Paradoxo aparente: Local FS prioriza performance em leitura; Banco relacional prioriza consistência. Resolução: FS é primária para LEITURA imutável (após ETL); Banco é primária para ESTADO vivo e transações. Docs processados no FS são snapshots validados — mudanças futuras retornam ao banco e regeneram o cache local."
+```
+
+## Decision Tree
+
+```javascript
+IF (accessing_massive_documents_for_llm_chain_or_script)
+  STEP_1: QUERY architecture layout (Are these raw transcripts? RAG sources? Long docs?)
+  STEP_2: CHECK existence in `./outputs`, `./data`, or `./sources`.
+  STEP_3: IF (Files Exist locally)
+    -> Stream directly via file-system paths (`fs.readFileSync`).
+    -> Bypass Supabase SQL completely for these blob accesses.
+```
+
+## Failure Modes
+
+### Overhead de Conexões VTT
+- **Trigger:** Script do backend busca extrair menções à palavra 'AIOX' na tabela gigante de vtt_logs em tempo de requisição de chat.
+- **Manifestation:** A resposta do LLM ganha latência de 8 a 15 segundos só pelo tráfego de saída do Supabase via pool.
+- **Prevention:** Assuma o disco local como a source primária para blocos literários mortos/tratados.
+
+## Validation
+
+✅ **Paradoxo Identificado:** Conflito entre "Local FS como primária (performance)" vs "Banco como single source of truth (consistência)"
+
+✅ **Resolução Articulada:** Camadas complementares — FS para snapshots imutáveis pós-ETL; Banco para estado vivo e mudanças futuras que regeneram cache
+
+✅ **sys_tension Adicionado:** Referência cruzada com AN_KE_050 explicita a tensão sistêmica
+
+✅ **Aplicabilidade Confirmada:** Heurística válida para RAG, análise batch, processamento LLM de documentos massivos

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_104.md

@@ -0,0 +1,60 @@
+# AN_KE_104 - Modular Generic Scripts
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 58ebd69e, aiox-stage — "sem precisar criar um novo script toda vez"]
+
+## Purpose
+
+Scripts "escreveu, rodou, lixou" (One-offs desvairados) espalhados na base causam inflamação sistêmica gigantesca. Processos rotineiros como consolidar artefatos de IA, extrações DDL de banco, ou parse de JSONLs tendem a ser recriados do nada pra cada pasta nova do projeto. Alan blinda o repor contra scripts inúteis cobrando a Parametrização Universal. Operações bash/node repetitivas DEVEM ser moduladas (recebendo flags CLI) para atuarem como ferramentas de orquestração atemporais em `/scripts`.
+
+## Configuration
+
+```yaml
+AN_KE_104:
+  name: "Modular Generic Scripts"
+  zone: "genialidade"
+  trigger: "Criando ou editando shell/node scripts operacionais do repositório (`./scripts/`)."
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — overhead de modularização vs. manutenção exponencial"
+    resolution: "Scripts únicos (<1 dia) permitem clonagem. Scripts recorrentes (>2 usos) exigem parametrização genérica. Gate de decisão: Vai usar este script para >2 contextos? SIM → Modularize. NÃO → Clone aceito."
+
+  rule: |
+    SE o script atende um fluxo temporal de arquivos que se repetirá para outras personas ou áreas
+    ENTÃO DEVE processar caminhos como Argumentos Modulares (`--input`, `--target`).
+    NUNCA desenhe diretórios engessados soltos onde "apenas criar um clone do script resolve a cópia nova".
+    O script deve encapsular a lógica, o utilizador define a variável.
+
+  veto_condition:
+    trigger: "Criar o `clone_pedro.sh` fixo, rodar, e depois ser instruído a clocar o Elon Musk criando o `clone_elon.sh` ao lado no mesmo formato."
+    action: "VETO — 'como podemos fazer siso de forma moduarlizada paar que possamos usa rno futuro sem precisar criar um novo script toda vez?'."
+
+  evidence:
+    - "[SOURCE: sessão 58ebd69e, aiox-stage] 'quero um script paralelo como ./scripts/consolidation-phase1.sh como podemos fazer siso de forma moduarlizada paar que possamos usa rno futuro sem precisar criar um novo script toda vez?'"
+```
+
+## Decision Tree
+
+```javascript
+IF (creating_maintenance_or_pipeline_script)
+  STEP_1: IDENTIFY TARGET: Is this manipulating `/squads/copy` or `/minds/pedro`?
+  STEP_2: EXTRACT TARGET TO FLAGS:
+    `const target = process.argv[2] || 'default-fallback';`
+  STEP_3: REPLACE hardcoded paths with string interpolation.
+  STEP_4: BAKE "How to Run" comments on file header demonstrating its agnostic usage.
+```
+
+## Failure Modes
+
+### Cemitério de Scripts Abandonados
+- **Trigger:** A pasta `./scripts` aloja 35 scripts soltos no repositório. Ninguém lembra que `parse-transcriptions-2024.js` faz exatamente a mesma coisa que a nova feature demanda.
+- **Manifestation:** Duplicação de features fundamentais da infraestrutura resultando em manutenções em silos duplos (se conserta os logs na cópia nova, a cópia do mês passado continua quebrando em casos limite).
+- **Prevention:** Um script governante universal para lógicas pareadas.
+
+---
+
+## Validation
+
+✓ **Paradoxo identificado:** Modularidade demanda overhead (flags, docs, error handling) vs. imediatismo de duplicação.
+✓ **Resolução:** Threshold de 2+ usos como critério binário.
+✓ **Aplicabilidade:** Scripts de infra-ops, transformação de dados, orchestração de artefatos.
+✓ **Trade-off:** SIM modular = manutenção centralizada + reutilização futura. NÃO modular = tech debt exponencial.

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_105.md

@@ -0,0 +1,67 @@
+# AN_KE_105 - Architectural KISS Challenge
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão aiox-core/arquitetura — "comparou com a esrtutura atual"]
+
+## Purpose
+
+A Síndrome do Over-Engineering ataca desenvolvedores e IAs quando recebem um domínio novo. A primeira intuição irresponsável de um Agente é modelar do zero uma "Nova Arquitetura Robusta", construindo castelos no backend com enums inéditos. O desafio KISS do Alan barra a ansiedade arquitetural. A regra prescreve que o Agente é rigorosamente obrigado a provar que a infraestrutura anterior DE FATO falhou em atender ao novo escopo, analisando a composição das classes/dados existentes *antes de rascunhar qualquer nova interface.*
+
+## Configuration
+
+```yaml
+AN_KE_105:
+  name: "Architectural KISS Challenge"
+  zone: "genialidade"
+  trigger: "Proposta de recriação de tabelas, grandes epics de novas arquiteturas ou design de domínios (DDD)."
+
+  sys_tension:
+    tension_with: "AN_KE_106 (Subagents Over Flattened Tasks) — parallelization drives architectural complexity vs KISS simplicity"
+    resolution: "Distinguish between legacy reuse patterns (apply KISS) and truly novel contexts (require evidence that existing cannot adapt). Use IDS Principles gates G1-G6 to evaluate fit before deciding REUSE vs CREATE."
+
+  rule: |
+    SE você arquitetar uma estrutura inteiramente nova (novas rotas UI, novos Schemas)
+    ENTÃO OBRIGATÓRIA A ETAPA: Defender a "Inutilização do Antigo".
+    Avalie o que pode ser reusado das views/pipelines legadas no projeto.
+    NÃO aplique soluções mastodônticas antes de atestar a completa derrocada de um design MVP anterior.
+
+  veto_condition:
+    trigger: "Agente sugere criar 4 `tables` PostgreSQL e GraphQL routes pra gerir eventos sem consultar a estrutura atual EventSourcing presente."
+    action: "VETO — 'Está aplicando KISS? analisou se essa arquitetura toda é REALMENTE necessária? comparou com a estrutura atual para entender o que pode ser aprovaitado dela?'."
+
+  evidence:
+    - "[SOURCE: histórico manual] 'Está aplicando KISS? analisou se essa arquitetura toda é REALMENTE necessária? comparou com a esrtutura atual para entender o que pode ser aprovaitado dela? isso tudo precisa estar de forma nativa na sua tast de domain'"
+```
+
+## Decision Tree
+
+```javascript
+IF (designing_brand_new_component_or_data_pipeline)
+  STEP_1: PAUSE construction logic.
+  STEP_2: QUERY existing counterparts (`search_web`, `grep_search`).
+  STEP_3: CHECK: How much of the existing data payloads solve 80% of our need?
+  STEP_4: EJECT newly created files IF simple prop-overriding on legacy architecture resolves the epic.
+  STEP_5: BUILD ONLY the delta requirements.
+```
+
+## Failure Modes
+
+### Over-Engineering Delusion
+- **Trigger:** Agente decide recriar um módulo UI de Cartões Psicográficos inteiro usando `recharts` puro, ignorando totalmente a livraria `shadcn/ui` que estava gerindo os `Cards` da dashboard ao lado.
+- **Manifestation:** O projeto enche de bibliotecas redundantes (Moment + DateFNS, Shadcn + Radix Puro + Headless).
+- **Prevention:** O Desafio de Simplicidade Inicial (KISS Challenge).
+
+---
+
+## Validation
+
+**Paradoxo Identificado:** Conservadorismo arquitetural vs. Inovação necessária — O heurístico proíbe criar novos quando o antigo poderia servir, mas contextos genuinamente novos exigem estruturas adaptadas.
+
+**Resolução:** Aplicar avaliação por gates (IDS Principles G1-G6) para distinguir entre:
+1. **Legacy Reuse Patterns** (KISS applies): Estrutura existente pode ser reconfigurada com 80%+ cobertura → REUSE/ADAPT
+2. **Genuinely Novel Contexts** (CREATE justified): Análise prova incompatibilidade estrutural → CREATE com documentação
+
+**Aplicação:** Toda proposta de arquitetura nova DEVE passar por:
+- G1 (Existe?) + G2 (Funciona sem modificação?)
+- Se SIM → REUSE (segue KISS Challenge)
+- Se NÃO → G3-G6 (avaliar adaptabilidade, compatibilidade, manutenibilidade)
+- CREATE é autorizado apenas se G3-G6 validarem impossibilidade de adaptação

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_106.md

@@ -0,0 +1,64 @@
+# AN_KE_106 - Subagents Over Flattened Tasks
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 05753292, aiox/arquitetura — "ao invés de usar subagenets, criou 3 tasks"]
+
+## Purpose
+
+Quando processos operacionais assumem densidade maciça (por exemplo: um loop que lê PDFs, extrai o texto, categoriza no banco e gera tweets sobre o material), a propensão de um framework inocente é esmagar tudo em "3 tasks gigantes e lineares". O problema prático disso é o esgotamento fatal da "janela temporal" e Tokens do LLM local: ele esquece qual foi a premissa inicial e delíra. A regra impõe *Delegação Profunda* em processos complexos isolados. Sub-agentes com escopo trancado, sem memória partilhada cruzada, reduzem o contexto a zero de ruído.
+
+## Configuration
+
+```yaml
+AN_KE_106:
+  name: "Subagents Over Flattened Tasks"
+  zone: "genialidade"
+  trigger: "Estruturando Workflows longos com fricções drásticas de domínios diferentes (ex: Backend -> UI Design -> SEO)."
+
+  rule: |
+    SE o fluxo delineado mudar de contexto massivo em suas fileiras
+    ENTÃO NUNCA "achate" o Epic em scripts lineares monótonos para 1 único agente resolver tudo.
+    SEPARE a orquestração instanciando Subagents hiper-focados.
+    Subagentes resolvem a perda de retenção lógica do Claude limpando as amnésias do buffer.
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — Subagentes aumentam WIP e overhead orquestral"
+    description: "Pressão entre manter orquestração centralizada (1 agente, coesão) vs distribuir subagentes (foco, mas overhead de sincronização)."
+    resolution: "Subagentes isolados com estado explícito handoff + orchestrator centralizador reduz amnésia sem perder coesão."
+
+  veto_condition:
+    trigger: "O `agent.md` principal recebe tarefas de `Parse SQL Data`, `Scrape 5 links` e `Gerar 3 telas no React` amarradas em sequência cega."
+    action: "VETO — 'Outra coisa que notei, é que ao invés de usar subagenets, criou 3 tasks, precisamos rever isto também.'."
+
+  evidence:
+    - "[SOURCE: sessão 05753292, aiox-stage] 'Outra coisa que notei, é que ao invés de usar subagenets, criou 3 tasks, precisamos rever isto também.'"
+```
+
+## Decision Tree
+
+```javascript
+IF (creating_epic_or_workflow_with_intense_context_shifts)
+  STEP_1: MAP Context Tokens load (Is it mixing UI rendering with heavy prompt-engineering text logic?)
+  STEP_2: IF Context overlaps excessively:
+    -> BUNDLE logically cohesive items into separate Subagents.
+    -> Agent A (@ux) handles purely UI payload.
+    -> Agent B (@copy) handles purely linguistics.
+  STEP_3: MAIN AGENT acts exclusively as Orchestrator passing state outputs, not computing raw code.
+```
+
+## Failure Modes
+
+### Amnésia Limitadora de Context Window
+- **Trigger:** Agente linear consome 160.000 tokens em suas 5 primeiras iterações lendo docs longos e, na rodada 6, o Claude esquece das restrições fundamentais listadas nas regras primárias.
+- **Manifestation:** Quebra silenciosa dos mandamentos base, falhas de schema crônicas por diluição semântica no buffer.
+- **Prevention:** Pipeline ramificada de subagentes com clearings em background.
+
+## Validation
+
+**Paradoxo Identificado:** Subagentes reduzem amnésia (compartimentalização = foco), mas aumentam complexidade orquestral (fragmentação = overhead).
+
+**Validação do Paradoxo:**
+- ✅ **Foco Local:** Cada subagente opera em contexto isolado, evitando amnésia de tarefas cruzadas
+- ✅ **Overhead de Sincronização:** Estado entre agentes requer handoffs explícitos e reconciliação de artefatos
+- ✅ **Resolução:** Orchestrator centralizado + estado handoff versionado + token-limit enforcement por subagent
+
+**Aplicabilidade:** Workflows que transitam entre 3+ domínios (Backend → UI → Copy → SEO) devem usar subagentes. Épicos lineares (<3 contextos) toleram 1 agente com checkpoints.

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_107.md

@@ -0,0 +1,63 @@
+# AN_KE_107 - Queue Concurrency Chaos
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão e6fec185, integrações n8n/whats — "escala... nao ficavam na ordem certa"]
+
+## Purpose
+
+Sistemas desenhados em laboratório muitas vezes rodam 1 iteração isolada via Postman com sucesso e são despachados como funcionais. Quando recebem volume real corporativo (ex. ingestão do WhatsApp ou Slack via webhooks N8N em massa), os microsserviços atropelam uns aos outros (Race Conditions), quebrando a linearidade do histórico das mensagens. Mapeado o erro custoso, a lei entra em vigor: todo sistema assíncrono que processa histórico ou linhas conectadas via eventos (Filas/Queues) DEVE possuir garantias estritas de Order Preservation (e evitação de concorrência ingênua).
+
+## Configuration
+
+```yaml
+AN_KE_107:
+  name: "Queue Concurrency Chaos"
+  zone: "genialidade"
+  trigger: "Desenhando lambdas, sub-funções cloud ou fluxos assíncronos (cron/webhook) de alto tráfego temporal."
+
+  rule: |
+    SE você implementar fluxos assíncronos que escutam eventos de disparo massivos ou chat logs
+    ENTÃO PREVEJA E DESENHE uma barreira restritiva para a ORDEM CRONOLÓGICA (Order Preserving Queue).
+    Testar o loop com apenas N=1 em dev é negligência. Concorrência escalável deve ser o Day 0.
+
+  veto_condition:
+    trigger: "Agente encerra a API Gateway alegando sucesso no script porque a requisição local salvou. Mas o banco está liberado pra 5 writes paralelos nas mesmas timestamps."
+    action: "VETO — 'Depois não conseguia escalar essa estrutura porque o trabalho em fila não funcionava bem. As mensagens não ficavam na ordem certa...'"
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs Garantia de Ordem em Queues"
+    resolution: "Usar filas com particionamento por chave (message_key/partition_key) ou locks pessimistas no BD. N escritas paralelas em chaves diferentes = OK; N escritas na mesma chave = serializar via FIFO queue ou row-level lock."
+
+  evidence:
+    - "[SOURCE: sessão e6fec185] 'Depois não conseguia escalar essa estrutura porque o trabalho em fila não funcionava bem. As mensagens não ficavam na ordem certa quando tinham muita grupos'"
+```
+
+## Decision Tree
+
+```javascript
+IF (designing_messaging_queues_or_async_batch_importers)
+  STEP_1: IDENTIFY ordering urgency (Do events A and B strictly rely on chronological insertion?)
+  STEP_2: CHECK concurrency limits settings.
+    IF missing -> LIMIT batch concurrency to 1 (Sequential) OR insert strict strict timestamp locks.
+  STEP_3: IMPLEMENT dead-letter queues.
+  STEP_4: IF using Supabase -> Lock row for update (RLS/Functions) preventing parallel transaction overrides.
+```
+
+## Failure Modes
+
+### Race Conditions Temporais (Cronological Smash)
+- **Trigger:** Webhook de recebimento do WhatsApp de cliente atinge a URL da Vercel. 5 mensagens enviadas no mesmo segundo batem nos workers que inserem via ORM cego ao banco.
+- **Manifestation:** O "Olá" fica abaixo do "Tudo bem com você?", destruindo a experiência para leitura da conversa retroativa inteira da dashboard AIOX.
+- **Prevention:** Enfileiradores estritos que enforcam `order key FIFO`.
+
+## Validation
+
+**Paradoxo:** Precisamos escalar concorrentemente (velocidade, throughput) ao mesmo tempo que garantimos ordem linear (integridade, UX). A tentação é testar com N=1 localmente e assumir que funciona em produção.
+
+**Validação:**
+- ✓ Filas configuradas com particionamento por entidade (conversation_id, user_id)?
+- ✓ Testes de carga com N>=10 escritas simultâneas na mesma partição rodados antes do deploy?
+- ✓ Dead-letter queues habilitadas para falhas e retries?
+- ✓ Row-level locks (SELECT ... FOR UPDATE) implementados se banco relacional?
+- ✓ Timestamp ordering verificado em logs retroativos (audit trail intacta)?
+
+Sem cumprimento destas garantias, o sistema vai "funcionar" localmente e falhar em produção quando escala.

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_108.md

@@ -0,0 +1,60 @@
+# AN_KE_108 - The Hard Way First (Anti-Retrabalho)
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 2da94fa4, aiox-stage — "nunca escolha o caminho do retrabalho"]
+
+## Purpose
+
+Na engenharia com IA, é trivial pedir um script superficial que resolve o gargalo de hoje colando "fita adesiva" em cima de um bug massivo (ex: suprimir erro, criar sync falso). O Alan abomina dívida técnica originada de preguiça operacional. O preceito é binário: diante de uma escolha entre refatorar o núcleo difícil (que dói na hora) versus passar por cima, DEVE-SE SEMPRE optar pelo núcleo difícil no Day-1. A dívida acumulada na AIOX gera refatorações estúpidas impossíveis de serem navegadas pela janela de contexto no médio prazo. 
+
+## Configuration
+
+```yaml
+AN_KE_108:
+  name: "The Hard Way First (Anti-Retrabalho)"
+  zone: "genialidade"
+  trigger: "Escolhas cruzadas entre um 'workaround rápido' ou uma 'reestruturação difícil e limpa'."
+
+  rule: |
+    SE houver ambiguidade entre resolver provisoriamente ou cavar o alicerce limpo
+    ENTÃO EXIJA o caminho difícil de forma imediata (No Lazy Workarounds).
+    Aja sem preguiça computacional. Dívidas arquiteturais destruirão a janela temporal da IA daqui a 2 meses.
+
+  sys_tension:
+    tension_with: "AN_KE_045 (Subtraction First Strategy) vs Complexidade de Refatoração Profunda"
+    resolution: "Pragmatismo > Apenas na margem (5-10% do esforço). O core arquitetural é inegociável. Workarounds restritos a periféricos e integrações temporárias."
+
+  veto_condition:
+    trigger: "Agente sugere mockar o login system inteiro ou ignorar a migração do data warehouse criando uma view estática pq 'economiza tempo hoje'."
+    action: "VETO — 'nunca, jamaiss escolha o caminho do retrabalho, fazemos o trabalho difíicl hoje, sem preguiça'."
+
+  evidence:
+    - "[SOURCE: sessão 2da94fa4, aiox-stage] 'nunca, jamaiss escolha o caminho do retrabalho, fazemos o trabalho difíicl hoje, sem preguiça'"
+```
+
+## Decision Tree
+
+```javascript
+IF (confronted_with_hacky_workaround_vs_proper_architecture)
+  STEP_1: IDENTIFY if the quick fix leaves orphaned data, silent errors, or untracked legacy paths.
+  STEP_2: IF (Technical Debt increases) -> REJECT immediately.
+  STEP_3: EMBRACE the deep refactor.
+    -> Fix the Typescript Interfaces.
+    -> Rebuild the core abstractions.
+  STEP_4: Deliver the robust foundation without complaining about effort.
+```
+
+## Failure Modes
+
+### Collapse of the Sunk Cost
+- **Trigger:** Agente ignora um erro de arquitetura de tokens do Prisma repetidas vezes escrevendo em cima com `// @ts-ignore`.
+- **Manifestation:** Um mês depois, nenhum deployment passa no CI/CD porque as raízes do DB desincronizaram massivamente com as APIs de frontend. Fatura de conserto explode.
+- **Prevention:** Conserto duro e doloroso logo na Session onde o erro brotou.
+
+## Validation
+
+**Critério de Validação:** Esta heurística é acionada quando um agente/developer está decidindo entre um caminho rápido com débito técnico vs. um caminho correto mas árduo. A decisão correta DEVE favorecer o caminho arquiteturalmente limpo, exceto em periféricos/integrações temporárias (máx. 5-10% do escopo total).
+
+**Teste:**
+- [ ] Identificar se a proposta de "workaround" afeta o core system (rejeitar) ou apenas periféricos (aceitar com prazo de refatoração)
+- [ ] Confirmar que o "caminho difícil" resolve o problema na raiz, não apenas adia
+- [ ] Registrar débito aceitável (se houver) no backlog com prazo máximo de resolução

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_109.md

@@ -0,0 +1,62 @@
+# AN_KE_109 - English-Only DB Schema (AI Defensive Design)
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 799322de, lovable migration — "colunas em portugues costumam gerar eerros de SQL"]
+
+## Purpose
+
+Enquanto copywriters amam a pátria mãe, a relação entre LLMs robustos abstratos e bancos de dados SQL exige linguística universal. Nomenclaturas como `tabela_carrinho`, ou colunas `data_criacao`, aumentam violentamente as taxas de alucinação de agentes que geram consultas parametrizadas internamente ou criam APIs. A regra isola o Banco de Dados como Nação Inglesa: todas as Tables, Views, RPCs, Enums e colunas DEVEM usar o inglês (`carts`, `created_at`). A localização (i18n) das palavras pertence somente ao Client UI em tempo de Render.
+
+## Configuration
+
+```yaml
+AN_KE_109:
+  name: "English-Only DB Schema (AI Defensive Design)"
+  zone: "genialidade"
+  trigger: "Desenhando Data Definition Languages (DDL), Models no Prisma ou schemas para migrações Supabase."
+
+  rule: |
+    SE gerando ou renomeando chaves no domínio de Persistent Storage ou Código Lógico
+    ENTÃO DEVE estar estritamente em the English Language. (tabelas, colunas, enums, endpoints).
+    NUNCA use aportuguesamentos em camadas lógicas, pois IAs alucinam JOINs em português ou fazem typo.
+
+  veto_condition:
+    trigger: "Agente cria um arquivo migration com `CREATE TABLE compras_do_usuario (codigo_rastreio UUID)`."
+    action: "VETO — 'tem muitos elementos como todo banco de dados com tabelas , descricoes, colunas em portugues, que na minha expderiencia costumam gerar muitos eerros de SQL com IA e voce muito bem o porque'."
+
+  evidence:
+    - "[SOURCE: sessão 799322de, db-refactor] 'tem muitos elementos como todo banco de dados com tabelas , descricoes, colunas em portugues, que na minha expderiencia costumam gerar muitos eerros de SQL com IA e voce muito bem o porque'"
+
+  sys_tension:
+    tension_with: "AN_KE_022 (Format Follows Generator) — LLM generators need English schema safety vs Documentation layer requires PT-BR coherence"
+    resolution: "DB Layer = English (schema immunity from LLM hallucination) | Documentation Layer = Portuguese (founder context, narrative coherence). Separation by layer eliminates contradiction."
+```
+
+## Decision Tree
+
+```javascript
+IF (defining_database_entities_or_type_definitions)
+  STEP_1: FORCE english dictionaries.
+    Reject: `usuario_id`, `data_compra`.
+    Approve: `user_id`, `purchased_at`.
+  STEP_2: CHECK existing schema conventions. IF mixing languages -> Normalize entirely to English.
+  STEP_3: Ensure UI labels (Zod localization, React text) cleanly handle the Portuguese translations, cleanly detached from the Data Schema.
+```
+
+## Failure Modes
+
+### Semantic SQL Hallucination
+- **Trigger:** Agente Claude é acionado para puxar relacionamentos entre "Vendas Múltiplas" num banco português.
+- **Manifestation:** O Agente alucina nomeando queries como `select * from sales` e a query crasha por 3 iterations seguidas (pois a table era `vendas_realizadas`). Consumo inútil de tokens lendo o schema toda santa iteração.
+- **Prevention:** Inglês padronizado resolve auto-completar na raiz matemática dos Modelos 3.7.
+
+---
+
+## Validation
+
+✅ **Paradox Identified:** English-only mandate in DB schema contradicts PT-BR documentation requirement (CLAUDE.md).
+
+✅ **Resolved via Layering:** Database layer (schema, DDL, types) operates in English for LLM safety. Documentation layer (Markdown, comments, narrative) operates in Portuguese for founder coherence and strategic alignment.
+
+✅ **Epistemic Confidence:** ALTA — validated against CLAUDE.md §5 (PT-BR Acentuação) and session 799322de evidence (LLM hallucination on Portuguese schema names).
+
+✅ **System Tension:** Encoded in `sys_tension` as (tension_with, resolution) tuple per SINKRA epistemic standards.

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_110.md

@@ -0,0 +1,58 @@
+# AN_KE_110 - Abstraction Funneling (Everything is an Artifact)
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão db270b2c, data architecture — "sao artifacts, sao artefatos criados com base em dados"]
+
+## Purpose
+
+Bancos de dados e file systems de ML tendem à poluição: criam-se caixas para Análises, Sínteses, Relatórios, Checklists e Resumos independentemente. Para o AIOX, dados mastigados por agentes são essencialmente uma mesma infraestrutura matemática. O funil de abstração atua aglomerando derivações sob uma entidade polimórfica (ex: `mind_artifacts`). Se a pipeline pegou "Raw Transcripts" e formou "Análise SWOT" -> é um artifact (type=swot). Isso preserva a tabela limpa e evita a refatoração diária do backend quando um novo formato de sumário é desejado.
+
+## Configuration
+
+```yaml
+AN_KE_110:
+  name: "Abstraction Funneling (Everything is an Artifact)"
+  zone: "genialidade"
+  trigger: "Modelagem de classes ou banco de dados armazenando saídas computacionais de IAs, relatórios, resumos ou perfis."
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — Polimorfismo centralizado vs Redução agressiva de camadas"
+    resolution: "Polimorfismo com Validators rígidos — permite extensão de tipos (flex) mas rejeita schemas divergentes (governance). JSONB payload é o escape hatch, mas `artifact_type` ENUM é invariante."
+
+  rule: |
+    SE você desenha onde armazenar diferentes tipos de inteligência derivada
+    ENTÃO centralize os esquemas usando Polimorfismo / Single Table Inheritance (ex: `mind_artifacts`).
+    NUNCA adicione uma Tabela ou Folder Novo para cada "Sabor de Resumo" que o Agente lançar.
+    Sínteses, frameworks, audits e plans são todos Artefatos com metadados diferentes.
+
+  veto_condition:
+    trigger: "Agente sugere criar tabela genérica de `summaries`, `analyses` e `action_plans` com chaves idênticas de UUID num Supabase vazio."
+    action: "VETO — 'synthesis, analysis e artifacts sao a mesma coisa, sao artifacts, sao artefatos criados com base em dados reais, são sintases, mas vamos chamar de mind_artifacts tudo que for uma abstracao de dados reais'."
+
+  evidence:
+    - "[SOURCE: sessão db270b2c, db-architecture] 'synthesis, analysis e artifacts sao a mesma coisa, sao artifacts... vamos chamar de mind_artifacts tudo que for uma abstracao de dados reais para futuras abstracoes'"
+```
+
+## Decision Tree
+
+```javascript
+IF (evaluating_where_to_store_new_llm_outputs_or_research)
+  STEP_1: IDENTIFY data origin. Is it RAW primary text OR a processed abstraction?
+  STEP_2: IF (Processed Abstraction)
+    -> ROUTE to global `mind_artifacts` (or universal equivalents).
+    -> Add dimensionality via ENUM `artifact_type = 'swot' | 'summary' | 'persona'`.
+  STEP_3: Enforce strict JSONB payload storage inside the artifact for dynamic extensions.
+```
+
+## Failure Modes
+
+### Tabela Fragmentada Explosiva
+- **Trigger:** Surge a necessidade de um Agente "Curador de Memes Psicográficos".
+- **Manifestation:** O dev gasta 3 horas alterando RLS Policies, Prisma, Mappers de Node.js APENAS para criar a tabela "memes_psicograficos" que armazena os exatos mesmos atributos que "profiles_card" armazenava (ID, MindID, Content, CreatedAt).
+- **Prevention:** Um único guardião de polimorfismo contendo `type: 'psicographic_meme'`.
+
+## Validation
+
+✓ **Paradoxo Identificado:** Centralização rígida (polimorfismo monolítico) vs. escalabilidade emergente (novos tipos ad-hoc).
+✓ **Tensão Sistêmica:** Flexibilidade (permitir novos tipos) × Governança (rejeitar schemas divergentes).
+✓ **Resolução:** ENUM tipo é contrato invariante; JSONB payload permite extensão sem migração.
+✓ **Aplicabilidade:** Decisões de arquitetura de dados com múltiplos "sabores" de output computacional.

package/pro/squads/squad-creator-pro/minds/oalanicolas/heuristics/AN_KE_111.md

@@ -0,0 +1,88 @@
+# AN_KE_111 - Day 0 Million-Scale Mindset
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 33889e33, aiox-stage — "preparada para 1 milhao para evitar retrabalhos globais"]
+
+## Purpose
+
+Na startup culture, a ideia de "fazer só pro showcase de hoje" é sedutora. O problema do *Hardcoding* frágil é que, quando os primeiros 1.000 usuários atritarem com o sistema, ele derretera como manteiga no Supabase (se você buscou todos os cursos fazendo requisição full O(N)). O Alan determina implacavelmente que arquiteturas raiz (Indexações no Prisma, Policies Base de RLS, Filas Assíncronas) não têm a permissão de serem lançadas débeis. Desenhe e execute matematicamente provando que resistirá a 1 Milhão no tráfego cronológico para congelar dívidas precoces.
+
+## Configuration
+
+```yaml
+AN_KE_111:
+  name: "Day 0 Million-Scale Mindset"
+  zone: "genialidade"
+  trigger: "Configuração de roteadores vitais Node.js, queries primárias Supabase/Prisma ou Eventos Cron."
+
+  rule: |
+    SE programar chamadas fundamentais que afetam o core render (ex: `Select` massivo, `Array.map` iterativo global)
+    ENTÃO DEVE justificar sua escalabilidade assintótica ou arquitetar a query (Pagination, Indexes, RLs blindado)
+    para sobreviver a Carga Teórica de "1 Milhão" instantânea.
+    O VETO é para "vamos mockar primeiro e ver como agride o servidor depois".
+
+  veto_condition:
+    trigger: "Agente cria a HomePage do MMOS disparando 3 chamadas HTTP no `useEffect` pedindo a lista completa de TODOS os cursos e seus sub-módulos em O(1)."
+    action: "VETO — 'vamos comecar agora com 1000 acessos mas pensando e com a base preparada para 1 milhao para evitar retrabalhos futuros. e com custos baixos.'."
+
+  sys_tension:
+    tension_with: "AN_KE_017 (Research No Meio, Não No Início) vs Complexidade de Análise Assintótica (Parsing Local); AN_KE_049 (Ship First, Doc Later) — velocidade vs escalabilidade"
+    poles:
+      pole_a:
+        name: "Ship Fast (MVP mindset)"
+        implication: "Solução rápida, frágil em escala, retrabalho futuro"
+      pole_b:
+        name: "Build for Scale (Day 0 preparation)"
+        implication: "Investimento inicial maior, solidez comprovada, sem débito técnico"
+    resolution: |
+      O paradoxo é falso. Escalabilidade não é over-engineering cosmético — é o custo INICIAL de
+      arquitetura (indexes, pagination, RLS) que evita retrabalho exponencial posterior.
+      Resolução: Diferenciar entre MVP "quick/dirty" (aceitável em UI/UX) e MVP "architected"
+      (obrigatório em queries/dados/APIs). Query O(N) em 1.000 usuários → mata-se em 1.000.000.
+    metric: "Ask: 'Will this code survive 1M concurrent requests?' If NO → Refactor before shipping."
+    severity: "CRITICAL"
+    recurrence: "Every data-fetching decision"
+
+  evidence:
+    - "[SOURCE: sessão 33889e33, aiox-stage/scale] 'vamos comecar agora com 1000 acessos mas pensando e com a base preparada para 1 milhao para evitar retrabalhos futuros. e com custos baixos.'"
+```
+
+## Decision Tree
+
+```javascript
+IF (writing_global_query_or_ingesting_large_arrays_to_FE)
+  STEP_1: CHALLENGE Big O Complexity. Is it querying the whole table or mapping without pagination?
+  STEP_2: IF YES (It fetches all `users` indiscriminately)
+    -> REWRITE using native SQL row limits (`.range()`, `.limit()`) OR server-side cursor pagination.
+  STEP_3: IMPLEMENT strict foreign keys and Postgres Indexes on `created_at` or heavily sorted columns.
+  STEP_4: Assume heavy traffic is current.
+```
+
+## Failure Modes
+
+### Memory Leak de MVP
+- **Trigger:** Fetch ingênuo de todos os logs do Slack pra "testar a visualização das métricas da comunidade". O array atinge 5.000 entradas.
+- **Manifestation:** React crashea imediatamente com *Out Of Memory* no Edge Lambda do Vercel. O desenvolvedor perde 3 dias só otimizando VDOM e descobrindo paginação que devia ter nascido no dia zero.
+- **Prevention:** Pagination Limit hardcoded Day-1.
+
+---
+
+## Validation
+
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+| **Paradox Identified** | ✅ | MVP Speed vs. Scalable Architecture — false tension resolved through architectural hygiene |
+| **System Tension Documented** | ✅ | sys_tension field includes both poles, resolution, and metric for validation |
+| **Decision Tree Complete** | ✅ | 4-step flow: Challenge Big O → Check limits → Implement indexes → Assume heavy load |
+| **Failure Mode Mapped** | ✅ | Memory Leak of MVP demonstrates cost of deferring scalability |
+| **Enforcement Metric** | ✅ | "Will this code survive 1M concurrent requests?" — testable veto condition |
+| **Resolution Actionable** | ✅ | MVP "architected" path defined — queries must prove scalability, UI can be quick |
+| **Integration Verified** | ✅ | Cross-reference with AN_KE_049 acknowledged; complementary not contradictory |
+| **Severity & Recurrence** | ✅ | CRITICAL — applies to every data-fetching decision in Day 0 |
+
+**Assessment:** APPROVED for operational use. Core principle: Architectural decisions have cascading costs. Build defensively from Day 0 on data layer; UI velocity is secondary.
+
+---
+
+**Pattern Compliance:** Day 0 Million-Scale Mindset
+**System Tension:** Speed (Ship) vs Scalability (Build defensible) — resolved via differential treatment
+**Integration:** Critical checkpoint for database design, query patterns, API endpoints