aiox-core 5.0.5 → 5.0.7

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

@@ -0,0 +1,58 @@
+# AN_KE_095 - Prompt Over Code for Control
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão Hackathon-Hub 066cd683 — reverter código e deixar controle no prompt]
+
+## Purpose
+
+Às vezes a solução não é mais código — é melhor prompt/config. Se algo pode ser controlado via prompt (formato de output, comportamento de avaliação), é mais flexível e barato que hardcodar no código.
+
+## Configuration
+
+```yaml
+AN_KE_095:
+  name: "Prompt Over Code for Control"
+  zone: "excelencia"
+  trigger: "Implementando lógica que depende de formato/comportamento ajustável."
+
+  rule: |
+    SE controle pode ser no prompt/config ao invés de no código
+    ENTÃO prompt > code. Mais flexível, mais barato de iterar.
+    "vamos reverter tudo entao e deixar o controle no prompt"
+
+  evidence:
+    - "[SOURCE: sessão 066cd683, Hackathon-Hub] 'vamos reverter tudo entao e deixar o controle no prompt'"
+
+  sys_tension:
+    tension_with: "AN_KE_025 (Determinism Over LLM) vs Prompt Flexibility"
+    resolution: |
+      Prompt é mais barato que código, MAS prompt drift sem versionamento é mais caro que código.
+      Balancear: use prompt para comportamento ajustável, MAS versione prompts (git + prompt_registry.yaml).
+      Sem versionamento → máximo 30 dias antes de risco de drift incontrolável.
+```
+
+## Decision Tree
+
+```javascript
+IF (implementing_behavior_control)
+  CHECK: can this be controlled via prompt/config instead of code?
+    IF (output format) → prompt instruction > code parser
+    IF (evaluation criteria) → prompt rubric > hardcoded scoring
+    IF (behavior toggle) → config flag > if/else in code
+    IF (complex logic with edge cases) → code is appropriate
+  BENEFIT: prompt changes = instant deploy, no build needed
+  RISK: prompt drift — version control prompts like code
+```
+
+## Failure Modes
+
+### O Parser que Deveria Ser Prompt
+- **Trigger:** 200 lines of code to parse LLM output format → could be fixed with 1 prompt line.
+- **Manifestation:** "vamos reverter tudo e deixar o controle no prompt."
+- **Detection:** Code that parses/formats LLM output extensively.
+- **Prevention:** Ask: "can a prompt instruction replace this code?" If yes → prompt > code.
+
+## Validation
+
+✅ **Heurística validada:** Prompt como instrumento de controle é mais eficiente que hardcoding, DESDE QUE prompts sejam versionados como código.
+⚠️ **Tensão sistêmica:** Prompt drift (mudanças não documentadas) pode cancelar todo benefício de flexibilidade. Exigir: `prompt_registry.yaml` + git commits para todas as mudanças de prompt.
+📋 **Critério de aceitação:** Qualquer mudança de prompt deve ser: (1) documentada em git, (2) rastreável em `prompt-changelog.md`, (3) validada contra casos de teste antes de deploy.

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

@@ -0,0 +1,65 @@
+# AN_KE_096 - Raw Import No Transform
+**Zone:** 🔥 20% Impacto | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mmos f10d21b4 — importação de dados sem transformar]
+
+## Purpose
+
+Ao importar dados externos (transcrições, documentos, datasets), importar RAW sem modificar. A IA tem tendência de "limpar" ou "melhorar" dados durante importação, perdendo informação original. Import raw, transform later.
+
+## Configuration
+
+```yaml
+AN_KE_096:
+  name: "Raw Import No Transform"
+  zone: "impacto"
+  trigger: "Importando dados de fontes externas: transcrições, docs, CSVs, APIs."
+
+  rule: |
+    SE importando dados externos
+    ENTÃO importar RAW (sem alterar, sem limpar, sem transformar).
+    Transformação é FASE SEPARADA após importação.
+    Dado original perdido = irrecuperável.
+
+  veto_condition:
+    trigger: "IA 'melhorando' dados durante importação (corrigindo gramática, reformatando, summarizando)."
+    action: "VETO — Import raw. Transform after. Preservar original."
+
+  sys_tension:
+    tension_with: "AN_KE_022 (Format Follows Generator) vs No Transform on Import"
+    resolution: "Preserve raw data FIRST (AN_KE_096), then create transform pipeline with standards. Format divergence resolved in separate transformation phase. Original immutable, processed derivable."
+
+  evidence:
+    - "[SOURCE: sessão f10d21b4] 'nao deve ler com IA, deve pegar todo arquivo (raw) e importar sem alterar'"
+    - "[RELATED] AN_KE_071 (Capture Raw Then Analyze) — 071 foca em API/auth data → JSONB. 096 foca em file imports → preservar arquivo original."
+```
+
+## Decision Tree
+
+```javascript
+IF (importing_external_content: transcription, document, CSV, dataset)
+  STEP_1: SAVE original file AS-IS
+    PRESERVE: encoding, formatting, typos, structure
+    LOCATION: raw/{source}/{date}-{filename}
+  STEP_2: ACKNOWLEDGE import complete
+  STEP_3: TRANSFORM in separate step (never inline)
+    Parse, clean, structure → output to processed/
+    KEEP: original in raw/ untouched
+  NEVER: "improve" text during import (fix grammar, reformat, summarize)
+  DISTINCTION from AN_KE_071: this is FILE content, not API/JSONB data
+```
+
+## Failure Modes
+
+### A Transcrição "Melhorada"
+- **Trigger:** IA importa transcrição de podcast e "limpa" linguagem coloquial automaticamente.
+- **Manifestation:** Nuances, expressões regionais, e tom original perdidos.
+- **Detection:** Imported text sounds formal when source was casual.
+- **Prevention:** "nao deve ler com IA, deve pegar todo arquivo raw e importar sem alterar."
+
+## Validation
+
+**Paradoxo Identificado:** Tensão entre a preservação irrevogável de dados brutos (AN_KE_096) e a necessidade de padronização e limpeza de dados para análise (AN_KE_093, AN_KE_085).
+
+**Resolução:** A heurística estabelece a sequência temporal correta: IMPORT RAW FIRST (immutable), THEN STANDARDIZE in separate pipeline. O original nunca é perdido; transformações são reversíveis via derivação. Isto resolve o paradoxo ao diferenciar átomos (raw data imutable) de moléculas (transformed data ephemeral).
+
+**Critério de Sucesso:** Importação ocorre sem transformação inline. Arquivo original recuperável 100%. Transformações ocorrem em fase separada e rastreável.

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

@@ -0,0 +1,63 @@
+# AN_KE_097 - Fail-Safe Small Batches
+**Zone:** 🔥 20% Impacto | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 6dd07098, mmos — "vamos de 3 em 3 para dar menos risco pro erro"]
+
+## Purpose
+
+Migração ou mutação global de alto risco gera desgaste cognitivo se causar "crash-and-burn" fatal e destruir toda a chain da sessão. Mutações pesadas devem abraçar segurança de escopo por parcelamento (batching). Seja copiando código complexo de migrations pro humano testar, seja varrendo 100 livros (executando aos poucos). Processos críticos precisam ser expostos e verificados ao Humano "de pedaço em pedaço". Reduz carga contextual, zera chance de travar a base com mil erros simultâneos.
+
+## Configuration
+
+```yaml
+AN_KE_097:
+  name: "Fail-Safe Small Batches"
+  zone: "impacto"
+  trigger: "Reescritas massivas de banco de dados, aplicação ou exportando transições grandes em copypast para terminal."
+
+  rule: |
+    SE a operação em andamento envolve volume grande e é arriscada (ex: migrations de sql, correções de centenas de arquivos)
+    ENTÃO subdivida a entrega ou o processamento em lotes extremamente conservadores (ex: batch de 3).
+    Menor risco = Maior recuperabilidade do log local caso rompa o context window com excesso de falhas.
+
+  veto_condition:
+    trigger: "Agente imprime um bloco SQL de 500 linhas que afeta 14 tabelas simultâneas de reestruturação de chave complexa sem aviso ou particionamento."
+    action: "VETO — 'vamos de 3 em 3 para dar menos risco pro erro?'."
+
+  evidence:
+    - "[SOURCE: sessão 6dd07098] 'vamos de 3 em 3 para dar menos risco pro erro? copie 3 migrations aqui para meu copypast'"
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs. Sequential Small Batch Safety"
+    resolution: "Prioritize atomic verification over throughput. Each batch MUST be validated before proceeding, even if total time increases. Recovery from a failed monolithic delivery > time cost of batch sequencing."
+```
+
+## Decision Tree
+
+```javascript
+IF (generating_highly_complex_or_risky_data)
+  STEP_1: QUANTIFY scope of change.
+    IF (volume > safe_tolerance_limit) -> SPLIT INTO CHUNKS.
+  STEP_2: CHUNK 1 (Provide Batch 1 of N)
+    Example: Deliver 3 SQL migrations out of 10.
+  STEP_3: AWAIT validation execution test.
+  STEP_4: IF Success -> Proceed to Next Batch.
+```
+
+## Failure Modes
+
+### Monolithic Crash Delivery
+- **Trigger:** Agente entende o pedido de tradução completa de 8 docs e queima todo a janela em 9800 linhas massivas que param no meio pelo limítrofe falhando pela metade.
+- **Manifestation:** Arquivos quebrados, perda do log histórico por excesso de output (blooming window).
+- **Prevention:** "Divide and Conquer". O Humano processa por etapas sem ansiedade fatal.
+
+## Validation
+
+**Paradox Identified:** Small batches slow immediate output but guarantee system integrity. Safety via constraint > convenience via speed.
+
+**When to Apply:** Any operation affecting >10 files, >5 tables, >100 lines of critical code, or migrations that cannot be easily rolled back.
+
+**Success Criteria:**
+- Each batch completes without context window pressure
+- Human can validate and approve before next batch
+- No failures cascade across batches
+- Recovery is always within reach

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

@@ -0,0 +1,98 @@
+# AN_KE_098 - 100 Tests Before Deterministic (Complex Domains)
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão sinkra-hub 2026-03-30 — correção ao vivo de arquitetura zone-classifier]
+
+## Purpose
+
+Para domínios de EXATAS (contagem, formatação, schema validation), Worker determinístico é seguro desde o dia 1. Para domínios COMPORTAMENTAIS (classificar qualidade, julgar heurísticas, avaliar impacto humano), NÃO automatizar até ter 100+ exemplos validados por humano+LLM. O padrão só emerge com volume de dados de qualidade.
+
+## Configuration
+
+```yaml
+AN_KE_098:
+  name: "100 Tests Before Deterministic (Complex Domains)"
+  zone: "genialidade"
+  trigger: "Propondo automatizar com Worker/script algo que envolve julgamento humano ou análise comportamental."
+
+  rule: |
+    SE domínio é EXATAS (contagem, formato, regex, schema)
+    ENTÃO Worker determinístico AGORA. Zero risco.
+    SE domínio é COMPORTAMENTAL (classificar qualidade, julgar impacto, avaliar unicidade)
+    ENTÃO humano + LLM PRIMEIRO → acumular 100+ testes validados → SÓ ENTÃO extrair padrões determinísticos.
+    Antes de 100 testes, não há dados suficientes pra saber o que é padrão e o que é exceção.
+
+  sys_tension:
+    tension_with: "AN_KE_097 (Fail-Safe Small Batches) vs 100 Testes Antes de Determinismo"
+    description: "Requer 100+ testes validados para automatizar análise comportamental, MAS a própria classificação do domínio (se é comportamental ou exatas) É UMA TAREFA COMPORTAMENTAL que pressupõe semântica. Bootstrap semântico: necessário humano+LLM para validar os primeiros exemplos, estabelecer âncoras semânticas, e SÓ DEPOIS acumular volume."
+    resolution: "Resolver em 3 fases: (1) Humano establece semântica inicial para ~30 exemplos-âncora; (2) LLM infere padrões e gera hipóteses para próximos 70; (3) Padrões validados em 100+ → extrair determinismo. A semântica initial bootstrapeia o volume. Não é sequencial puro; é iterativo."
+
+  veto_condition:
+    trigger: "Criar Worker Python com IF/ELSE para classificar heurísticas em zones de Pareto."
+    action: "VETO — Classificar se algo é 'paradigm-defining' (0.8%) requer entender SIGNIFICADO, não contar campos. Humano+LLM primeiro."
+
+  evidence:
+    - "[SOURCE: sessão 2026-03-30] 'até termos muitos dados de qualidade nao vale a pena criar um worker, primeiro precisamos garantir qualidade com humano e LLM e quando identificarmos padroes solidos, de preferencia acima de 100 testes e entao, temos algo para extrair algo mais deterministico quando diz respeito a analises complexas como comportamento humano, quando nao é algo de exatas'"
+    - "[SOURCE: sessão 2026-03-30] Correção de zone-classifier de Worker→Agent: classificar zona requer entender significado, julgar impacto relativo, avaliar unicidade — tudo semântico"
+```
+
+## Decision Tree
+
+```javascript
+IF (proposing_deterministic_automation)
+  CLASSIFY domain:
+    EXACT_SCIENCE (counting, formatting, regex, schema, paths)
+      → Worker/Script IMMEDIATELY. $0, 100% reliable.
+    BEHAVIORAL (quality judgment, impact assessment, uniqueness, classification)
+      → CHECK: how many validated examples exist?
+        IF (examples < 100)
+          → KEEP as Human + LLM. Accumulate validated data.
+        IF (examples >= 100)
+          → ANALYZE patterns in the 100+ examples
+          → EXTRACT deterministic rules WHERE patterns are solid
+          → KEEP LLM for edge cases where patterns are weak
+```
+
+## Failure Modes
+
+### O Worker Prematuro
+- **Trigger:** Criar IF/ELSE Python para classificar heurísticas como 0.8%/4%/20%/80%.
+- **Manifestation:** Worker classifica "reality_arbitration" (paradigm-defining para Elon Musk) como 20% porque não tem campo "is_unique=true". O script não entende semântica.
+- **Detection:** Classificações absurdas: heurísticas de genialidade classificadas como impacto genérico.
+- **Recovery:** Reverter para Human+LLM até ter dados de treinamento suficientes.
+- **Prevention:** Regra dos 100: SÓ automatizar domínio comportamental após 100+ exemplos validados.
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "deterministic-maturity-gate"
+  heuristic: AN_KE_098
+  phase: "Automation_Architecture"
+
+  validation_questions:
+    - "Esse domínio é exatas ou comportamental?"
+    - "SE comportamental: temos 100+ exemplos validados por humano?"
+    - "SE < 100: quem vai julgar até lá? (Human+LLM)"
+```
+
+## Validation
+
+**Semântica Inicial (Fases 1-2):**
+- [ ] Humano estabeleceu semântica em 20-30 exemplos-âncora?
+- [ ] LLM consegue gerar hipóteses baseado nas âncoras?
+- [ ] Hipóteses validadas em ≥50% dos casos novos?
+
+**Volume & Padrão (Fase 3):**
+- [ ] Acumulado ≥100 exemplos com semântica consistente?
+- [ ] Padrões comportamentais emergem em ≥70% da massa?
+- [ ] Existe margem semântica para exceções (≤30%)?
+
+**Determinismo (Após Phase 3):**
+- [ ] Worker proposto cobre padrão majoritário (≥70%)?
+- [ ] LLM retém casos de borda (exceções semânticas)?
+- [ ] Coexistência Worker+LLM testada em batch?
+
+**Paradoxo Resolvido?**
+- [ ] Tensão com AN_KE_097 documentada e aceita?
+- [ ] Bootstrap semântico inicial internalizado pelo time?
+- [ ] Diferenciação clara entre EXATAS (determinismo dia 1) e COMPORTAMENTAL (fase 3)?

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

@@ -0,0 +1,97 @@
+# AN_KE_099 - CLAUDE.md as Living Config
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: 7+ instâncias cross-project (mentelendaria, mmos, sinkra-hub) — salve/adicione no CLAUDE.md]
+
+## Purpose
+
+Meta-heurística: CLAUDE.md (e equivalentes AGENTS.md, GEMINI.md) NÃO é documentação — é CONFIG VIVA do agente. Mas a evidence revela algo mais sutil que "salve tudo": Alan trata o arquivo com DISCIPLINA de engenharia — confere regras existentes antes de adicionar ("eu já tenho algumas regras no claude.md confira todas elas"), pede síntese e compactação ("se tivesse que sintetizar em apenas mais 3 quais deveriam ser?"), e exige que só o essencial entre ("colocar só o essencial dentro de claude.md"). Não é dump de regras — é curadoria ativa de config com pressão constante contra bloat.
+
+## Configuration
+
+```yaml
+AN_KE_099:
+  name: "CLAUDE.md as Living Config"
+  zone: "excelencia"
+  trigger: "Descoberta de regra/padrão durante sessão, OU revisão do arquivo de config do agente."
+  sys_tension:
+    tension_with: "AN_KE_038 (Gap de Reasoning = Processo Vago)"
+    resolution: "Salve immediato (persistence), mas SEMPRE leia+sintetize+comprima (curation). Paradoxo resolvido via audit periódico: regras persistem, bloat não."
+
+  rule: |
+    SE descobriu regra/padrão/constraint durante sessão
+    ENTÃO avaliar se é persistente (cross-session) ou efêmera (este task).
+    SE persistente:
+      (1) LER config atual PRIMEIRO — conferir se já existe regra similar
+      (2) SINTETIZAR nova regra na menor forma possível
+      (3) SALVAR imediatamente — "later" = never
+    SE efêmera → NÃO pollute o config — manter em contexto da task
+    MANUTENÇÃO: periodicamente auditar e comprimir regras (só essencial).
+
+  veto_condition:
+    trigger: "Sessão terminando com regra persistente não salva, OU adição de regra sem conferir existentes."
+    action: "VETO — 'eu já tenho algumas regras no claude.md confira todas elas.' Leia antes de adicionar. Sintetize."
+
+  evidence:
+    - "[SOURCE: sessão c0429238, mentelendaria] 'adicione no seu CLAUDE.MD jamais, NUNCA em hipotese alguma, assine algum documento como Claude'"
+    - "[SOURCE: sessão a5d42042, mentelendaria] 'salve isso no seu Claude.md'"
+    - "[SOURCE: sessão 017a1f24, mmos] 'vamos evitar usar em arquivos, v2, v3, isso está inclusive como regra em claude.md'"
+    - "[SOURCE: sessão 55333ac6, mmos] 'eu já tenho algumas regras no claude.md confira todas elas'"
+    - "[SOURCE: sessão dc677053, mmos] 'sim, concordo, e as outras regras precisamos documentar tb e colocar só o essencial dentro de claude.md'"
+    - "[SOURCE: sessão d829ca37, mmos] 'Quais regras similares a estas já temos em claude.md? e se tivesse que sintetizar em apenas mais 3 quais deveriam ser adicionadas?'"
+    - "[PATTERN] 7+ instâncias cross-project confirmam: CLAUDE.md = runtime config com disciplina de engenharia (ler, sintetizar, comprimir), não dump de regras"
+```
+
+## Decision Tree
+
+```javascript
+IF (rule_or_pattern_discovered_during_session)
+  STEP_1: CLASSIFY persistence
+    IF (applies cross-session, cross-project) → PERSISTENT → proceed
+    IF (applies only to this task/sprint) → EPHEMERAL → do NOT add to config
+
+  STEP_2: CHECK existing config FIRST
+    READ: current CLAUDE.md / AGENTS.md / GEMINI.md
+    SEARCH: similar rule already exists?
+      IF (exact match) → SKIP, do not duplicate
+      IF (partial match) → MERGE/STRENGTHEN existing rule
+      IF (no match) → proceed to add
+
+  STEP_3: SYNTHESIZE for minimal footprint
+    FORMAT: clear rule statement, not prose
+    LENGTH: 1-2 lines if possible ("se não cabe em 1 linha, não extraiu direito" — AN_KE_008)
+    AUDIT: "quais regras similares a estas já temos? se tivesse que sintetizar em apenas mais 3?"
+
+  STEP_4: SAVE immediately
+    TIMING: DURING session, not "later" — later = never
+    TARGET: whichever config file is active (CLAUDE.md, AGENTS.md, GEMINI.md)
+
+  MAINTENANCE (periodic):
+    AUDIT: ler todas as regras — remover redundantes
+    COMPRESS: "colocar só o essencial"
+    QUESTION: "se tivesse que sintetizar em apenas mais 3 quais deveriam ser?"
+
+  NEVER: end session with unsaved persistent rule
+  NEVER: add without reading existing rules first (causes bloat)
+  RELATED: AN_KE_079 (Cross-Session Context), AN_KE_072 (doc rot applies to config too)
+```
+
+## Failure Modes
+
+### O Config que Virou Dump
+- **Trigger:** Every session adds 2-3 rules. After 20 sessions, CLAUDE.md has 60 rules — half redundant.
+- **Manifestation:** AI confused by contradicting rules. Performance degrades.
+- **Detection:** `wc -l CLAUDE.md` > 200 lines. Rules contradict each other.
+- **Prevention:** Periodic audit: "se tivesse que sintetizar em apenas mais 3?" Compress. "colocar só o essencial."
+
+## Validation
+
+**Paradoxo Identificado:** "Salvar imediatamente (urgência de persistence)" VS "Conferir/sintetizar antes (disciplina contra bloat)"
+
+**Resolução:** O paradoxo é falso. Alan não quer velocidade descontrolada — quer **velocidade com rigor**. O movimento é:
+1. Encontra padrão → Classifica (persistente? efêmero?)
+2. SE persistente → lê existentes PRIMEIRO (não é impulso, é check)
+3. Sintetiza na forma mínima (NUNCA poliglota)
+4. Salva NO MESMO TURNO (não procrastina)
+5. Periodicamente: audita tudo, remove redundância, recomprime
+
+Não há conflito entre "salvar logo" e "curar antes". São **fases sequenciais do mesmo ciclo**, não trade-offs. O "veto" só ocorre quando pula (2) ou (3).

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

@@ -0,0 +1,100 @@
+# AN_KE_100 - Reverse Engineer Your Reasoning
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões sinkra-hub 5eb9bf45 (audit heurísticas), 0f1fe148 (validate-skill/squad)]
+
+## Purpose
+
+Meta-heurística suprema: quando completa processo complexo com resultado bom, FAZER ENGENHARIA REVERSA do próprio raciocínio e documentar como processo reprodutível. Mas a evidence do history revela que Alan não espera apenas um post-mortem no final — ele pede meta-extração DURANTE o processo ("Quais heuristicas podemos tirar de todo processo que estamos fazendo?") e COMPARTILHAMENTO entre ferramentas ("o que pode ser aproveitado entre eles que nao estamos aproveitando?"). A recursividade é tripla: (1) o processo de criar heurísticas É uma heurística, (2) o processo de compartilhar lógica entre scripts É um padrão ("log que é criado poderia ser compartilhado entre todos"), (3) o process-heuristic-mining-from-history.md que documenta ESTE processo é produto DESTA heurística.
+
+## Configuration
+
+```yaml
+AN_KE_100:
+  name: "Reverse Engineer Your Reasoning"
+  zone: "genialidade"
+  trigger: "Completou processo complexo com resultado de alta qualidade, OU identificou lógica reutilizável durante execução."
+  sys_tension:
+    tension_with: "AN_KE_025 (Determinism Over LLM) — parar para reverse-engineer quebra fluxo determinístico"
+    resolution: "Extrair heurísticas DURANTE execução (não bloqueia), validar e compartilhar POST-MORTEM paralelo"
+
+  rule: |
+    SE completou processo complexo com resultado bom
+    ENTÃO fazer engenharia reversa do próprio raciocínio em 3 tempos:
+      (1) DURANTE: "quais heurísticas podemos tirar de todo processo que estamos fazendo?"
+      (2) AO TÉRMINO: documentar como processo reprodutível por outras LLMs
+      (3) CROSS-TOOL: "o que pode ser aproveitado entre eles que não estamos aproveitando?"
+    O processo de criar heurísticas É uma heurística.
+    O processo de compartilhar lógica É um padrão.
+
+  veto_condition:
+    trigger: "Resultado excelente obtido sem: (a) extrair heurísticas durante o processo, (b) documentar reasoning post-mortem, (c) identificar lógica compartilhável."
+    action: "VETO — 'quando conclui faça engenharia reversa do seu reasoning para transformarmos em processo documentado. Isso por si só é material para heurística.'"
+
+  evidence:
+    - "[SOURCE: sessão 5eb9bf45, sinkra-hub] 'quando conclui faca uma engenharia reversa do seu reasoning para transforamrmos isso em um processo documentado que outras LLMs ou voce poderá executar isso no futuro, isso por si só já é material para uma heuristica'"
+    - "[SOURCE: sessão 0f1fe148, sinkra-hub] 'Quais heuristicas podemos tirar de todo processo que estamos fazendo?'"
+    - "[SOURCE: sessão 0f1fe148, sinkra-hub] 'o que pode ser aproveitado entre eles que nao estamos aproveitando?' + 'o log que é criado, nao poderia ser compartilhado entre todos tb?'"
+    - "[META] Esta heurística é auto-referencial: foi criada pelo processo que ela descreve. A sessão 5eb9bf45 auditou os cards 060-100. O process-heuristic-mining-from-history.md é output direto desta heurística."
+```
+
+## Decision Tree
+
+```javascript
+IF (executing_complex_process)
+  DURING_EXECUTION:
+    QUESTION: "quais heurísticas podemos tirar deste processo?"
+    IF (pattern_spotted) → NOTE for later formalization
+    IF (reusable_logic_spotted) → FLAG: "isso pode ser compartilhado com X?"
+
+  ON_COMPLETION:
+    STEP_1: PAUSE — do not move to next task yet
+    STEP_2: REVERSE-ENGINEER reasoning
+      WHAT: exact sequence of decisions made
+      WHY: rationale for each branching point
+      WHICH: alternatives rejected and why
+      WHERE: logic that could be shared between tools
+    STEP_3: DOCUMENT as reproducible process
+      FORMAT: step-by-step with decision gates (not prose)
+      AUDIENCE: future self or another LLM executing same task
+      DELIVERABLE: process .md file (like process-heuristic-mining-from-history.md)
+    STEP_4: EXTRACT meta-patterns
+      IF (process reveals new heuristic) → CREATE new AN_KE card
+      IF (process confirms existing heuristic) → ADD evidence to existing card
+      IF (logic is shared between tools) → EXTRACT to shared module (DRY)
+
+  CROSS-TOOL CHECK (periodic):
+    COMPARE: validate-skill vs validate-squad vs sinkra-map
+    QUESTION: "o que pode ser aproveitado entre eles?"
+    IF (shared logic found) → EXTRACT to shared lib (AN_KE_007 REUSE > CREATE)
+
+  NEVER: finish excellent work without capturing the process that produced it
+  NEVER: build similar tool without checking what can be shared from existing
+```
+
+## Failure Modes
+
+### A Sessão Brilhante que Ninguém Reproduz
+- **Trigger:** LLM executa pipeline perfeitamente mas não documenta o raciocínio.
+- **Manifestation:** Próxima sessão tenta reproduzir → resultado medíocre porque reasoning steps são diferentes.
+- **Detection:** Qualidade inconsistente entre sessões para mesma tarefa.
+- **Prevention:** Post-mortem obrigatório: "como cheguei neste resultado? documentar."
+
+### Os Três Scripts que Fazem a Mesma Coisa
+- **Trigger:** validate-skill.sh, validate-squad.sh, sinkra-map.sh criados independentemente.
+- **Manifestation:** "o que pode ser aproveitado entre eles que nao estamos aproveitando?" + "o log poderia ser compartilhado entre todos?"
+- **Detection:** Diff de scripts mostra 60%+ de lógica duplicada (logging, model routing, phase patterns).
+- **Prevention:** CROSS-TOOL CHECK antes de criar nova ferramenta. Extrair shared lib primeiro.
+
+---
+
+## Validation
+
+**Paradoxo Identificado:** Meta-análise (observar o próprio reasoning) vs. Ação (executar tarefa). A heurística que extrai heurísticas cria auto-referência.
+
+**Tensão Sistêmica:**
+- Interromper execução para extrair padrões = custo de contexto + latência
+- Não extrair = perder insights + duplicação de esforço em futuros projetos
+
+**Resolução:** Análise paralela pós-execução (não-bloqueante). Task post-mortem iniciada APÓS conclusão da tarefa principal, preservando fluxo e capturando insights de forma assíncrona.
+
+**Status:** ✓ Validado | Raciocínio reproduzível; evidência documental presente (sessões 5eb9bf45, 0f1fe148); auto-aplicabilidade confirmada.

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

@@ -0,0 +1,62 @@
+# AN_KE_101 - Framework Strict Isolation
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão aiox-core/arquitetura — "misturando framework com expansão"]
+
+## Purpose
+
+A fundação do AIOX e do framework SINKRA v3.1 reside na agnosticidade total do core operacional. Injetar configurações específicas de domínios corporativos (`scan-registry.yaml`, por exemplo), tokens de clientes, ou rotas personalizadas dentro do núcleo base (`.aiox-core`) destrói a portabilidade do repositório. O núcleo é a engrenagem pura; qualquer injeção de "negócio" DEVE acontecer via *Expansion Packs*, `squads/`, ou `.Codex/`, garantindo encapsulamento da máquina.
+
+## Configuration
+
+```yaml
+AN_KE_101:
+  name: "Framework Strict Isolation"
+  zone: "genialidade"
+  trigger: "Modificando scripts, ferramentas ou pastas vitais de `.aiox-core` com dados pontuais da sessão local."
+
+  rule: |
+    SE você encontrar um script que requer dados específicos do negócio ou de um client
+    ENTÃO externalize o payload de dados do framework básico (`.aiox-core`).
+    NUNCA coloque lógica hardcoded de projeto dentro do Core Agnóstico.
+    O sistema DEVE sobreviver como open-source intacto. Toda camada de bussiness é um pacote isolado.
+
+  veto_condition:
+    trigger: "Agente cria estrutura `.aiox-core/lib/scan-registry.yaml` para rastrear processos do workspace do usuário."
+    action: "VETO — 'Você tem razão absoluta! Estava misturando framework com expansão. ❌ Estrutura Errada... NÃO deveria ter dados do projeto'."
+
+  evidence:
+    - "[SOURCE: histórico manual] 'Estava misturando framework com expansão. Vamos corrigir: ❌ Estrutura Errada (que propus) .aiox-core/ # Framework - NÃO deveria ter dados do projeto'"
+
+  sys_tension:
+    - tension_with: "AN_KE_026 (Squad Agnosticism) vs Complexidade de Parsing Local"
+      resolution: "AN_KE_101 impõe purismo agnóstico ao core framework, enquanto AN_KE_026 demanda agnosticismo de squads em relação a domínios; paradoxo resolvido via Expansion Packs como camada intermediária que encapsula injeção de negócio sem poluir base"
+```
+
+## Decision Tree
+
+```javascript
+IF (adding_new_feature_to_core_architecture)
+  STEP_1: IDENTIFY domain (Is this generic orchestration code OR business-specific tracking?)
+  STEP_2: IF (Business/Project specific)
+    -> ROUTE to `squads/*` OR `workspace/*` OR `expansion-packs/*`.
+    -> DISCARD changes mapped to `.aiox-core/`.
+  STEP_3: IF (Generic Orchestration)
+    -> APPEND to `.aiox-core/` while preserving parameter injection instead of hardcoded state.
+```
+
+## Failure Modes
+
+### Monolithic Core Pollution
+- **Trigger:** Configurações de "AllFluence" e integrações do ClickUp vazam para arquivos base em `.aiox-core`.
+- **Manifestation:** Qualquer clone do repositório base que queira montar uma arquitetura para Hospital ou EdTech falhará tentando resolver keys do "AllFluence".
+- **Prevention:** Isolação purista. O Framework não possui DNA proprietário, ele o invoca.
+
+## Validation
+
+✓ **Paradox Identified:** Purismo agnóstico (.aiox-core) vs. Necessidade operacional de rastreamento/contexto do projeto.
+
+✓ **Tension Resolved:** sys_tension aponta para AN_KE_070 (Dynamic Expansion) como mecanismo de resolução — Expansion Packs permitem injeção sem poluição do core.
+
+✓ **Evidence Chain:** Manual history confirms veto of `.aiox-core/lib/scan-registry.yaml` como erro arquitetural; caminho correto é `squads/*/config.yaml` + `workspace/` + `expansion-packs/`.
+
+✓ **Heuristic Stability:** Rule is deterministic and falsifiable — qualquer adição de dados-specificos ao `.aiox-core` viola a heurística.

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

@@ -0,0 +1,65 @@
+# AN_KE_102 - LLM Downgrade Defense
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 74ce8793, aiox-stage — "sem precisarmos de LLM no futuro"]
+
+## Purpose
+
+Inteligência Artificial de ponta (Claude 3.7 Sonnet) é uma ferramenta para orquestração, decisão arquitetural pesada e raciocínios caóticos, e não um estivador para arrumar arquivos estáticos se a regex faz isso. O Alan detesta processos escaláveis onde a automação diária torra dezenas de tokens cegamente. Ao construir um worker ou pipeline persistente, o desenvolvedor DEVE rastrear o padrão determinístico da tarefa. Se inevitável, adote downgrade de inferência: delegar processos repetitivos estritos para os Tiers inferiores de LLMs (Haiku / 8B local).
+
+## Configuration
+
+```yaml
+AN_KE_102:
+  name: "LLM Downgrade Defense (Deterministic First)"
+  zone: "genialidade"
+  trigger: "Desenhando extrações massivas, processadores cron-like ou conversores ETL de dados rotineiros."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — escalabilidade via múltiplos subagents vs. simplificar para Haiku determinístico"
+    resolution: "Piramide de seleção: Regex/Script (zero cost) → Haiku para classificação simples → Sonnet para decisão arquitetural pesada. A falha é usar Sonnet onde Regex serve."
+
+  rule: |
+    SE a tarefa trata manipulação em scale (parse de imagens, split de blocos textuais)
+    ENTÃO PRIORIDADE ABSOLUTA: Construir via JavaScript/Bash (puro determinismo, custo zero).
+    SE impossível ser determinista → Delegue prompt em `system` rígido para LLMs nível Haiku/Flash.
+    Somente instâncias cerebrais críticas necessitam instanciar Tiers Master.
+
+  veto_condition:
+    trigger: "Codar um script Python que invoca o `claude-3-7-sonnet` para parsear IDs e Datas explícitos de dentro de uma lista markdown de 8.000 linhas."
+    action: "VETO — 'tente entender o padrao que permitiria um script conseguir replicar isso, sem precisarmos de LLM... ou criar um prompt para uma LLM mais barata Haiku...'"
+
+  evidence:
+    - "[SOURCE: sessão 74ce8793, aiox-stage] 'tente entender o padrao que permitiria um script conseguir replicar isso, sem precisarmos de LLM no futuro, ou entao criar um prompt para que uma LLM mais barata com Haiku faca esse trabalho'"
+```
+
+## Decision Tree
+
+```javascript
+IF (creating_automation_for_repetitive_processing)
+  STEP_1: CHALLENGE the LLM usage. (Does it require reasoning OR just pattern matching?)
+  STEP_2: IF (Pattern Matching possible via Regex/DOM Parse/JSON path)
+    -> Build a standard Script. Drop AI dependency.
+  STEP_3: IF (Simple Reasoning required like minor classification)
+    -> Adopt Claude-3-Haiku endpoint config.
+  STEP_4: IF (Deep Context understanding required)
+    -> Adopt Sonnet tier.
+```
+
+## Failure Modes
+
+### Burn Rate Arquitetônico
+- **Trigger:** Pipeline de ingestão roda chamadas API de reasoning pesado para cada log capturado da Vercel para identificar se foi "Erro TS" ou "Aviso CSS".
+- **Manifestation:** Fatura Cloud Anthropic atinge $1k em 3 dias testando lixo trivial.
+- **Prevention:** Pipeline Defense. Programação clássica em primeiro lugar para jobs operacionais.
+
+---
+
+## Validation
+
+✓ **Paradoxo identificado:** A heurística prescreve usar LLMs avançados para decisões críticas ao mesmo tempo que veda seu uso em tarefas determinísticas, criando tensão entre custo/capacidade.
+
+✓ **Resolução declarada:** Pirâmide de delegação (Regex → Haiku → Sonnet) garante que cada nível de complexidade use o modelo apropriado.
+
+✓ **Applicability:** Crítica para pipelines de produção, ETL em escala e automações de longo prazo onde burn rate é mensurável.
+
+Status: **VALID** — Paradoxo capturado, tensão resolvida via `sys_tension` field.