aiox-core 5.0.4 → 5.0.7

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

@@ -0,0 +1,69 @@
+# AN_KE_086 - Verify State Before Mutating
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: 97 instâncias de "antes de" em 5 meses de history — padrão cross-project massivo]
+
+## Purpose
+
+O padrão mais repetido de Alan: VERIFICAR o estado atual ANTES de qualquer mutação. Não assumir — confirmar. Schema pode já ter sido migrado. Seeds podem já ter sido aplicadas. Código pode já ter sido alterado. Verificar primeiro = evitar 80% dos erros.
+
+## Configuration
+
+```yaml
+AN_KE_086:
+  name: "Verify State Before Mutating"
+  zone: "genialidade"
+  trigger: "Qualquer operação que muda estado: migration, seed, deploy, refactor, delete."
+
+  rule: |
+    SE vai mutar estado (DB, arquivo, config, deploy)
+    ENTÃO VERIFICAR estado atual PRIMEIRO.
+    "Conferiu todo schema antes de criar esse migration?"
+    Não assumir — confirmar. Verificação custa segundos. Rollback custa horas.
+
+  veto_condition:
+    trigger: "Executar migration/seed/delete sem verificar estado atual."
+    action: "VETO — Confira primeiro. SELECT antes de ALTER. ls antes de rm. git status antes de commit."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents) vs State Verification Serialization"
+    resolution: "Verificação prévia (segundos) é 10x mais rápido que rollback (horas). O padrão favora segurança porque o custo real da pressa > custo real da cautela."
+
+  evidence:
+    - "[SOURCE: 97 instâncias] 'antes de' aparece 97x no history como prerequisite gate"
+    - "[SOURCE: sessão mmos e2c20669] 'confira no banco o que temos antes de continuar'"
+    - "[SOURCE: sessão mmos 3ec2ae94] 'Conferiu todo schema antes de criar esse migration? isso ai cria o que? pq user_profiles a tabela já existe'"
+    - "[SOURCE: sessão mmos a8145c99] 'antes de fazer uma migração precisamos entender conceitualmente como vamos aplicar os tiers'"
+    - "[SOURCE: sessão mmos 017a1f24] 'calma vamos planejar antes de alterar qualquer coisa' (repetido 2x)"
+```
+
+## Decision Tree
+
+```javascript
+IF (about_to_mutate_state)
+  STEP_1: VERIFY current state
+    IF (database) → SELECT/DESCRIBE before ALTER/INSERT
+    IF (files) → ls/cat before rm/mv/write
+    IF (git) → git status/diff before commit/push
+    IF (config) → read current before overwrite
+  STEP_2: COMPARE expected vs actual
+    IF (state_matches_expectation) → PROCEED
+    IF (state_differs) → INVESTIGATE before acting
+  NEVER: assume state from memory or prior session
+```
+
+## Failure Modes
+
+### A Migration que Falha na Segunda Vez
+- **Trigger:** ALTER TABLE RENAME sem verificar que coluna já foi renomeada.
+- **Manifestation:** "column 'nome_clone' does not exist" — SQLSTATE 42703.
+- **Detection:** Migration falha imediatamente.
+- **Recovery:** Adicionar IF EXISTS guards (AN_KE_051).
+- **Prevention:** SELECT column_name FROM information_schema ANTES de ALTER.
+
+## Validation
+
+**✓ Paradoxo Identificado:** Speed vs Safety — A tensão entre agir rápido e verificar antes de mutar.
+
+**✓ Resolução:** O padrão resolve o paradoxo porque verificação prévia (5-10 segundos) é dramaticamente mais rápido que debug + rollback + reapply (2-4 horas). O custo real da pressa (risco de falha em produção) > custo real da cautela (segundos de espera).
+
+**✓ Aplicabilidade:** Validado por 97 instâncias de "antes de" como gate em 5 meses de história. Padrão massivo cross-project — parte da DNA operacional de Alan.

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

@@ -0,0 +1,74 @@
+# AN_KE_087 - Brand Domain Isolation
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mentelendaria c5b4f186 + sessão extrai d28b9844 — contaminação entre marcas/projetos]
+
+## Purpose
+
+Nunca cruzar domínios de marca. Conceitos de um business (Thiago Finch/Outliers) NUNCA entram em documentos de outro (Academia Lendária). Configs de um projeto NUNCA contaminam templates de outro. Isolamento total entre universos de marca.
+
+## Configuration
+
+```yaml
+AN_KE_087:
+  name: "Brand Domain Isolation"
+  zone: "excelencia"
+  trigger: "Trabalhando com múltiplas marcas, projetos ou businesses que compartilham infraestrutura."
+
+  rule: |
+    SE múltiplas marcas/projetos compartilham repo ou ferramentas
+    ENTÃO isolamento TOTAL de conteúdo entre domínios.
+    NUNCA usar conceitos/nomes/termos de uma marca em documentos de outra.
+    Configs de projeto A NUNCA poluem template de projeto B.
+
+  veto_condition:
+    trigger: "Conceitos de marca X aparecendo em documento de marca Y."
+    action: "VETO — Limpar contaminação. Verificar se template está 'sujo' com refs de outro projeto."
+
+  evidence:
+    - "[SOURCE: sessão c5b4f186] 'Isso sao nomes que não são usados em nada pela academia lendária, isso é de Thiago Finch do movimento Outliers, não use de forma alguma Outlier, Bunda Mole e Mulambo em NENHUM documento da Academia Lendária'"
+    - "[SOURCE: sessão d28b9844, extrai] 'revise se eles não estão sujos com configurações de outros projetos, quero deixar este como padrão AIOX sem referencia a projetos nao inclusos nesta estrutura'"
+
+  sys_tension:
+    tension_with: "AN_KE_007 (REUSE > CREATE) — eficiência através de reutilização"
+    resolution: "Criar templates brand-neutral com abstração de configurações via variáveis; isolar context-specific references em branches/overrides per business"
+```
+
+## Decision Tree
+
+```javascript
+IF (working_with_multiple_brands_or_projects)
+  STEP_1: IDENTIFY active brand context
+    WHICH brand am I working on RIGHT NOW?
+  STEP_2: SCAN for cross-contamination
+    GREP: terms from brand A in docs of brand B
+    CHECK: templates for refs to other projects
+    CHECK: configs for values from other environments
+  STEP_3: ON CONTAMINATION FOUND
+    CLEAN: remove all foreign brand references
+    VERIFY: template is "clean" — no refs to excluded projects
+  NEVER: use Outliers/Mulambo terms in Academia Lendária docs
+  NEVER: use project-specific configs in shared templates
+```
+
+## Failure Modes
+
+### O Template Sujo
+- **Trigger:** Template base usado em projeto A é copiado para projeto B sem limpeza.
+- **Manifestation:** "revise se eles não estão sujos com configurações de outros projetos."
+- **Detection:** `grep -ri 'outlier\|mulambo\|bunda.mole' workspace/businesses/academia-lendaria/`
+- **Prevention:** Template audit antes de reusar. Cada template deve ser brand-neutral ou brand-specific.
+
+## Validation
+
+**Paradoxo Identificado:**
+- **Tensão:** Maximizar eficiência através da reutilização de templates vs. garantir isolamento total entre domínios de marca
+- **Resolução:** Implementar camada de abstração paramétrica (brand-agnostic templates + context-specific overrides)
+  - Templates reutilizáveis devem usar placeholders: `{BRAND_NAME}`, `{PROJECT_CONFIG}`, `{CONTEXT_SCOPE}`
+  - Cada negócio/marca fornece seu próprio arquivo de overrides: `workspace/businesses/{slug}/config/template-overrides.yaml`
+  - Scripts de validação (pre-commit hooks) verificam contaminação cruzada automaticamente
+  - Documentação explícita sobre qual template é "brand-neutral" vs "brand-specific"
+
+**Critério de Sucesso:**
+- Zero contaminação cruzada de conceitos/nomes entre documentos de diferentes marcas
+- Reutilização eficiente de templates via parametrização
+- Auditoria automatizada detecta violações em tempo de commit

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

@@ -0,0 +1,89 @@
+# AN_KE_088 - Runners as Product Process
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão sinkra-hub b3c022b9 — sinkra-map CLI + modo YOLO]
+
+## Purpose
+
+Quando um pipeline CLI funciona bem (sinkra-map.sh, validate-squad.sh, mmos.sh), a próxima evolução natural é PRODUTIZAR como processo autônomo. Não é só "rodar script" — é criar modos que escalam execução sem intervenção humana: modo YOLO (100% autônomo para as N fases), ssh runners (execução remota), e batch runners (múltiplos squads em sequência). Alan vê CLI runners como PRODUTO, não ferramenta — algo que deveria ter seu próprio processo formalizado no squad-creator-pro.
+
+## Configuration
+
+```yaml
+AN_KE_088:
+  name: "Runners as Product Process"
+  zone: "excelencia"
+  trigger: "Pipeline CLI estável com 5+ runs manuais bem-sucedidos."
+
+  rule: |
+    SE pipeline CLI estável (5+ runs, edge cases conhecidos)
+    ENTÃO produtizar como processo formal:
+      (1) Modo interativo (default, humano no loop)
+      (2) Modo YOLO (100% autônomo, todas fases sem parar)
+      (3) Modo batch (múltiplos inputs em sequência)
+      (4) Modo remoto (ssh runners para execução distribuída)
+    Cada modo é um processo formal no squad-creator-pro.
+    Runner = produto. Script = protótipo.
+
+  veto_condition:
+    trigger: "Pipeline CLI com 10+ runs manuais sem modo autônomo disponível."
+    action: "VETO — 'isso precisa virar um processo de criar esses modos autônomos, esses runners.' Produtizar."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — Produtizar automatiza sequencialmente (modo YOLO percorre fases sem parar), mas AN_KE_073 propõe paralelização para throughput. Tensão: sequencialismo robusto vs paralelismo escalável. Resolvida por decisão de design: runners mantêm sequencialismo (cada fase depende da anterior), mas runners múltiplos executam em paralelo (batch mode com N squads simultâneos)."
+    resolution: "Hierarquia de modos: (1) interativo é default seguro, (2) YOLO é sequencial (cada fase espera a anterior), (3) batch paralelo roda múltiplos YOLO em runners distintos. Mudança de paradigma: script → processo → produto."
+
+  evidence:
+    - "[SOURCE: sessão b3c022b9, sinkra-hub] 'assim como mmos.sh tb quero criar um modo 100% YOLO para as 7 fases do sinkra map-proceess'"
+    - "[SOURCE: sessão b3c022b9, sinkra-hub] 'isso precisa virar um processo em squad creator-pro de criar esses modos autonomos sei la o nome esses runners ssh'"
+    - "[SOURCE: sessão f268bcf6, sinkra-hub] 'Shell runner + prompt template são DELIVERABLES obrigatórios de create-pipeline. Outputs: 6 required (was 3). Shell Runner Requirements: 10 non-negotiable items. Veto: missing .sh, prompt, or flags'"
+```
+
+## Decision Tree
+
+```javascript
+IF (cli_pipeline_stable AND run_count >= 5)
+  STEP_1: ASSESS automation readiness
+    CHECKS:
+      - Edge cases documented? (from manual runs)
+      - Error handling covers known failures?
+      - Output is deterministic and validatable?
+    IF (all checks pass) → proceed to productize
+
+  STEP_2: CREATE runner modes
+    MODE_INTERACTIVE: default, human confirms each phase
+    MODE_YOLO: all phases execute sequentially without stopping
+      - Requires: fallback chain (AN_KE_064)
+      - Requires: error recovery per phase
+    MODE_BATCH: iterate over list of inputs
+      - Input: file with list of squad names / paths
+      - Output: per-input results directory
+    MODE_REMOTE: ssh to runner machine, execute there
+      - Requires: environment setup script
+      - Requires: result sync back to local
+
+  STEP_3: FORMALIZE as process in squad-creator-pro
+    CREATE: task definition for "productize CLI pipeline"
+    DOCUMENT: which modes are available, how to invoke
+
+  NEVER: manually run pipeline 20+ times without creating YOLO mode
+```
+
+## Failure Modes
+
+### O Script que Só o Criador Sabe Rodar
+- **Trigger:** sinkra-map.sh funciona perfeitamente para Alan, 0 documentação de modos.
+- **Manifestation:** Ninguém mais consegue executar. Cada run requer explicação verbal.
+- **Detection:** Script sem --help que mostra modos disponíveis.
+- **Prevention:** Modos formalizados com flags (--mode yolo, --mode batch). --help auto-gerado.
+
+## Validation
+
+**Paradoxo Identificado:** Automação vs Controle — Quanto mais autônomo o runner (modo YOLO), menor a capacidade humana de intervir em tempo real. Quanto mais humano no loop (interativo), mais lento e menos escalável.
+
+**Validação da Resolução:**
+1. ✅ Modo interativo = default seguro (preserva decisão humana)
+2. ✅ Modo YOLO = camada adicional explícita (opt-in, não obrigatório)
+3. ✅ Fallback chain (AN_KE_064) mitiga falhas autônomas
+4. ✅ Mudança epistemológica: Script → Processo → Produto resolve a tensão por reposicionamento de abstração
+
+**Status:** Heurística validada contra paradoxo de automação balanceada.

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

@@ -0,0 +1,88 @@
+# AN_KE_089 - Validate Phases Mirror Map Phases
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão sinkra-hub b3c022b9 — comparando validate vs map process phases]
+
+## Purpose
+
+Paridade arquitetural: se um processo tem N fases de MAPEAMENTO (sinkra-map), o processo de VALIDAÇÃO correspondente DEVE ter fases correspondentes. A validação não pode ser monolítica se o mapeamento é granular. Cada fase de map produz output verificável → cada fase precisa de validação correspondente. Alan detectou que validate tinha menos fases que map e pediu alinhamento: "deveriamos criar mais fases quebradas no validate como no map-process."
+
+## Configuration
+
+```yaml
+AN_KE_089:
+  name: "Validate Phases Mirror Map Phases"
+  zone: "excelencia"
+  trigger: "Processo tem map/generate com N fases mas validate/review com menos fases."
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) vs Granularidade de Validação"
+    resolution: "Equilibrio dinamico: validate DEVE ter fases correspondentes a map (AN_KE_089), mas apenas para outputs verificáveis. Fases que não produzem validação acionável são WIP — eliminar conforme AN_KE_050. Shared infra entre map/validate (logging, model routing) reduz overhead."
+
+  rule: |
+    SE processo tem map/generate com N fases granulares
+    ENTÃO validate/review DEVE ter fases correspondentes (1:1 ou N:subset).
+    Validação monolítica para mapeamento granular = gap de feedback.
+    Cada fase de map produz output → cada output precisa de validation gate.
+    BONUS: shared infra entre map e validate (logging, model routing) — AN_KE_100.
+
+  veto_condition:
+    trigger: "validate-process tem 2 fases para map-process com 7 fases."
+    action: "VETO — 'deveriamos criar mais fases quebradas no validate como no map.' Alinhar granularidade."
+
+  evidence:
+    - "[SOURCE: sessão b3c022b9, sinkra-hub] 'deveriamos criar mais fases quebradas no validate como no map-process'"
+    - "[CONTEXT] sinkra-map.sh tem 7 phases. validate-squad.sh inicialmente tinha 3 phases (structure, quality, deep). Alan pediu alinhamento."
+    - "[CONTEXT] sessão 0f1fe148 descobriu que validate-skill, validate-squad e sinkra-map compartilham lógica (AN_KE_100)"
+```
+
+## Decision Tree
+
+```javascript
+IF (process_has_map_and_validate)
+  STEP_1: COUNT phases
+    map_phases = N (e.g., sinkra-map has 7)
+    validate_phases = M
+
+  STEP_2: CHECK alignment
+    IF (M < N/2) → MISALIGNMENT: validate too coarse
+      → ADD phases to validate to match map granularity
+    IF (M ≈ N) → ALIGNED: good
+    IF (M > N) → OVER-VALIDATION: validate more granular than necessary
+
+  STEP_3: MAP correspondence
+    FOR EACH map_phase:
+      IDENTIFY: what output does it produce?
+      ENSURE: a validate_phase checks that specific output
+    FOR EACH validate_phase:
+      ENSURE: it corresponds to at least 1 map_phase output
+
+  STEP_4: SHARE infra (AN_KE_100 cross-tool)
+    Logging → shared between map and validate
+    Model routing → shared between map and validate
+    Phase execution → shared between map and validate
+
+  NEVER: monolithic validate for granular map
+```
+
+## Failure Modes
+
+### O Validate que Score Sem Granularidade
+- **Trigger:** validate-squad gives 1 score for entire squad, map-process has 7 phases.
+- **Manifestation:** Score 45/100 — but which phases failed? No granularity to act on.
+- **Detection:** validate output has 1 number. map output has 7 sections.
+- **Prevention:** Break validate into phases mirroring map. Each phase gets its own score. Total = weighted average.
+
+## Validation
+
+**Paradoxo identificado:** A granularidade de MAPEAMENTO exige granularidade de VALIDAÇÃO (AN_KE_089), mas granularidade excessiva em validação aumenta overhead computacional (AN_KE_090).
+
+**Resolução:** Validação deve ter N fases correspondentes a map, com execução paralela via shared infra (logging, model routing) para minimizar duplicação. Cada fase de validate valida exatamente 1 output de map. Agregação ocorre apenas em scoring final (weighted average por fase).
+
+**Critério de sucesso:**
+- ✓ validate_phases ≥ map_phases / 2
+- ✓ Cada output de map tem correspondente em validate
+- ✓ Shared infra reduce overhead (AN_KE_100)
+- ✓ Feedback granular por fase (não monolítico)
+
+---
+**Validado em:** 2026-03-30 | **Status:** ✅ Refatorado com sys_tension e validação

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

@@ -0,0 +1,74 @@
+# AN_KE_090 - Harvest Before Delete
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mmos 017a1f24 — revisão de agentes antes de migração]
+
+**sys_tension:** (completeness_vs_speed, time_box_harvest_phase)
+
+## Purpose
+
+Antes de deletar artefatos obsoletos, COLHER o que tem de valor. Agentes antigos podem ter heurísticas, configs ou patterns que se perdem pra sempre no delete. Harvest first, then prune.
+
+## Configuration
+
+```yaml
+AN_KE_090:
+  name: "Harvest Before Delete"
+  zone: "excelencia"
+  trigger: "Deletando, arquivando, ou migrando artefatos que serão substituídos."
+
+  rule: |
+    SE vai deletar/arquivar artefatos (agentes, scripts, configs, docs)
+    ENTÃO PRIMEIRO revisar e extrair o que tem valor.
+    Deletar sem harvest = perder conhecimento irrecuperável.
+
+  veto_condition:
+    trigger: "rm -rf ou git rm batch sem revisão prévia do conteúdo."
+    action: "VETO — Revise primeiro. Extraia patterns, configs, heurísticas. Depois delete."
+
+  tension_with: "AN_KE_045 (Subtraction First Strategy) — Prioriza remover complexidade desnecessária rapidamente, criando atrito com harvest completo antes de delete"
+
+  evidence:
+    - "[SOURCE: sessão 017a1f24] 'Quero que revise o que dos agentes antigos talvez possamos aproveitar nos novos antes de deletarms eles e deixarmos tudo apenas com o sistema novo'"
+    - "[SOURCE: sessão 13c09251, mmos] 'fez backup antes de deletar?'"
+```
+
+## Decision Tree
+
+```javascript
+IF (about_to_delete_or_archive)
+  STEP_1: READ content before deleting
+    FOR EACH artifact:
+      SCAN: patterns, configs, heuristics, useful logic
+      TAG: "harvest" or "safe to delete"
+  STEP_2: HARVEST valuable content
+    IF (patterns found) → extract to appropriate location
+    IF (configs found) → merge into new system
+    IF (heuristics found) → create AN_KE card
+  STEP_3: BACKUP
+    git stash / git branch archive-{date} / pg_dump
+    VERIFY: backup is accessible
+  STEP_4: DELETE
+    ONLY after Steps 1-3 complete
+  NEVER: rm -rf batch without reading first
+```
+
+## Failure Modes
+
+### Os Agentes Antigos que Levaram Segredos
+- **Trigger:** Migração para novo agent system. `rm -rf` old agents sem review.
+- **Manifestation:** New agents missing patterns, configs, special prompts que existiam nos antigos.
+- **Detection:** "cadê aquela config que tínhamos?" — após delete.
+- **Prevention:** "revise o que dos agentes antigos talvez possamos aproveitar nos novos antes de deletarmos."
+
+## Validation
+
+**Paradoxo Identificado:** Harvest-Delete contém uma tensão irredutível entre **completeness** (colher tudo antes de deletar) e **speed** (terminar logo e liberar espaço). Quanto mais profundo o harvest, mais tempo leva; quanto mais rápido se executa, mais se perde.
+
+**Resolução:** Aplicar time-boxing no harvest phase. Definir limite de tempo máximo (ex: 4h) para harvest e depois proceder com delete, aceitando que **não será 100% perfeito, mas terá sido validado e intencional**.
+
+**Aplicação Prática:**
+1. Set timer para 4 horas de harvest
+2. Priorizar artefatos críticos (heurísticas, configs de negócio, patterns únicos)
+3. Ao timeout, PARAR e prosseguir com delete
+4. Documentar o que foi harvested vs. deixado para trás
+5. Aceitar que alguns segredos ficarão perdidos — isso é o custo da transição

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

@@ -0,0 +1,76 @@
+# AN_KE_091 - Conceptual Before Mechanical
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos a8145c99, 017a1f24 — "calma, vamos planejar antes" repetido 2x na mesma sessão]
+
+## Purpose
+
+Entender CONCEITUALMENTE antes de executar MECANICAMENTE. Migrations sem entender o modelo conceptual = desastre. Código sem entender a arquitetura = retrabalho. A IA tende a executar imediatamente — o humano deve frear e exigir entendimento primeiro.
+
+## Configuration
+
+```yaml
+AN_KE_091:
+  name: "Conceptual Before Mechanical"
+  zone: "genialidade"
+  trigger: "IA propondo executar migration, refactor, ou mudança arquitetural significativa."
+
+  rule: |
+    SE mudança é arquitetural ou conceitual (não apenas cosmética)
+    ENTÃO ENTENDER o modelo conceitual PRIMEIRO.
+    Ler paper/doc/spec ANTES de escrever código.
+    "antes de migrar precisamos entender conceitualmente"
+
+  veto_condition:
+    trigger: "Criar migration SQL antes de entender o modelo conceitual por trás."
+    action: "VETO — 'calma vamos planejar antes de alterar qualquer coisa'"
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs. Complexidade de Parsing Conceitual"
+    resolution: |
+      Distinção crítica entre mudanças COSMÉTICA (alta velocidade aceitável) e
+      ARQUITETURAIS (compreensão prévia obrigatória). A pressa mata a qualidade conceptual.
+      Resolução: investir tempo inicial (conceptual) economiza retrabalho (execution).
+
+  evidence:
+    - "[SOURCE: sessão a8145c99] 'antes de fazer uma migração precisamos entender conceitualmente como vamos aplicar os tiers, eu escrevi um paper sobre isso, quero que leia antes de continuarmos'"
+    - "[SOURCE: sessão 017a1f24] 'calma vamos planejar antes de alterar qualquer coisa' (dito 2x na mesma sessão)"
+    - "[SOURCE: sessão 4af01fc6, mmos] 'podemos entao capturar uma documentacao que mereça ser lida antes de fazer uma nova view em db'"
+```
+
+## Decision Tree
+
+```javascript
+IF (proposed_change_is_architectural)
+  STEP_1: STOP mechanical execution
+    "calma vamos planejar antes de alterar qualquer coisa"
+  STEP_2: UNDERSTAND conceptual model
+    READ: paper/spec/doc if exists (AN_KE_082)
+    IF (no doc exists) → DISCUSS conceptual model with human first
+    MAP: how does the current conceptual model work?
+  STEP_3: PLAN changes conceptually
+    WHAT entities are affected?
+    HOW do relationships change?
+    WHAT breaks if we change this?
+  STEP_4: ONLY THEN execute mechanically
+    Migration/refactor/code follows conceptual understanding
+  NEVER: write migration SQL without understanding the model behind it
+```
+
+## Failure Modes
+
+### A Migration que Não Entendeu o Modelo
+- **Trigger:** IA recebe "implementar tiers" e imediatamente escreve ALTER TABLE.
+- **Manifestation:** Schema não reflete modelo conceitual do paper. Tiers mal-modelados.
+- **Detection:** "calma vamos planejar antes" — dito 2x na mesma sessão (a8145c99, 017a1f24).
+- **Prevention:** Ler paper/spec ANTES de escrever SQL. Entender conceito → DEPOIS implementar.
+
+---
+
+## ✓ Validation
+
+**Paradoxo Identificado:** Velocidade de execução (pressão por delivery) vs. Compreensão conceitual profunda (qualidade arquitetural).
+
+**Resolução Implementada:**
+- Campo `sys_tension` adicionado ao YAML com referência cruzada e estratégia de resolução.
+- Heurística confirma que investimento inicial em compreensão conceptual reduz retrabalho downstream.
+- Aplicável a decisões arquiteturais e migrações de schema — não cosmético.

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

@@ -0,0 +1,61 @@
+# AN_KE_092 - Unify Before Extending
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão prompt-ops — unificar design system antes de estender]
+
+## Purpose
+
+Quando existem múltiplas versões, variantes ou duplicatas de algo, UNIFICAR primeiro antes de adicionar features novas. Estender algo fragmentado = multiplicar a fragmentação.
+
+## Configuration
+
+```yaml
+AN_KE_092:
+  name: "Unify Before Extending"
+  zone: "excelencia"
+  trigger: "Múltiplas versões/variantes do mesmo artefato existem."
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — Unify Sequentially vs. Parallelize for Speed"
+    resolution: "Unify cost upfront (slower immediate delivery) prevents exponential fragmentation cost later (much slower long-term velocity). Accept short-term cost for long-term system health."
+
+  rule: |
+    SE existem variantes (2 design systems, 2 schemas, 2 configs)
+    ENTÃO UNIFICAR o melhor de cada ANTES de adicionar novo.
+    "como podemos unificar o que tem de melhor em cada parte"
+
+  evidence:
+    - "[SOURCE: sessão prompt-ops] 'leia /outputs e /docs/design-system e me diga como podemos unificar o que tem de melhor em cada parte'"
+    - "[SOURCE: sessão prompt-ops] 'mas eu fui claro na solicitacao, unificar o que tem de melhor'"
+```
+
+## Decision Tree
+
+```javascript
+IF (extending_feature_or_adding_capability)
+  CHECK: do multiple variants/versions exist?
+    IF (YES) → UNIFY first
+      STEP_1: MAP what each variant has (feature comparison)
+      STEP_2: IDENTIFY "best of each" to keep
+      STEP_3: CREATE unified version with best features
+      STEP_4: THEN extend the unified version
+    IF (NO) → extend directly
+  NEVER: add feature to variant A while variant B exists
+  PREFER: 1 unified system > 2 partial systems + new feature
+```
+
+## Failure Modes
+
+### Os Dois Design Systems
+- **Trigger:** Project has /outputs/ design system AND /docs/design-system. New feature added to one, not the other.
+- **Manifestation:** "unificar o que tem de melhor em cada parte" — descoberta tardia de duplicação.
+- **Detection:** Same concept described in 2+ locations with different details.
+- **Prevention:** Before ANY extension, search for variants. Unify → then extend.
+
+## Validation
+
+✓ **Paradoxo identificado:** Tensão entre velocidade imediata (estender rápido em uma variante) vs. saúde de sistema (unificar antes, custando tempo agora mas economizando exponencialmente depois).
+
+✓ **Resolução aplicada:** Aceitar custo de unificação upfront como investimento que previne fragmentação exponencial e degeneração de longo prazo.
+
+✓ **Campo sys_tension adicionado:** Documentada relação SPEED_OVER_QUALITY com resolução explícita.
+
+✓ **Heurística validada:** Regra é aplicável, evidência robusta, decision tree executável.

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

@@ -0,0 +1,69 @@
+# AN_KE_093 - Backup Before Mutation
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos 22650c09, 13c09251 — backup pedido antes de operações destrutivas]
+
+## Purpose
+
+Antes de qualquer operação que muda dados em produção ou deleta artefatos, FAZER BACKUP. Alan pede isso explicitamente e se frustra quando a IA pula esse passo.
+
+## Configuration
+
+```yaml
+AN_KE_093:
+  name: "Backup Before Mutation"
+  zone: "excelencia"
+  trigger: "Operação destrutiva: delete, migration, seed, schema change, bulk update."
+  sys_tension:
+    tension_with: "AN_KE_051 (Idempotent Operations) — operações idempotentes não precisam backup; mutações irreversíveis exigem"
+    resolution: "Pausar apenas em operações destrutivas; executar autonomamente em operações reversíveis. Backup é validação, não bloqueio."
+
+  rule: |
+    SE operação vai mudar/deletar dados que não são facilmente recuperáveis
+    ENTÃO BACKUP primeiro. Perguntar ao humano se quer backup.
+    No handoff pro próximo: "faça backup antes de qualquer alteração."
+
+  veto_condition:
+    trigger: "DELETE ou ALTER em produção sem backup prévio."
+    action: "VETO — Backup first. pg_dump, git stash, ou cópia manual."
+
+  evidence:
+    - "[SOURCE: sessão 22650c09] 'vamos fazer um handoff e no próximo ja peça para fazer backup de tudo que tá lá antes de qualquer alteracao'"
+    - "[SOURCE: sessão 13c09251, mmos] 'fez backup antes de deletar?'"
+```
+
+## Decision Tree
+
+```javascript
+IF (destructive_operation: DELETE, ALTER, MIGRATION, SEED, BULK_UPDATE)
+  STEP_1: BACKUP before anything
+    DB: pg_dump / supabase db dump / snapshot
+    Files: git stash / git branch backup-{date}
+    Config: copy current state to .bak
+  STEP_2: VERIFY backup is accessible
+    Can you restore from this backup? Test.
+  STEP_3: EXECUTE destructive operation
+  STEP_4: VERIFY result
+    IF (result wrong) → RESTORE from backup
+  HANDOFF: "faça backup antes de qualquer alteração"
+```
+
+## Failure Modes
+
+### O DELETE sem Volta
+- **Trigger:** IA executa `DELETE FROM` em produção sem backup.
+- **Manifestation:** "fez backup antes de deletar?" — perguntado DEPOIS do delete.
+- **Detection:** No pg_dump or snapshot before migration.
+- **Prevention:** Backup is step 0 of ANY destructive operation. Handoff must include backup instruction.
+
+## Validation
+
+**Paradoxo Identificado:** Confiança (inference_autonomy) × Cautela (data_integrity). Alan quer que a IA execute de forma autônoma, mas exige validação preventiva em operações irreversíveis.
+
+**Resolução:** Executar autonomamente em operações reversíveis (lint, build, feature branches). Pausar e validar apenas em DELETE, ALTER, MIGRATION, ou operações com dados históricos em produção. O backup é a ponte entre confiança e segurança.
+
+**Checklist de Validação:**
+- [ ] Operação é destrutiva? (DELETE, ALTER, DROP, TRUNCATE, seed destructivo)
+- [ ] Dados são recuperáveis via git, pg_dump, ou snapshot?
+- [ ] Backup foi solicitado explicitamente ou executado antes da operação?
+- [ ] Restore foi testado para confirmar que o backup funciona?
+- [ ] Handoff contém instrução clara sobre backup para próximo agente?

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

@@ -0,0 +1,58 @@
+# AN_KE_094 - Agnostic Extensibility Protection
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão aiox-core/squads — "mudou de genérico para hardcode"]
+
+## Purpose
+
+A arquitetura do AIOX e os scripts CLI desenhados baseiam-se em expansão orgânica: adicionar squads, expansion-packs e modulos ao sistema *deve requerer zero modificações* no ecossistema subjacente. Hardcodear diretórios isolados nos `if/else` ao iterar quebra drasticamente esse design expansivo. Alan odeia retrocessos estruturais e alerta rigidamente pro fato de que os laços devem ser for-loops genéricos iterando os caminhos, protegendo a auto-descoberta dos packs na startup.
+
+## Configuration
+
+```yaml
+AN_KE_094:
+  name: "Agnostic Extensibility Protection"
+  zone: "excelencia"
+  trigger: "Desenvolvendo CLIs, runners ou iterators base do workspace infinito."
+
+  rule: |
+    SE o script precisa interagir com os plugins presentes (como expansion-packs, squads)
+    ENTÃO USE descoberta de diretórios dinâmica (`fs.readdir`, `glob`, arrays por pathing).
+    NUNCA insira os nomes "squad_a", "squad_b" hardcoded no código do handler.
+    O sistema DEVE processar módulos adicionados no futuro livremente.
+
+  veto_condition:
+    trigger: "Agent reescreve o script de compilação iterando rigidamente `['pack_zero', 'pack_one']` ao notar que existem apenas aqueles dois hoje."
+    action: "VETO — 'Pq voce mudou de generico para hardcode considerando que podemos ter novos expansion packs...'."
+
+  evidence:
+    - "[SOURCE: sessão question on hardcode] 'Pq voce mudou de generico para hardcode considerando que podemos ter novos expansions packs e como está vai impedir que os novos sejam atualizados automatiacmente'"
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — pragmatismo imediato de hardcoding vs. extensibilidade genérica"
+    resolution: "Use generic discovery with optional caching layer — maintain extensibility while optimizing hot paths through lazy-loading and memoization, not through hardcoded lists."
+```
+
+## Decision Tree
+
+```javascript
+IF (writing_loop_or_handler_for_plugins_squads_etc)
+  STEP_1: CHECK for static data arrays denoting structural entities mapping to folders.
+    IF (`['workspaceA', 'workspaceB'].includes(x)`) -> FAIL.
+  STEP_2: REPLACE WITH DYNAMIC CALLS
+    Use `os.listdir()` or equivalent backend mechanism mapping over the path `/expansion-packs/*`.
+  STEP_3: ENSURE script works successfully even if we drop 7 new generic folders there tomorrow.
+```
+
+## Failure Modes
+
+### Hardcode de Atalho Burro
+- **Trigger:** Agente quebra a genérica que rodava sobre todos arquivos de configs e adere um mapeamento manual local nos IFs.
+- **Manifestation:** Um Expansion Pack inteiro inserido no repo principal vira fantasma - as CI/CDs não o testam nem empacotam. Retrabalho insano de debugar "onde está aquele bug de não buildar minha pasta?".
+- **Prevention:** Nomes de domínios corporativos não existem soltos na infra. Toda configuração injetável vem de fora dos Runners.
+
+## Validation
+
+- ✅ **Paradoxo Identificado:** Extensibilidade genérica vs. pragmatismo de hardcoding — balanceado via caching memoizado
+- ✅ **sys_tension Adicionado:** Documenta conflito entre `Pragmatism` (hardcode para velocidade) e `Agnostic Extensibility` (descoberta dinâmica)
+- ✅ **Resolução Proposta:** Lazy-loading + optional caching layer preserva genéricidade mantendo performance
+- ✅ **Aplicabilidade:** Crítica para arquiteturas infinitas (AIOX, squads, expansion-packs, workspaces multibusiness)