aiox-core 5.0.4 → 5.0.7

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

@@ -0,0 +1,98 @@
+# AN_KE_077 - Design Smell Detector
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: 14+ instâncias cross-project (Hackathon-Hub, mmos, aiox-stage, sinkra-hub) — "nao faz sentido"]
+
+## Purpose
+
+A frase "não faz sentido" é um DESIGN SMELL DETECTOR natural. Quando Alan diz isso, tem problema arquitetural — dado no lugar errado, abstração incorreta, componente desnecessário, ou lógica ilógica. Funciona em TODOS os domínios: schema de banco ("is_premium BOOLEAN nao faz sentido por si só"), UI ("widget Maior Nota nao faz sentido"), organização de arquivos ("nao faz sentido /ui /system /libraries"), pricing de modelos ("Gemini Pro ficou mais barato que haiku? nao faz sentido"), e até segurança ("tem dado sensivel que nao faz sentido estar aqui"). Inclui detecção de falsos determinísticos: se algo é rotulado como determinístico mas tem variabilidade → também é design smell ("isso deve ser deterministico").
+
+## Configuration
+
+```yaml
+AN_KE_077:
+  name: "Design Smell Detector"
+  zone: "excelencia"
+  trigger: "Frase 'não faz sentido' (ou equivalente) aparece durante review, build, ou discussão."
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) vs Detecção Subjetiva de Smell — ambas buscam eliminar o desnecessário, mas AN_KE_050 via controle de WIP estruturado enquanto AN_KE_077 via sinalização perceptual"
+    resolution: "Transmutar subjetividade em investigação estruturada: ao invés de validar/rejeitar baseado em opinião, sempre PARAR e executar decisão-tree objetiva (DATA_PLACEMENT, ABSTRACTION, EXISTENCE, LOGIC, SECURITY). Se após análise estruturada ainda houver desacordo → escalar para decisor designado, nunca ignorar a sinalização."
+
+  rule: |
+    SE "não faz sentido" aparece (de qualquer pessoa):
+    ENTÃO PARAR e investigar o design smell:
+      - Dado no lugar errado? → MOVER
+      - Abstração incorreta? → REFATORAR
+      - Componente desnecessário? → DELETAR
+      - Lógica ilógica? → REDESENHAR
+      - Coisa que deveria ser determinística mas não é? → TORNAR determinístico
+    A frase é SEMPRE um sinal legítimo — nunca ignorar.
+
+  veto_condition:
+    trigger: "Alguém disse 'não faz sentido' e a conversa seguiu sem investigar."
+    action: "VETO — Parar. Investigar. 'Não faz sentido' NUNCA é gratuito."
+
+  evidence:
+    - "[SOURCE: sessão d6b38401, mmos] 'Essa estatistica Live Supabase nao faz sentido nenhum estar ali'"
+    - "[SOURCE: sessão 4fb48802, mmos] 'is_premium BOOLEAN DEFAULT false, nao faz sentido isso por si só já é um tipo de oferta'"
+    - "[SOURCE: sessão 1723d762, mmos] 'nao faz sentido termos capa com imagem se podemos fazer tudo com HTML e ser mais leve e 100% responsivo'"
+    - "[SOURCE: sessão d73d5bfc, aiox-stage] 'nao faz sentido /ui /system /libraries, isso tudo deveria estar...'"
+    - "[SOURCE: sessão d73d5bfc, aiox-stage] 'tem mt dado dentro do legado de workspace que nao faz sentido nenhum estar aqui tem até dado sensivel'"
+    - "[SOURCE: sessão 711559f2, aiox-stage] 'quem vai executar esta task? para o que ela serve? nao faz sentido criar uma nova task aleatoria jogada em qualquer pasta'"
+    - "[SOURCE: sessão a13d8b00, sinkra-hub] 'Como que Gemini Pro ficou mais barato que haiku? isso nao faz sentido algum'"
+    - "[SOURCE: sessão 95634505, aiox-stage] 'isso nao faz sentido, isso deve ser deterministico' (merged de AN_KE_094)"
+```
+
+## Decision Tree
+
+```javascript
+IF (phrase_detected: "não faz sentido" OR equivalent)
+  STEP_1: STOP current work — this is a signal, not noise
+
+  STEP_2: CLASSIFY the smell
+    TYPE_A: DATA_PLACEMENT — "não faz sentido estar aqui/ali"
+      → Dado está no componente/tabela/pasta errada
+      → ACTION: mover para local correto
+    TYPE_B: ABSTRACTION — "não faz sentido por si só" / "não faz sentido ter X se Y"
+      → Abstração está no nível errado (granular demais ou genérica demais)
+      → ACTION: refatorar abstraction level
+    TYPE_C: EXISTENCE — "pra que serve isso?" / "nao faz sentido ter isso"
+      → Componente/campo/widget não deveria existir
+      → ACTION: deletar (AN_KE_075)
+    TYPE_D: LOGIC — "como que X é mais barato que Y?" / "isso deveria ser determinístico"
+      → Lógica contradiz expectativa razoável
+      → ACTION: investigar root cause, provavelmente bug ou design flaw
+    TYPE_E: SECURITY — "tem dado sensível que não faz sentido estar aqui"
+      → Informação sensível in wrong scope
+      → ACTION: mover imediatamente, audit trail
+
+  STEP_3: FIX the smell (don't just note it)
+  STEP_4: VERIFY fix resolved the "não faz sentido" feeling
+```
+
+## Failure Modes
+
+### O Widget que Ninguém Sabe Pra Que Serve
+- **Trigger:** Dashboard tem "Maior Nota" widget que mostra dado sem contexto claro.
+- **Manifestation:** "nao faz sentido, pq vários recebem isso, vamos pensar em outro."
+- **Detection:** Quando explicar o widget leva > 10 segundos → design smell.
+- **Prevention:** Cada componente deve responder "pra que serve?" em 1 frase.
+
+### O Dado Sensível no Lugar Errado
+- **Trigger:** Workspace público contém dados operacionais de negócio com dados sensíveis.
+- **Manifestation:** "tem mt dado sensivel da operacao que nao faz sentido estar aqui."
+- **Detection:** Grep por dados pessoais, financeiros, ou credenciais em pastas compartilhadas.
+- **Prevention:** SECURITY audit como parte de qualquer migração/reorganização.
+
+## Validation
+
+**Context:** AN_KE_077 resolve a tensão intrínseca entre subjetividade e objetividade na detecção de problemas de design. A heurística reconhece que "não faz sentido" é fundamentalmente uma percepção, mas transforma essa percepção em investigação estruturada através da decision-tree de tipos (DATA_PLACEMENT, ABSTRACTION, EXISTENCE, LOGIC, SECURITY).
+
+**Validation Criteria:**
+1. ✓ **Tensão identificada:** Subjetividade (interpretação) vs. Objetividade (investigação estruturada)
+2. ✓ **Resolução inscrita:** Toda sinalização gatilha parada + análise estruturada, nunca descarte por subjetividade
+3. ✓ **Decision-tree presente:** Permite classificação e ação determinística mesmo com origem subjetiva
+4. ✓ **Escalonamento definido:** Se análise estruturada não resolver desacordo, escala para decisor designado
+5. ✓ **Ligações cross-heurística:** Conecta com AN_KE_044 (pragmatismo vs purismo) e AN_KE_089 (consenso)
+
+**Status:** ✅ Válida — paradoxo resolvido através de transmutação de subjetividade em protocolo estruturado.

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

@@ -0,0 +1,66 @@
+# AN_KE_078 - Names Not IDs as Identity
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão sinkra-hub ee0a7008 — migração squad-creator-pro, identidade de founders]
+
+## Purpose
+
+Quando artefatos representam PESSOAS reais (founders, experts, agents), usar nomes reais — não anonimizar com IDs, slugs, ou roles genéricos. Pessoas são DNA do sistema, não recursos intercambiáveis. Alan exige que o sistema reflita identidade: "eles são parte do DNA." Isso se aplica a minds no squad-creator-pro (oalanicolas, pedro-valerio, thiago-finch), agents no CODEOWNERS, e qualquer artefato que represente decisões de pessoas reais.
+
+## Configuration
+
+```yaml
+AN_KE_078:
+  name: "Names Not IDs as Identity"
+  zone: "excelencia"
+  trigger: "Criando artefato que representa pessoa real: mind, agent, CODEOWNER, founder profile."
+  sys_tension:
+    tension_with: "AN_KE_034 (Ghostwriting/Autorship) — rastreabilidade de DNA vs anonimização de privacidade em clones."
+    resolution: "Critério administrativo: se pessoa é nomeada em CODEOWNERS ou squad-creator-pro/agents/, usa nome real (DNA). Se é cliente/prospect, anonimiza (privacidade)."
+
+  rule: |
+    SE artefato representa PESSOA real (founder, expert, mentor, agent)
+    ENTÃO usar nome/username real, não anonimizar.
+    Pessoas-chave são DNA do sistema — identidade é design, não dados.
+    EXCEÇÃO: dados sensíveis de terceiros (clientes, leads) → anonimizar.
+    REGRA: internos = nomes reais. Externos = proteção de privacidade.
+
+  veto_condition:
+    trigger: "Substituindo nomes de founders/experts por IDs genéricos ('founder_1', 'expert_A')."
+    action: "VETO — 'nao devemos anonimizar, eles sao parte do DNA.' Use nomes reais para internos."
+
+  evidence:
+    - "[SOURCE: sessão ee0a7008, sinkra-hub] 'nao devemos anonimizar, eles sao parte do DNA'"
+    - "[CONTEXT] Diretórios minds/ em squad-creator-pro usam nomes reais: oalanicolas/, pedro-valerio/, thiago-finch/"
+    - "[CONTEXT] CODEOWNERS usa 3 founders por nome para aprovação de paths shared"
+```
+
+## Decision Tree
+
+```javascript
+IF (creating_artifact_representing_person)
+  STEP_1: CLASSIFY person
+    IF (internal: founder, expert, team member) → USE real name/username
+    IF (external: client, lead, prospect) → ANONYMIZE for privacy
+    IF (public figure: expert being cloned) → USE real name (they're the product)
+
+  STEP_2: APPLY naming
+    Directories: minds/oalanicolas/ (not minds/founder_001/)
+    Agents: @pedro-valerio (not @agent_02)
+    CODEOWNERS: real GitHub usernames
+    Heuristic cards: AN_KE_NNN by @oalanicolas
+
+  NEVER: anonymize internal team members — they ARE the system
+  NEVER: use real names for external client data — privacy first
+```
+
+## Failure Modes
+
+### O Clone Sem Nome
+- **Trigger:** Building mind-cloning system with anonymous IDs for all personas.
+- **Manifestation:** System loses the "who" — decisions traced to "mind_47" instead of the person who made them.
+- **Detection:** Artefatos usam IDs onde deveriam usar nomes. `grep -r "founder_\|expert_\|mind_[0-9]" minds/`
+- **Prevention:** Names for DNA, IDs for data. Founders and experts ARE the identity of the system.
+
+## Validation
+
+✅ **Paradoxo resolvido:** Tensão entre "nomes para rastreabilidade DNA" (internos) e "anonimização para privacidade" (externos) → **Critério administrativo como fonte de verdade.** Se CODEOWNERS ou squad-creator-pro declaram a pessoa, usa-se nome real. Clientes/prospects → anonimizar por padrão, exceto se expressamente autorizado em contrato L1-strategy/legal.

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

@@ -0,0 +1,91 @@
+# AN_KE_079 - Cross-Session Context Injection
+
+```yaml
+heuristic_id: AN_KE_079
+name: "Cross-Session Context Injection"
+zone: "excelencia"
+agent: "@oalanicolas"
+source: "sessões mmos 9c3ca5e9, 6484e8b6, 1ed77acc — trabalho paralelo multi-janela"
+sys_tension:
+  tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — overhead de consolidação + bridge humano em sessões paralelas"
+  resolution: "Injeção de contexto APENAS para domínios que têm impacto direto. Não contaminar autonomia de sessões independentes. A decisão de 'é impactante?' fica com o humano, não com a IA."
+```
+
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos 9c3ca5e9, 6484e8b6, 1ed77acc — trabalho paralelo multi-janela]
+
+## Purpose
+
+Quando trabalhando em múltiplas sessões paralelas, injetar contexto de uma sessão na outra PROATIVAMENTE. A IA não tem visibilidade cross-session — cada janela é um universo isolado. O humano é o bridge. Sem essa injeção: sessão A cria schema que sessão B não sabe, sessão B gera migrations que conflitam. Alan pratica isso sistematicamente: informa mudanças, pede consolidação para handoff, e verifica impacto cross-janela.
+
+## Configuration
+
+```yaml
+AN_KE_079:
+  name: "Cross-Session Context Injection"
+  zone: "excelencia"
+  trigger: "Trabalhando em múltiplas sessões Claude/Codex/Gemini em paralelo."
+
+  rule: |
+    SE fez trabalho em outra sessão que impacta a atual
+    ENTÃO informar a IA proativamente:
+      (1) O QUE mudou na outra sessão
+      (2) COMO impacta o trabalho desta sessão
+      (3) SE há conflitos potenciais (mesmo arquivo, mesmo schema)
+    A IA não tem visibilidade cross-session. Você é o bridge.
+    No final: consolidar para continuidade ("consolide tudo para continuar em outra sessão").
+
+  veto_condition:
+    trigger: "Duas sessões editando mesmo domínio sem informar uma sobre a outra."
+    action: "VETO — Injetar contexto. 'o que acabei de fazer em outra sessão pode impactar seu trabalho.'"
+
+  evidence:
+    - "[SOURCE: sessão 9c3ca5e9, mmos] 'o que acabei de fazer em outra sessao e pode impactar/acelerar o seu trabalho e acho importante saber antes de continuar'"
+    - "[SOURCE: sessão 6484e8b6, mmos] 'consolide tudo o que fez para continuar em outra sessao'"
+    - "[SOURCE: sessão 1ed77acc, mmos] 'onde está toda esta documentacao? vou ir para outra janela com db-sage para conferir'"
+    - "[SOURCE: sessão f5cce682, sinkra-hub] 'Você consegue rodar isso em outra janela/sessão sem depender desta?'"
+```
+
+## Decision Tree
+
+```javascript
+IF (working_in_multiple_sessions)
+  BEFORE_SWITCHING:
+    STEP_1: CONSOLIDATE current session state
+      "consolide tudo o que fez para continuar em outra sessao"
+    STEP_2: IDENTIFY cross-impact
+      WHAT files changed? WHAT schema changed? WHAT decisions made?
+
+  WHEN_ENTERING_NEW_SESSION:
+    STEP_3: INJECT context from other session
+      INFORM: "fiz X na outra sessão, pode impactar Y aqui"
+      PROVIDE: specific files, changes, decisions
+
+  ON_CONFLICT:
+    IF (both sessions editing same file) → STOP one, sync, resume
+    IF (both sessions changing schema) → STOP both, merge schema changes
+    IF (decisions conflict) → surface to human for arbitration
+
+  RELATED: AN_KE_099 (persist rules in config) — config files ARE cross-session context
+```
+
+## Failure Modes
+
+### O Schema que Conflitou
+- **Trigger:** Sessão A cria tabela X. Sessão B cria migration que assume X não existe.
+- **Manifestation:** Migration falha em produção. "coluna já existe" ou "tabela não encontrada."
+- **Detection:** Migration com erro de conflito em deploy.
+- **Prevention:** Injetar contexto de mudanças de schema entre sessões. "fiz migrations na outra janela."
+
+## Validation
+
+**Paradoxo Identificado:** Quanto mais paralelo o trabalho, mais dependente a IA fica da injeção manual de contexto. A IA não consegue ver além de sua sessão, criando um gargalo de dependência do humano como "bridge" — justamente quando a paralelização deveria aumentar autonomia.
+
+**Resolução:** A injeção de contexto NÃO é um problema a ser eliminado, mas uma PRÁTICA DELIBERADA. O humano decide o que é "impactante" — nem tudo merece ser comunicado cross-session. Sessões trabalhando em domínios independentes podem permanecer isoladas. A tensão resolve-se quando o humano ativa a injeção apenas para domínios com risco real de conflito.
+
+**Checklist de Validação:**
+- [ ] Mudança de schema? Informar otra sessão
+- [ ] Mudança de arquivo compartilhado? Consolidar antes de trocar sessão
+- [ ] Mudança de decisão arquitetural? Injetar contexto
+- [ ] Mudança isolada (feature nova, sem deps)? Não contaminar outra sessão
+- [ ] Ambiguidade sobre impacto? Perguntar ao humano antes de injetar

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

@@ -0,0 +1,59 @@
+# AN_KE_080 - Next Command Flow
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão d89753b9, aiox-stage — "me de o comando pra o proximo"]
+
+## Purpose
+
+A fluidez do loop Homem-Máquina exige atrito zero na passagem do bastão no terminal. Quando o Alan roda uma pipeline que processa dados e finaliza a sua fase atual, o agente ou script conclusivo JAMAIS deve terminar em silêncio de "concluído". Ele deve explicitamente antecipar e formatar em console o exato *próximo script ou comando* (`bash/CLI`) que precisará ser colado/executado na sequência. Transição sem cognição forçada.
+
+## Configuration
+
+```yaml
+AN_KE_080:
+  name: "Next Command Flow"
+  zone: "excelencia"
+  trigger: "Término de um epic execution run, validador ou script CLI multi-step interativo."
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — Serial Sequencing vs Parallel Execution"
+    resolution: "Fornecer contexto de próximo passo em formato consultivo, não prescritivo — humano retém decisão final de sequenciação"
+
+  rule: |
+    SE você concluir um script, task complexa ou repassar o fluxo
+    ENTÃO forneça o formato em bloco de código do COMANDO EXATO subsequente.
+    A fricção entre o output de uma IA e o próximo passo natural deve ser zero.
+    Sempre termine a saída dizendo "Próximo Comando:" e entregue o iterador necessário.
+
+  veto_condition:
+    trigger: "Script execute-epic termina dizendo 'Pronto, concluído!' e não mostra qual o próximo ID do story a ser rodado."
+    action: "VETO — 'qual comando pra o proximo, quero sempre qu eno final me de o coamndo pra o proixmo'."
+
+  evidence:
+    - "[SOURCE: sessão d89753b9, aiox-stage] 'qual comando pra o proximo, quero sempre qu eno final me de o coamndo pra o proixmo / isso precisa ser alterado no execute-epic para ele sempre dar o comando do proximo execute'"
+```
+
+## Decision Tree
+
+```javascript
+IF (ending_script_execution_or_closing_task)
+  STEP_1: IDENTIFY what is logically next to do (Is it the next story? Deploy? Test?)
+  STEP_2: FORMAT output. Do not end conversation with a generic summary.
+  STEP_3: EMBED CLI command
+    `echo "Próximo Passo:"`
+    `echo "npm run execute-epic --story 12.4"`
+  STEP_4: EXIT gracefully leaving an actionable hook on screen.
+```
+
+## Failure Modes
+
+### Dead-End Conversacional
+- **Trigger:** Ao processar batch 1, agente finaliza respondendo apenas "Entendido e processado".
+- **Manifestation:** O Alan perde tempo abrindo arquivos README ou `.MD` do backlog para lembrar qual era a story seguinte que ele anotou, quebrando o flow-state.
+- **Prevention:** Pipeline chaining via sugestões hardcoded de script flow.
+
+## Validation
+
+**Paradoxo Identificado:** A heurística persegue "atrito zero" na transição (automação de sugestão de próximo passo), mas cria uma fricção cognitiva oposta — exigir que o agente antecipe o "próximo comando correto" sem contexto de prioridade/sequenciação do usuário viola a agência humana.
+
+**Resolução:** Fornecer sugestões de próximo passo em modo **consultivo** (ex: "Próximos Candidatos:") em vez de **prescritivo** ("Execute isto"). O humano decide se quer executar ou desviar. Assim preserva-se fluidez sem sacrificar autonomia.
+
+**Validação:** Teste em execute-epic: após conclusão de story, gerar lista de 3 próximas stories viáveis com seus IDs, precedidas por "→ Sugestões de Sequência:" e deixar Alan escolher qual executar.

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

@@ -0,0 +1,64 @@
+# AN_KE_081 - Agnostic Taxonomy & English Combinatorics
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 5eac34ac, aiox-stage — "ingles e combinatorias"]
+
+## Purpose
+
+Sistemas caem sob seu próprio peso quando as taxonomias mudam a cada semana ou ficam engessadas em jargões fechados. As estruturas categóricas (como chaves de tags no db, identificadores de file paths, tipos num enum Prisma) precisam adotar padronização. Tudo o que é chave de máquina precisa ser gerado num modelo agnóstico combinatório (ex: inglês, descritivas e passíveis de se cruzarem — `topic:marketing`, `format:video`) em detrimento de uma tag monolítica estática `marketing-em-video-portugues`, garantindo extensibilidade a médio prazo.
+
+## Configuration
+
+```yaml
+AN_KE_081:
+  name: "Agnostic Taxonomy & Combinatorics"
+  zone: "excelencia"
+  trigger: "Modelagem lógica de tags em banco de dados, slugs combinatoriais ou chaves de metadados."
+
+  rule: |
+    SE definindo tags, nomes de esquemas ou categorias para coleções
+    ENTÃO USE idioma de backend universal (Inglês) para as chaves nativas.
+    GARANTA que o modelo seja combinatório e granular, não uma abstração hardcoded gigante.
+    Categorias devem ser combinadas (`format` + `niche` + `geo`) e NUNCA string longas isoladas.
+
+  veto_condition:
+    trigger: "Criar uma chave numérico-localizada tipo `Tag: VideoYouTubeComAlan`"
+    action: "VETO — 'taxonomias precisam ser em ingles e combinatórias, nunca isoladas'."
+
+  evidence:
+    - "[SOURCE: sessão 5eac34ac, aiox-stage] 'taxonomias precisam ser em ingles e combinatórias, nunca isoladas'"
+    - "[PATTERN] Sistema base do MMOS adotou `skill_level`, `format_type` no lugar de categorias engessadas exclusivas."
+
+  sys_tension:
+    tension_with: "AN_KE_027 (Zero Emojis & Design Consistente) — exigência de design visual/semântico consistente vs. imposição de idioma inglês exclusivo para chaves de máquina"
+    resolution: "Usar inglês APENAS para chaves de máquina (enums, DB slugs). Conteúdo e rótulos de UX podem ser em PT-BR ou localizados. Separação clara: machine layer (English) + presentation layer (multilíngue)."
+```
+
+## Decision Tree
+
+```javascript
+IF (defining_taxonomy_enums_tags_or_keys)
+  STEP_1: FORCE english keywords exclusively (for DB enums and core machine slugs).
+  STEP_2: CHECK taxonomy scope:
+    IF (it conveys multiple dimensions like "Marketing Video") -> SPLIT THEM.
+  STEP_3: COMBINATORICS
+    Create `{ domain: 'marketing', format: 'video' }` instead of `{ category: 'marketing-video' }`.
+```
+
+## Failure Modes
+
+### Monólito de Categorias Infinitas
+- **Trigger:** "Novos cursos entraram e as categorias são muito específicas".
+- **Manifestation:** Em 6 meses, a tabela de categorias passa a ter 1500 linhas que não possuem sentido agrupado para os filtros de dashboard.
+- **Prevention:** Estrutura taxonômica compositável (Combinatorial Data).
+
+---
+
+## Validation
+
+✅ **Paradoxo Identificado:** Inglês universal para máquina vs. conteúdo multilíngue de UX.
+
+✅ **Resolução:** Camada de máquina (enums, slugs, DB keys) em inglês; camada de apresentação (labels, strings de UX) em PT-BR ou localizadas conforme necessário.
+
+✅ **Evidência:** Pattern validado no MMOS (skill_level, format_type) mantém granularidade e extensibilidade sem engessamento.
+
+✅ **Aplicabilidade:** Aplicar quando modelando taxonomias, definindo esquemas, ou criando enums de categorizações.

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

@@ -0,0 +1,71 @@
+# AN_KE_082 - Read Documentation Before Acting
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos — "leia antes de continuar" repetido cross-project]
+
+## Purpose
+
+A IA tende a AGIR imediatamente ao receber comando. Alan consistentemente FREIA e manda ler docs/papers/specs ANTES de executar. Entender o contexto previne 80% dos erros de implementação.
+
+## Configuration
+
+```yaml
+AN_KE_082:
+  name: "Read Documentation Before Acting"
+  zone: "excelencia"
+  trigger: "IA propondo executar algo em domínio que tem documentação disponível."
+
+  rule: |
+    SE existe documentação/spec/paper sobre o que vai ser feito
+    ENTÃO ler PRIMEIRO, agir DEPOIS.
+    "leia a documentação que criamos sobre tools, antes de avançarmos"
+    Distinto de AN_KE_086 (verify state): este é sobre DOCUMENTAÇÃO, não estado de DB.
+
+  evidence:
+    - "[SOURCE: sessão 9c7751dc] 'leia a documentacao que criamos sobre tools, antes de avançarmos'"
+    - "[SOURCE: sessão a8145c99] 'eu escrevi um paper sobre isso, quero que leia antes de continuarmos'"
+    - "[SOURCE: sessão 4af01fc6] 'podemos capturar uma documentacao que mereça ser lida antes de fazer uma nova view em db'"
+
+  sys_tension:
+    - tension_with: "AN_KE_017 (Research No Meio, Não No Início)"
+      resolution: "AN_KE_082 obriga leitura de docs ANTES de agir em domínios documentados; AN_KE_017 adia research para fase intermediária. Coexistem: ler docs conceituais no início (AN_KE_082) + defer deep research para meio do projeto (AN_KE_017)."
+    - tension_with: "AN_KE_086 (Verify State Before Proceeding)"
+      resolution: "AN_KE_082 governa documentação conceitual; AN_KE_086 governa estado de runtime. Ambas coexistem: ler docs + verificar estado = segurança total."
+    - tension_with: "AN_KE_001 (Autonomy & Decisiveness)"
+      resolution: "Leitura de docs não paralisa decisão — acelera ela. Docs informam melhor decisão. Paradoxo resolvido via: 'ler faz parte de agir bem.'"
+```
+
+## Decision Tree
+
+```javascript
+IF (about_to_implement_something)
+  CHECK: does documentation/spec/paper exist for this domain?
+    IF (YES) → READ it FIRST, then implement
+      IF (doc contradicts plan) → ADJUST plan to align with doc
+      IF (doc confirms plan) → PROCEED with confidence
+    IF (NO) → CHECK: should documentation be created first?
+      IF (complex domain) → CREATE minimal doc/spec BEFORE coding
+      IF (simple change) → PROCEED directly
+  NEVER: implement complex domain logic without reading existing docs
+  NEVER: create DB views/tables without reading schema documentation
+```
+
+## Failure Modes
+
+### A Migration que Ignorou o Paper
+- **Trigger:** IA implementa tier system em banco sem ler paper escrito por Alan sobre como tiers devem funcionar.
+- **Manifestation:** Schema implementado não reflete modelo conceitual do paper. Retrabalho completo.
+- **Detection:** Output diverge de documentação existente.
+- **Prevention:** "leia o paper antes de continuarmos," "leia a documentação que criamos sobre tools."
+
+## Validation
+
+**Checklist de Aplicação (AN_KE_082):**
+
+- [ ] Documentação/spec/paper relevante foi identificada?
+- [ ] Leitura completa foi feita ANTES de qualquer implementação?
+- [ ] Plano foi ajustado para alinhar com conceitos da documentação?
+- [ ] Divergências foram mapeadas e discutidas?
+- [ ] Paradoxo com autonomia foi resolvido via "ler é agir bem"?
+- [ ] Harmonia com AN_KE_086 (state verification) mantida?
+
+**Status:** ✅ Heurística validada com sys_tension resolvida.

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

@@ -0,0 +1,62 @@
+# AN_KE_083 - Cross-Agent Awareness
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 851f99d8, aiox-stage — "Tem outro agente trabalhando"]
+
+## Purpose
+
+Você não está sozinho no repositório. O cenário AIOX é desenhado em modo *Multi-Player*, portanto, os agentes não devem atuar com arrogância de "singleton" ("sou a primeira coisa rolando aqui hoje"). Agentes podem, devem e vão entrar assincronamente preenchendo pedaços de um software enorme. Quando acordar em uma workspace, ou antes de sobrescrever uma estrutura greenfield perigosa com base no último input do chat, o Agente *deve ler fisicamente* as pastas adjacentes e se perguntar: "o outro Agente ou o usuário já adiantou isso agorinha?". Check de integridade temporal antes da cegueira de prompt.
+
+## Configuration
+
+```yaml
+AN_KE_083:
+  name: "Cross-Agent Awareness"
+  zone: "excelencia"
+  trigger: "Início de task em repositório grande após um intervalo, ou retomada de épicos de desenvolvimento."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs Awareness Multi-Agente"
+    resolution: "Equilibrar velocidade (30s check vs 5min audit) com coordenação: arquivo recente (< 5 min atrás) = SKIP rebuild; arquivo antigo (> 1h) ou ausente = PROCEED. Autonomia não é anarquia—é respeitar locks temporais."
+
+  rule: |
+    SE iniciar elaboração de assets novos de uma pipeline
+    ENTÃO assuma que estamos num ambiente de inteligência paralela.
+    PRIMEIRO confira se o asset já não foi gerado via file system / git log.
+    Revisar > Reescrever as cegas.
+
+  veto_condition:
+    trigger: "Regerar um pacote de components UI inteiro sem verificar usando o comando ls/find se as pastas UI já ganharam os componentes nos últimos 5 commits por outro AI."
+    action: "VETO — 'Tem outro agente trabalhando sempre revise pq algo ele pode já ter feito'."
+
+  evidence:
+    - "[SOURCE: sessão 851f99d8, aiox-stage] 'Tem outro agente trabalhando sempre revise pq algo ele pode já ter feito'"
+    - "[SOURCE: sessão 341b50fe, aiox-stage] 'siga, mas sempre visando pq tenho outros agents trabalhando nisso tb e eels podem ter já feito'"
+```
+
+## Decision Tree
+
+```javascript
+IF (assigned_to_build_target_X)
+  STEP_1: Assume another agent/human might have touched X recently.
+  STEP_2: CHECK file existence (`view_file`, `list_dir`, `grep_search`).
+  STEP_3: CHECK git history (`git log -n 5`) to trace recent modifications.
+  STEP_4: IF (X partially built) -> APPEND and ENHANCE seamlessly instead of destroying.
+  STEP_5: IF (X missing) -> PROCEED building.
+```
+
+## Failure Modes
+
+### Overwrite Destrutivo do Agente Incoordenado
+- **Trigger:** Agente Frontend e Agente Backend atuando no projeto. Backend gera tipos TS nos outputs. Frontend reconstrói tudo na cabeça usando uma versão sem consultar o folder target.
+- **Manifestation:** Perda imediata do código que um modelo gastou 10min escrevendo.
+- **Prevention:** Leitura obrigatória do destino de escrita das funções de criação antes do execute final.
+
+---
+
+## Validation
+
+- [ ] **Paradoxo Identificado:** Tensão entre Autonomia Radical (AN_KE_001) e Awareness Multi-Agente (AN_KE_083) é resolvida via timing heurístico (5min/1h thresholds).
+- [ ] **sys_tension Campo:** Completo com tension_with e resolution explícitos.
+- [ ] **Decision Tree:** Aplicável em contextos de rebuild paralelo (UI components, schemas, assets).
+- [ ] **Failure Mode Coverage:** Cobre o cenário crítico de overwrite entre Frontend/Backend.
+- [ ] **Escalabilidade:** Heurística de timing funciona com N agents assincronamente.

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

@@ -0,0 +1,66 @@
+# AN_KE_084 - Foundation Complete Before Building
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mmos 22650c09 — completar base antes de avançar]
+
+## Purpose
+
+Completar uma camada 100% antes de construir a próxima. Drivers e tools 100% ANTES de correlações. Schema 100% ANTES de seeds. Base instável = tudo em cima treme.
+
+## Configuration
+
+```yaml
+AN_KE_084:
+  name: "Foundation Complete Before Building"
+  zone: "excelencia"
+  trigger: "Projeto multi-camada onde camada N+1 depende de camada N."
+
+  rule: |
+    SE projeto tem camadas de dependência (schema → seeds → UI → tests)
+    ENTÃO completar camada N a 100% ANTES de começar N+1.
+    "eu quero preparar antes 100% o drivers e tools, e depois começar as correlações"
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs sequência mandatória de camadas"
+    resolution: "100% completude na camada atual significa: schema validado + drivers testados + correlações mapeadas. 'Aproveitar dados existentes' refere-se a reutilizar estruturas já 100% completas, nunca a usar camadas parcialmente prontas. A transição entre camadas é binária: camada N = 100% (gate passa) ou camada N < 100% (gate falha, não avança)."
+
+  evidence:
+    - "[SOURCE: sessão 22650c09] 'eu quero preparar antes 100% o drivers e tools, e depois começar as correlações, antes de avançar no resto'"
+    - "[SOURCE: sessão 77b3afff] 'a ideia é nao criar nenhuma nova coluna muito menos tabela, vamos primeiro aproveitar esses dados'"
+```
+
+## Decision Tree
+
+```javascript
+IF (project_has_dependency_layers)
+  STEP_1: IDENTIFY layer order
+    L0: Schema/Data model → MUST be 100% before L1
+    L1: Seeds/Sample data → MUST be 100% before L2
+    L2: Backend logic → MUST be 100% before L3
+    L3: UI/Frontend → builds on stable backend
+  STEP_2: VALIDATE current layer completeness
+    IF (current_layer < 100%) → COMPLETE it first
+    IF (current_layer = 100%) → proceed to next
+  NEVER: start L3 while L1 is still 80%
+  PREFER: aproveit existing data before creating new columns/tables
+```
+
+## Failure Modes
+
+### O UI que Treme
+- **Trigger:** Frontend built on schema that keeps changing.
+- **Manifestation:** Every schema change breaks 3 UI components. Constant rework.
+- **Detection:** > 2 schema changes AFTER UI started. Frontend PR requires backend PR.
+- **Prevention:** "preparar 100% drivers e tools primeiro, depois começar correlações."
+
+## Validation
+
+**Checklist para garantir camada N a 100% antes de avançar:**
+
+- [ ] Schema: Todas as tabelas definidas, tipos validados, constraints aplicadas
+- [ ] Drivers: APIs/funções de acesso testadas e funcionando 100%
+- [ ] Correlações: Relacionamentos entre entidades mapeados e validados
+- [ ] Seeds: Dados de teste ou iniciais carregados e verificados
+- [ ] Tests: Cobertura mínima 80% da camada atual
+- [ ] Gate Review: Aprovação explícita (não implícita) para avançar à camada N+1
+
+**Paradoxo Resolvido:** "Completude antes de avançar" ≠ "nunca reutilizar". Significa: estruturas prontas + validadas + testadas = seguras para reutilizar. Aproveitar existente = reuso controlado de camadas 100% completas, não de WIP.

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

@@ -0,0 +1,62 @@
+# AN_KE_085 - Greenfield Over Spaghetti Refactor
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mmos (clonagem de perfil), aiox-stage]
+
+## Purpose
+
+Quando nos deparamos com dados espaguetizados (múltiplas anotações velhas de prompts mescladas, templates falhos iterados no limite da sanidade ou scraps sobrecarregados), a mente impulsiva do desenvolvedor quer consertar o emaranhado tentando refatorar linha por linha. Alan entende a matemática do caos: "comece um greenfield do zero" jogando as bagunças para a pasta `sources/`. O tempo economizado descartando falsas fundações compensa o "orgulho do conserto". Se a entropia acumulou num volume doente, faça "tabula rasa" puxando raw assets isolados.
+
+## Configuration
+
+```yaml
+AN_KE_085:
+  name: "Greenfield Over Spaghetti Refactor"
+  zone: "genialidade"
+  trigger: "Processamento de fontes desorganizadas, documentação lixo no workspace herdado, refatoração impossível contínua."
+
+  sys_tension:
+    tension_with: "AN_KE_045 (Subtraction First Strategy) vs. Greenfield Reconstruction"
+    resolution: "Subtraction-first privilegia eliminar complexity iterativamente. Greenfield privilegia reconstruir desde L0 quando entropia crítica supera 70%. Critério: Se refatoração contínua gera 2+ iterações de correção no mesmo artifact, greenfield é mais eficiente que subtrair incrementalmente."
+
+  rule: |
+    SE o domínio atual do projeto estiver poluído (falsas docs, código Frankenstein, assets contraditórios)
+    ENTÃO NUNCA tente consertar a teia de aranha (refatorar em cima do escombro).
+    Mova todo o lixo valioso para `sources/` estritas (como read-only raw material).
+    Crie o trabalho de from scratch (Greenfield).
+    A sanidade sistêmica cresce partindo do L0 em base limpa.
+
+  veto_condition:
+    trigger: "O documento do clone do Thiago Finch está terrível. O agente foca em rodar 8 passes de edição no mesmo arquivo quebrado para 'ajeitar' parágrafos."
+    action: "VETO — 'começar um greenfield do zero: organize em sources'."
+
+  evidence:
+    - "[SOURCE: sessão clone_profile] 'O processo está com vários erros: Thiago Finch é uma figura pública e eu tenho documentos já do clone dele na pasta, entao deveria organizar os documentos em sources e começar um greenfield do zero'"
+```
+
+## Decision Tree
+
+```javascript
+IF (evaluating_messy_legacy_artifacts_or_docs)
+  STEP_1: ESTIMATE entropy (Is this file completely distorted by prior bad iterations?)
+  STEP_2: MOVE artifacts
+    IF (entropy is critical) 
+      -> `mkdir -p _sources_raw/`
+      -> Mover lixo utilizável pra pasta sources original.
+  STEP_3: START clear, standardized output schema in target folder.
+  STEP_4: PULL logic cleanly from raw sources to greenfield skeleton.
+```
+
+## Failure Modes
+
+### Sunk Cost Arquitetônico
+- **Trigger:** Insistência em manter um script gigantesco legado para não perder o que parece prático.
+- **Manifestation:** Em 1 mês o modelo conserta o Legacy que continua estourando em exceções bizarras (Doc Rot sistêmico).
+- **Prevention:** Botão vermelho imediato de Wipe + Source-Isolate.
+
+## Validation
+
+**Paradoxo Identificado:** Greenfield (create from zero) tensiona contra Incremental Optimization (refactor continuously). A heurística resolve o paradoxo pela entropia: quando a estrutura herdada contém >70% de artefatos incoerentes/contraditórios, o custo marginal da refatoração supera o custo de começar do zero.
+
+**Aplicabilidade:** Critério objetivamente verificável — contar iterações de correção no mesmo artefato. Se >2 iterações corretor-conserto em 1 período, greenfield é optimal.
+
+**Contra-indicadores:** Quando a base contém núcleos estruturados e o lixo é periférico (<30%), incremental é mais eficiente (AN_KE_001 prevalece).