aiox-core 5.0.5 → 5.0.7

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

@@ -0,0 +1,67 @@
+# AN_KE_070 - Multi-IDE Sync Protocol
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 05e78370, aiox-stage — "vamos sincronizar sempre para claude"]
+
+## Purpose
+
+Alan utiliza um ecossistema complexo (Claude Code, Gemini, Roo, Cursor). Sempre que construímos scripts geradores ou `agents/workflows`, o design deve considerar portabilidade. Comandos globais (`/command`) e lógica de agente de profunda imersão funcionam de forma nativa apenas onde dão match absoluto (como no Claude CLI ou terminal de alta confianca), enquanto *nos outros* deve ser convertido apenas como *skills* (ferramentas passivas limitadas). Modificar em um significa propagar ao outro na medida da sua utilidade, garantindo sincronia transversal dos IDEs.
+
+## Configuration
+
+```yaml
+AN_KE_070:
+  name: "Multi-IDE Sync Protocol"
+  zone: "excelencia"
+  trigger: "Modificando scripts, agentes ou comandos CLI que impactam configurações dos IDEs AI."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs Centralização Sequencial do Sync"
+    resolution: "Centralizar em Claude Code como source-of-truth para commands/agents. Expor via skills em outros IDEs. Skills são conversas assincrónicas; commands são sincronizações CLI. Não gerar conflito de ativação: uma feature = um ponto de entrada + múltiplas formas de consumo."
+
+  rule: |
+    SE você criar ou atualizar commands ou skills para a base principal
+    ENTÃO DEVE sincronizar transversalmente respeitando o ecossistema local.
+    Claude Code recebe os pesos pesados (commands e agents).
+    Gemini/Roo e outros recebem versões em formato de skill.
+    O AIOX DEVE estar alinhado transversalmente.
+
+  veto_condition:
+    trigger: "Agente cria um feature amarrado estritamente ao framework Gemini que destrói as dependências do Claude Code, sem gerar skill isolada."
+    action: "VETO — 'nos outros todos precisa ser apenas skill'."
+
+  evidence:
+    - "[SOURCE: sessão 05e78370, aiox-stage] 'vamos sincronizar sempre para claude /command e /agents, nos outros apenas o que eles tem compatibilidade, até onde sei nos outros todos precisa ser apenas skill'"
+```
+
+## Decision Tree
+
+```javascript
+IF (creating_or_updating_workflow_agent_skill)
+  STEP_1: IDENTIFY execution context (Is this heavy orchestration or basic capability?)
+  STEP_2: For CLAUDE CODE (Core Orchestration):
+    -> Save as complex agent/command
+  STEP_3: For GEMINI / ROO / OTHERS (Task Execution):
+    -> Map strictly as a Skill, preventing incompatible IDE crashes.
+  STEP_4: Verify git sync status across workspaces.
+```
+
+## Failure Modes
+
+### Quebra Incompatível de IDE
+- **Trigger:** Configurações ou comandos do Cursor copiam cegamente hooks de CLI do Claude.
+- **Manifestation:** Todos os IDEs paralelos perdem compatibilidade e dão erro ao renderizar custom skills.
+- **Detection:** Analisar arquivos `manifest.json` ou configs locais de `.gemini`/`.claude`.
+- **Prevention:** Isolar implementações passivas (skills) de implementações ativas (commands/activators).
+
+## Validation
+
+**✓ Paradoxo Identificado:** Sincronização transversal vs. Isolamento por IDE (Cada IDE pressiona por customização nativa; sincronização exige compatibilidade universal)
+
+**✓ Resolução Aplicada:** Hierarchy clara — Claude Code = authority (source-of-truth); Outros IDEs = skill-based consumers (async, compatible)
+
+**✓ Enforcement:** Before pushing any command/agent update, verify via ide-sync validator:
+```bash
+node .aiox-core/infrastructure/scripts/ide-sync/index.js validate --strict
+```
+
+**✓ Mapped Tensions:** Connected heuristics (AN_KE_018, AN_KE_042) document complementary principles

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

@@ -0,0 +1,87 @@
+# AN_KE_071 - Capture Raw Then Analyze
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mmos 330de299 — raw_user_meta_data durante criação de usuários/minds]
+
+## Purpose
+
+Counter-intuitive: ao receber dados externos, NÃO tentar parse/transform na entrada. Salvar RAW primeiro, analisar DEPOIS. Mas a frase completa de Alan revela uma nuance crucial: "mas criar e associar com mind é fundamental, é requisito mínimo na criação de usuários." Raw capture é SAFETY NET, não substituto de modelagem. A prioridade é: (1) criar a entidade de negócio (mind, user, clone), (2) salvar raw como backup, (3) analisar e extrair depois. O raw garante que dados nunca se perdem, mas o modelo de negócio ainda vem primeiro.
+
+## Configuration
+
+```yaml
+AN_KE_071:
+  name: "Capture Raw Then Analyze"
+  zone: "excelencia"
+  trigger: "Recebendo dados de fonte externa: auth callback, webhook, CSV import, API response, scrape."
+
+  rule: |
+    SE recebendo dados externos (auth, webhook, import, scrape)
+    ENTÃO 3 steps em ordem:
+      (1) CRIAR entidade de negócio (user, mind, clone) — requisito mínimo
+      (2) SALVAR raw payload em JSONB sem transformação — safety net
+      (3) ANALISAR e extrair campos estruturados — segundo passo
+    Raw capture é backup. Modelo de negócio vem primeiro.
+    Dados perdidos na importação = irrecuperáveis.
+
+  veto_condition:
+    trigger: "Transform/parse dados externos inline sem: (a) criar entidade de negócio primeiro, ou (b) salvar raw como backup."
+    action: "VETO — 'criar e associar com mind é fundamental, é requisito mínimo.' Entidade de negócio PRIMEIRO, raw como safety net."
+
+  sys_tension:
+    tension_with: "AN_KE_088 (The Sequential Pipeline Truth) vs Atomicidade Paralela"
+    description: "A regra diz 'capture raw THEN analyze' (temporal: raw primeiro), mas a evidência enfatiza 'criar entidade é requisito MÍNIMO' (lógico: negócio primeiro). AN_KE_088 veta paralelismo ('Anti-Parallelism Illusion'), enquanto AN_KE_071 recomenda Steps 1+2 atômicos/paralelos. Qual vem primeiro na sequência real?"
+    resolution: "Temporal e lógico são ortogonais. Logicamente, entidade de negócio é pré-requisito (Step 1). Temporalmente, raw capture ocorre em paralelo ou logo após (Step 2), MAS dentro de uma transação atômica (nenhuma race condition). A ordem de execução é: (1) create entity ATOMICALLY + (2) save raw IMMEDIATELY + (3) analyze async (true parallelism permitido apenas para Step 3). AN_KE_071 respeita sequência lógica (entity first) mas permite paralelização de I/O dentro da transação."
+
+  evidence:
+    - "[SOURCE: sessão 330de299, mmos] 'podemos sempre salvar nas importacoes e gravar tudo que chegou em raw_user_meta_data e depois analisar o que pode ser feito com esse dado, desta forma nao perdemos ele, o que acha? mas criar e associar com mind é fundamental, é requisito minimo na criacao de usuários'"
+    - "[CONTEXT] A frase revela prioridade: business entity (mind) = requisito mínimo → raw capture = safety net → analysis = second pass"
+```
+
+## Decision Tree
+
+```javascript
+IF (receiving_external_data)
+  STEP_1: CREATE business entity FIRST
+    // "criar e associar com mind é fundamental, é requisito mínimo"
+    IF (user import) → create user + create mind + associate
+    IF (clone creation) → create clone entry + link to mind
+    IF (auth callback) → create/update user profile
+    RULE: entity creation CANNOT fail silently
+
+  STEP_2: SAVE raw payload as backup
+    IF (database) → JSONB column: raw_data, raw_user_meta_data, raw_payload
+    IF (file import) → preserve original file alongside parsed version
+    IF (webhook) → log full request body in audit table
+    NEVER: transform-and-discard in a single step
+
+  STEP_3: ACKNOWLEDGE receipt
+    Return 200 OK / success to caller
+    Raw is saved — processing can happen async
+
+  STEP_4: ANALYZE and extract (async/deferred)
+    EXTRACT: structured fields from raw JSONB
+    VALIDATE: extracted values against schema
+    STORE: typed columns from validated data
+    IF (extraction fails) → raw is preserved, retry later
+
+  PRIORITY ORDER: business entity > raw capture > extraction > structured storage
+  NEVER: skip Step 1 (entity) to rush Step 4 (extraction)
+```
+
+## Failure Modes
+
+### O Usuário sem Mind
+- **Trigger:** Import pipeline salva raw_user_meta_data mas esquece de criar entidade mind.
+- **Manifestation:** Usuário existe no auth mas não tem mind associada — funcionalidade core quebrada.
+- **Detection:** `SELECT u.id FROM users u LEFT JOIN minds m ON u.id = m.user_id WHERE m.id IS NULL`
+- **Prevention:** Step 1 (create entity) é prerequisite bloqueante. Raw capture (Step 2) não substitui.
+
+## Validation
+
+✅ **Paradoxo Identificado:** Ordem temporal (raw primeiro) vs. Ordem lógica (entidade primeiro) — **RESOLVIDO** via paralelização atômica (Steps 1+2 executam juntos, Step 3 é async).
+
+✅ **sys_tension Adicionado:** Campo YAML documenta a tensão e sua resolução.
+
+✅ **Coerência Confirmada:** A heurística mantém força: entidade de negócio é inviolável (requisito mínimo), raw capture é inviolável (nunca perder dados), análise é flexível (deferred).
+
+**Status:** Refatoração completa. Heurística pronta para uso em pipelines de import.

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

@@ -0,0 +1,84 @@
+# AN_KE_072 - Code Over Documentation
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos 4404bc3e, 3cbfc9d5 — doc rot awareness + pivot para doc-rot detector]
+
+## Purpose
+
+Código funcional > documentação. Não como preferência casual — como PRINCÍPIO ARQUITETURAL. Documentação desatualizada (doc rot) é PIOR que zero doc porque induz ações erradas. A evolução do pensamento de Alan é reveladora: (1) primeiro percebeu que doc rot existia ("estamos melhorando ou criando doc rot?"), (2) depois cristalizou a hierarquia ("code > doc, codigo funcional é real"), (3) finalmente pivotou uma tool de anotação para DETECÇÃO de doc rot — ou seja, transformou uma ferramenta de CRIAR documentação em uma ferramenta de DELETAR documentação. Esse pivot é a evidence mais forte: a ação mais valiosa sobre documentação é SUBTRAÇÃO, não adição.
+
+## Configuration
+
+```yaml
+AN_KE_072:
+  name: "Code Over Documentation"
+  zone: "genialidade"
+  trigger: "Decisão entre investir tempo em documentação vs código funcional, ou IA gerando documentação sem ser solicitada."
+
+  rule: |
+    Hierarquia absoluta: Código funcional > documentação. Sempre.
+    DELETAR doc podre > CRIAR doc novo > NÃO documentar > Documentar código instável.
+    A ação mais valiosa sobre documentação é SUBTRAÇÃO.
+    SE código está mudando → NÃO documentar (vai virar doc rot).
+    SE doc existente está stale → DELETAR (mais valioso que criar novo).
+    SE doc existente está correta → NÃO tocar (não duplicar, não expandir).
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents) vs Complexidade de Parsing Local"
+    resolution: "Documentação é PROIBIDA exceto em 3 casos: (1) API pública com SLA (code > docs, mas código + spec < nenhum contrato), (2) regulatory/legal (contract força), (3) onboarding crítico (investir em code design primeiro, docs secundário). Em 90% dos casos, a resposta é DELETAR não CRIAR."
+
+  veto_condition:
+    trigger: "IA gerando documentação extensa para código instável, ou expandindo doc sem ser solicitada."
+    action: "VETO — 'estamos melhorando ou criando doc rot?' Pergunte antes de documentar. Prefira code auto-documentado."
+
+  evidence:
+    - "[SOURCE: sessão 4404bc3e, mmos] 'code > doc, codigo funcional é real, documentar é criar DOC ROT'"
+    - "[SOURCE: sessão 3cbfc9d5, mmos] 'estamos melhorando ou criando doc rot?'"
+    - "[SOURCE: sessão 3cbfc9d5, mmos] 'vamos testar só mais uma vez e talvez possamos transformar ela não em anotação, mas de descobrir conteudo podre doc rot para deletar'"
+    - "[PATTERN] Skill doc-rot nasceu durante sessão 3cbfc9d5: pivot de ferramenta de ANOTAÇÃO para ferramenta de DETECÇÃO/DELEÇÃO de doc rot — prova material do princípio"
+```
+
+## Decision Tree
+
+```javascript
+IF (documentation_decision)
+  STEP_0: HIERARCHY CHECK
+    DELETE stale doc > CREATE new doc > DO NOTHING > Document unstable code
+
+  STEP_1: EXISTING DOC found?
+    IF (exists AND stale) → PRIORITY: DELETE IT (higher value than creating new)
+    IF (exists AND accurate) → KEEP AS-IS, do NOT expand, do NOT duplicate
+    IF (not exists) → proceed to Step 2
+
+  STEP_2: CODE STABILITY check
+    IF (code actively changing) → DO NOT DOCUMENT — code will change, doc will rot
+    IF (code stable > 2 sprints) → MINIMAL documentation only:
+      - Types/interfaces as documentation (self-documenting)
+      - 1-line comments for non-obvious WHY (never WHAT)
+      - README only if externally consumed
+
+  STEP_3: AI DOCUMENTATION CHECK
+    IF (AI generating docs without being asked) → STOP
+    IF (AI expanding existing docs) → STOP, ask "estamos melhorando ou criando doc rot?"
+    IF (human explicitly asked for docs) → MINIMAL, focused, timestamped
+
+  NEVER: generate verbose documentation "for completeness"
+  PREFER: code with good names + types > external docs
+  INSIGHT: if you find yourself wanting a doc-rot detector, the principle is working
+```
+
+## Failure Modes
+
+### A Anotação que Vira Doc Rot
+- **Trigger:** Ferramenta de anotação (@llm-context) gera anotações que desatualizam em dias.
+- **Manifestation:** "estamos melhorando ou criando doc rot?" — pergunta durante revisão da tool.
+- **Detection:** Doc/anotação descreve estado que não corresponde ao código atual.
+- **Recovery:** Pivot: transformar a ferramenta de CRIAR anotações em DETECTAR doc rot. A melhor doc tool é a que DELETA docs.
+- **Prevention:** Antes de criar doc, perguntar: "quanto tempo até isso ficar desatualizado?" Se < 1 mês → não criar.
+
+## Validation
+
+✓ **Paradoxo identificado:** Documentação é criada para melhorar compreensão, mas se virar doc rot (desatualizada), PIORA a compreensão e induz erro. A resolução é SUBTRAÇÃO (deletar doc podre) não ADIÇÃO.
+
+✓ **Tension mapeada:** Tensão existe entre "Code Over Documentation" e necessidade ocasional de documentação como contrato (APIs públicas, regulatory). Resolução: criar doc APENAS em 3 casos específicos; em 90% do tempo, resposta é DELETAR.
+
+✓ **Aplicabilidade:** Esta heurística aplica-se ao contexto AllFluence onde a documentação foi uma fonte histórica de desperdício; o pivô para doc-rot-detector validou empiricamente que SUBTRAÇÃO > ADIÇÃO.

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

@@ -0,0 +1,89 @@
+# AN_KE_073 - Parallel Subagents for Throughput
+**Zone:** 🔥 20% Impacto | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão mentelendaria 6c434ffc — "máximo de subagentes em paralelo"]
+
+## Purpose
+
+Quando tarefa é paralelizável (preenchimento de dados, pesquisa, validação, batch processing), usar o MÁXIMO de subagentes em paralelo. A IA por default executa sequencialmente — Alan exige paralelismo explícito para throughput. O padrão se aplica a LLM subagents (Claude workers), bash parallel jobs, e pipelines multi-fase. A distinção chave: paralelismo é para THROUGHPUT em tarefas independentes, não para colaboração em tarefas dependentes.
+
+## Configuration
+
+```yaml
+AN_KE_073:
+  name: "Parallel Subagents for Throughput"
+  zone: "impacto"
+  trigger: "Tarefa com múltiplos items independentes que podem ser processados em paralelo."
+  sys_tension:
+    tension_with: "PV_KE_088 (The Sequential Pipeline Truth) vs Complexidade de Parsing Local"
+    resolution: "Paralelismo aplica-se a items INDEPENDENTES (sem dependência de estado prévio). Sequencialismo aplica-se a items DEPENDENTES (requerem output anterior como input). A decisão crítica: identificar se há dependência real entre items, não apenas processá-los na ordem."
+
+  rule: |
+    SE tarefa é paralelizável (items independentes, sem dependência entre eles)
+    ENTÃO usar MÁXIMO de paralelismo disponível:
+      - LLM: múltiplos subagentes simultâneos
+      - Bash: parallel jobs, xargs -P, GNU parallel
+      - Pipeline: fases independentes em paralelo
+    Throughput > sequencialidade QUANDO items são independentes.
+    NUNCA paralelizar tarefas com dependência entre elas.
+
+  veto_condition:
+    trigger: "Processando 10+ items sequencialmente quando são independentes."
+    action: "VETO — 'FAça com o máximo de subagentes que conseguir.' Paralelizar."
+
+  evidence:
+    - "[SOURCE: sessão 6c434ffc, mentelendaria] 'FAça A com o máximo de subagentes que conseguir'"
+    - "[SOURCE: sessão mentelendaria] 'use multiplos agentes em paralelo para este preenchimento e sempre pesquise na internet se tiver alguma dúvida'"
+    - "[PATTERN] Modelo wave-based em story-cycle usa parallelismo headless (claude -p em worktrees separados)"
+    - "[SOURCE: sessão e0a18d13, mmos] 'revise um a um, use multiplos agentes para ser mais rápido'"
+    - "[SOURCE: sessão b89fe039, mmos] 'Use multiplos agentes e faça todas atividades paralelas que puder'"
+    - "[SOURCE: sessão 24a4da7c, mmos] 'Quero testar o modo paralelo com 10 livros usando gemini e subagents'"
+```
+
+## Decision Tree
+
+```javascript
+IF (batch_of_independent_items)
+  STEP_1: CHECK independence
+    IF (item_N depends on item_N-1) → SEQUENTIAL (cannot parallelize)
+    IF (items are independent) → PARALLELIZE
+
+  STEP_2: SELECT parallelism method
+    IF (LLM processing) → spawn N subagents, each with 1 item
+    IF (bash/script) → xargs -P $(nproc) or GNU parallel
+    IF (multi-phase pipeline) → check which phases are independent
+
+  STEP_3: FAN-OUT
+    LIMIT: respect rate limits / billing limits (AN_KE_064)
+    TRACK: progress per parallel worker
+    COLLECT: results after all complete
+
+  STEP_4: FAN-IN
+    MERGE: individual results into unified output
+    VALIDATE: completeness (all items processed?)
+    REPORT: failures per worker
+
+  NEVER: process 10+ independent items one-by-one
+  EXCEPTION: when debugging, sequential is fine for visibility
+```
+
+## Failure Modes
+
+### O Preenchimento de 200 Campos em Série
+- **Trigger:** 200 dados de personas para preencher → IA processa 1 por vez.
+- **Manifestation:** Task que deveria levar 5 minutos leva 2 horas.
+- **Detection:** Monitoramento mostra: 1 request/min para tarefa batch-friendly.
+- **Prevention:** "FAça com o máximo de subagentes." Fan-out/fan-in pattern.
+
+## Validation
+
+**✓ Heurística validada**
+
+| Critério | Status | Nota |
+|----------|--------|------|
+| Paradoxo identificado | ✓ | Tensão entre paralelismo (independência) e sequencialismo (dependência) |
+| Resolução clara | ✓ | Critério de decisão: presença/ausência de dependência de estado |
+| Aplicabilidade | ✓ | Claramente aplicável a batch processing, pesquisa, validação, preenchimento de dados |
+| Evidência | ✓ | 6 fontes diretas de Alan e padrão wave-based documentado |
+| Integração com AN_KE_038 | ✓ | Complementária, não conflitante; define espaço de aplicação diferente |
+
+**Paradoxo resolvido:** A tensão entre "sempre paralelizar" e "manter contexto sequencial" resolve-se na **análise de dependência de estado**. Se não há dependência, paraleliza; se há, mantém sequência com contexto preservado (AN_KE_038).

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

@@ -0,0 +1,60 @@
+# AN_KE_074 - Commit Sebelum Deletion (Commit Before Unsafe Deletion)
+**Zone:** 🔥 20% Impacto | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão c49f3c16, aiox-stage — "antes de continuar faça commit"]
+
+## Purpose
+
+A deleção estrutural ou reposicionamento de centenas de artefatos é uma operação de alto risco, pois os LLMs rotineiramente erram escopo (deletam massivamente pastas pai via `rm -rf`). A regra impõe que *antes* de prosseguir com uma exclusão pedida ou uma reestruturação perigosa de arquivos em staging, o Agente DEVE obrigar a fixação de um save-state com um `git commit`. Isso garante a reversibilidade a 1 segundo de custo mental.
+
+## Configuration
+
+```yaml
+AN_KE_074:
+  name: "Commit Before Unsafe Deletion"
+  zone: "impacto"
+  trigger: "Operação massiva de exclusão, deleção de arquivos sensíveis ou reorganização destrutiva."
+
+  sys_tension:
+    tension_with: "AN_KE_075 (Delete Stale Recreate from Scratch) — Checkpoint reversibility vs Destructive cleanup authorization"
+    resolution: "Safety takes precedence. Commit before deletion to create reversible checkpoint, then validate completion, then create final commit documenting closure."
+
+  rule: |
+    SE a tarefa envolver deletar pastas de scaffolding ou dados massivos iteráveis
+    ENTÃO OBRIGATÓRIO commitar o estado local ANTES de executar o rm/delete.
+    Aja como um checkpoint de segurança inegociável.
+    O `git commit` deve preceder operações destrutivas como um escudo anti-hallucination.
+
+  veto_condition:
+    trigger: "Agente processa comando apagando 50 arquivos no bash sem validar status Git."
+    action: "VETO — 'antes de continuar faça commit'."
+
+  evidence:
+    - "[SOURCE: sessão c49f3c16, aiox-stage] 'nao delete nada do harry potter, antes de continuar faça commit'"
+```
+
+## Decision Tree
+
+```javascript
+IF (action_destroys_or_massively_moves_files)
+  STEP_1: PAUSE execution.
+  STEP_2: CHECK git status.
+    IF (uncommitted_changes_exist)
+      -> ASK HUMAN to commit OR auto-run `git add . && git commit -m "chore: save state before massive deletion"`
+  STEP_3: EXECUTE deletion / scaffolding teardown.
+```
+
+## Failure Modes
+
+### RM-RF Catastrófico
+- **Trigger:** Agente deleta a pasta `/docs` antiga inteira para dar lugar à `/docs-v2` sem commitar as novidades nas outras pastas adjacentes.
+- **Manifestation:** Perde-se alterações valiosas não lixadas, impossibilitando CTRL+Z no file system.
+- **Detection:** `git reflog` vazio nos últimos 30 min com `rm -rf` executado.
+- **Prevention:** A heurística impõe salvar.
+
+## Validation
+
+✅ **Paradoxo Identificado:** Commit obrigatório ANTES da deleção cria estado incompleto (staging com deletions apenas), violando Conventional Commits que exigem commits semânticos completos.
+
+✅ **Resolução Aplicada:** Bifurcar em dois commits — (1) "chore: save state before destructive operation" (reversibility checkpoint), (2) "feat/fix: complete deletion [Story X.Y]" (semantic close).
+
+✅ **Compliance:** Implementação responde à veto_condition sem comprometer integridade de git history.

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

@@ -0,0 +1,87 @@
+# AN_KE_075 - Delete Stale Recreate from Scratch
+**Zone:** 🔥 20% Impacto | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão sinkra-hub 6c66eaf6 — limpeza e auditoria squad-creator-pro]
+
+## Purpose
+
+Counter-intuitive: quando artefato está desatualizado e o custo de atualizar > custo de recriar, DELETAR e recriar do zero. A tentação é "atualizar incrementalmente" — mas isso acumula cruft, inconsistências, e gera artefatos Frankenstein. A sessão 6c66eaf6 revela que Alan aplica isso em MÚLTIPLAS dimensões: (1) files desatualizados ("delete tudo que tiver desatualizado, melhor recriar do zero"), (2) organização questionável ("benchmarks dentro do squad-creator-pro? test-cases? isso precisa estar dentro dele? nao é sujeira?"), (3) documentação antiga ("tem mt documentacao que parece ser antiga tb de processos"). O princípio é mais profundo que file cleanup — é HYGIENE ORGANIZACIONAL: questionar a própria existência de cada artefato.
+
+## Configuration
+
+```yaml
+AN_KE_075:
+  name: "Delete Stale Recreate from Scratch"
+  zone: "impacto"
+  trigger: "Artefato desatualizado encontrado durante revisão, OU questionar se artefato deveria existir naquele local."
+
+  rule: |
+    SE artefato desatualizado E custo_atualizar > custo_recriar
+    ENTÃO deletar e recriar do zero.
+    SE artefato existe mas ninguém sabe POR QUE → questionar existência.
+    SE artefato está no lugar errado ("precisa estar dentro dele?") → mover ou deletar.
+    Manter stale = doc rot ativo contaminando contexto.
+    Update incremental de artefato podre = Frankenstein.
+    Delete + recreate from ground truth = consistência garantida.
+
+  sys_tension:
+    tension_with: "AN_KE_045 (Subtraction First Strategy) — Delete-from-Scratch approach é subtração radical vs preservação incremental. Porém: subtração de artefatos podres (>50% stale) garante higiene organizacional; em sistemas saudáveis, incrementalismo preserva contexto valioso. A tensão é: quando remover > consertarr."
+    resolution: "Usar cost-threshold (0.3-0.5 ratio) como decisor. Abaixo = incremental. Acima = delete-recreate. Entre = preferir delete. Decisão baseada em métrica, não em preferência."
+
+  veto_condition:
+    trigger: "Fazendo patch incremental em artefato que: (a) está >50% desatualizado, (b) ninguém sabe pra que serve, ou (c) está no local errado."
+    action: "VETO — 'delete tudo que tiver desatualizado, melhor recriar do zero.' Não faça Frankenstein. Questione a existência."
+
+  evidence:
+    - "[SOURCE: sessão 6c66eaf6, sinkra-hub] 'delete tudo que tiver desatualizado, melhor recriara do zero'"
+    - "[SOURCE: sessão 6c66eaf6, sinkra-hub] 'O que são os benchmarks dentro do squad-creator-pro? test-cases? isso precisa estar dentro dele? nao é sujeira? tem mt documentacao que parece ser antiga tb de processos etc'"
+    - "[META] Este upgrade de 11 cards (060-100) de 7L → ~60-80L é exemplo vivo desta heurística: stubs não foram patchados — foram deletados e recriados do zero"
+```
+
+## Decision Tree
+
+```javascript
+IF (stale_artifact_found)
+  STEP_1: QUESTION existence first
+    ASK: "isso precisa estar aqui? nao é sujeira?"
+    IF (nobody knows why it exists) → DELETE without recreation
+    IF (exists but in wrong place) → DELETE + recreate in correct location
+    IF (exists with clear purpose but outdated) → proceed to Step 2
+
+  STEP_2: EVALUATE update vs recreate
+    cost_to_update = (lines_changed / total_lines) + (dependencies_broken / total_deps)
+    IF (cost_to_update > 0.5 OR structure_changed) → DELETE and RECREATE from ground truth
+    IF (cost_to_update < 0.3 AND structure_intact) → PATCH incrementally
+    IF (between 0.3-0.5) → PREFER recreate (Frankenstein risk)
+
+  STEP_3: BEFORE_DELETE
+    HARVEST: valuable content that should survive (AN_KE_090 Template Harvesting)
+    ARCHIVE: if artefato tem historical value (git history preserves)
+    VERIFY: no active dependencies pointing to this artifact
+
+  STEP_4: RECREATE from current ground truth
+    SOURCE: current codebase state, not the old artifact
+    FORMAT: current standards, not legacy format
+    VALIDATE: new version against current reality
+    NEVER: copy-paste from old artifact and "update" — starts from scratch
+
+  THREE TRIGGERS of this heuristic:
+    (1) FILE stale → "delete tudo desatualizado, melhor recriar do zero"
+    (2) LOCATION wrong → "precisa estar dentro dele? nao é sujeira?"
+    (3) DOCUMENTATION antiga → "mt documentacao que parece ser antiga de processos"
+```
+
+## Failure Modes
+
+### O Frankenstein de Squad
+- **Trigger:** Squad-creator-pro tem benchmarks, test-cases, e docs antigos acumulados de 6 meses de evolução.
+- **Manifestation:** "O que são os benchmarks? test-cases? isso precisa estar dentro dele? nao é sujeira? tem mt documentacao que parece ser antiga"
+- **Detection:** `ls -la` mostra arquivos com modified date > 60 days. Content não referenciado por nenhum script ativo.
+- **Prevention:** Auditoria trimestral: para cada artefato perguntar "isso precisa existir? aqui? neste formato?" Se não → deletar.
+
+## Validation
+
+- ✅ **Paradoxo Identificado:** Tension entre incrementalismo (AN_KE_001) e delete-from-scratch (AN_KE_075) — resolvido via cost-threshold métrico
+- ✅ **sys_tension** campo adicionado com tension_with e resolution explícitos
+- ✅ **Decision Tree** fornece critério claro (0.3-0.5 cost ratio) para evitar decisões subjetivas
+- ✅ **Failure Mode** exemplifica manifestação real em squad-creator-pro
+- ✅ **Aplicabilidade:** Testado em upgrade 060-100 cards (stubs recriados, não patchados)

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

@@ -0,0 +1,107 @@
+# AN_KE_076 - Minimal Blast Radius
+**Zone:** 💎 4% Excelência | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessões mmos d6b38401, 8a1ebe41, 22650c09, aiox-stage 711559f2 — frustração recorrente com IA expandindo escopo]
+
+```yaml
+sys_tension:
+  tension_with: "AN_KE_073 (Parallel Subagents) vs Execução Singular Controlada"
+  paradox: "Minimalismo absoluto (só altere o solicitado) vs. Obrigação de vetar ampliações de escopo (intervenção ativa)"
+  resolution: "STRICT EXECUTION: Execute mínimamente → Verifica diff → SE diff > esperado: STOP, VETO, GET CONFIRMATION. Minimalismo na execução, maximalismo na supervisão."
+```
+
+## Purpose
+
+A IA tem tendência sistêmica de "aproveitar" um comando para "melhorar" coisas adjacentes — refatorar layout ao mudar uma cor, renomear variáveis ao corrigir um bug, reorganizar imports ao adicionar uma feature. Isso é DESTRUTIVO porque: (1) o humano perde a confiança ao ver diff inesperado, (2) mudanças não-solicitadas podem quebrar coisas que funcionavam, (3) reverte progresso que o humano não quer perder. Blast radius mínimo = confiança máxima. Se o humano quer mais, ele pede mais. A regra se aplica a TODOS os domínios: UI, banco de dados, codebase, infra, e até organização de arquivos.
+
+## Configuration
+
+```yaml
+AN_KE_076:
+  name: "Minimal Blast Radius"
+  zone: "excelencia"
+  trigger: "IA recebendo comando pontual e alterando algo além do escopo solicitado."
+
+  rule: |
+    SE recebendo comando para mudar UMA coisa
+    ENTÃO mudar SÓ aquela coisa em TODOS os domínios:
+      - UI: mudar cor do botão ≠ refatorar layout
+      - DB: ajustar coluna ≠ renomear tabelas adjacentes
+      - Code: corrigir bug ≠ refatorar módulo
+      - Files: mover arquivo ≠ reorganizar diretório inteiro
+      - Infra: alterar config ≠ reestruturar tasks de outro lugar
+    Blast radius mínimo = confiança máxima.
+    "Quanto mais bonito o diff, mais suspeito."
+
+  veto_condition:
+    trigger: "Diff mostra alterações em arquivos/componentes/tabelas que não foram solicitados."
+    action: "VETO — 'Estou vendo que voce está deletando muita coisa que parece ser bem interessante, cuidado.' Revert não-solicitado."
+
+  evidence:
+    - "[SOURCE: sessão d6b38401, mmos] 'Eu nao quero alterar o dash atual ou se alterar, quero manter o máximo do que como está, só incorporar novas ou pequenas mudanças, mas toda vez que do um comando para IA ela muda todo dash'"
+    - "[SOURCE: sessão 8a1ebe41, mmos] 'Estou vendo que voce está deletando muita coisa que parece ser bem interessante, cuidado, revise de novo'"
+    - "[SOURCE: sessão 22650c09, mmos] 'nao altere, exclua ou adicione nenhuma coluna do banco sem antes me pedir confirmação'"
+    - "[SOURCE: sessão 711559f2, aiox-stage] 'pq vc salvou algo em .aiox-core/development/tasks/compute-lifecycle-status.md? a ideia é nao alterar tasks originais do aiox-core'"
+```
+
+## Decision Tree
+
+```javascript
+IF (receiving_change_request)
+  STEP_1: SCOPE the change precisely
+    IDENTIFY: which file(s), which function(s), which line(s)
+    BOUNDARY: explicit list of what WILL change
+
+  STEP_2: EXECUTE within scope
+    UI: change ONLY the component/element requested
+    DB: change ONLY the column/table mentioned + confirmação prévia (AN_KE_086)
+    Code: change ONLY the function/block specified
+    Files: move/edit ONLY the file(s) mentioned
+    Infra: alter ONLY the task/config specified — NEVER touch aiox-core originals
+
+  STEP_3: VERIFY blast radius post-change
+    RUN: git diff --stat
+    RATIO: files_changed / files_expected
+    IF (ratio > 2x) → SUSPECT, review each extra file
+    IF (ratio > 5x) → REVERT extras, keep only scoped changes
+
+  STEP_4: INFORM about necessary cascading
+    IF (requested_change REQUIRES change in another file to compile/work)
+      → INFORM human: "Precisei alterar X também porque Y depende de Z"
+      → GET confirmation before proceeding
+    IF (requested_change does NOT require cascading)
+      → CHANGE NOTHING ELSE, even if you see "improvements"
+
+  NEVER: "improve" adjacent code, "fix" formatting, "clean up" imports without explicit ask
+```
+
+## Failure Modes
+
+### O Dashboard que Sumiu
+- **Trigger:** Pedido para mudar cor de um botão → IA refatora layout, state management, imports.
+- **Manifestation:** "toda vez que do um comando para IA ela muda todo dash, quero manter o máximo do que como está."
+- **Detection:** `git diff --stat` mostra 15+ files changed para change request de 1 file.
+- **Prevention:** Scope antes de executar. Diff review obrigatório. Se blast radius > 2x → pausa.
+
+### A Coluna Fantasma
+- **Trigger:** Pedido para ajustar query → IA renomeia colunas, adiciona índices não solicitados.
+- **Manifestation:** "nao altere, exclua ou adicione nenhuma coluna do banco sem antes me pedir confirmação."
+- **Detection:** Migration diff mostra ALTER TABLE em tabelas não mencionadas no pedido.
+- **Prevention:** Qualquer mutação de schema requer confirmação explícita. SELECT antes de ALTER (AN_KE_086).
+
+### Os Tasks Sagrados
+- **Trigger:** Salvando output em local errado → IA altera tasks originais do aiox-core.
+- **Manifestation:** "pq vc salvou algo em .aiox-core? a ideia é nao alterar tasks originais do aiox-core."
+- **Detection:** `git diff` mostra changes em .aiox-core/ que não foram solicitados.
+- **Prevention:** .aiox-core/ é read-only para alterações não-explicitadas. Output vai em outputs/, não em tasks/ do core.
+
+---
+
+## Validation
+
+✓ **Paradox Identified:** Minimalismo (não altere nada além do solicitado) conflita com Supervisão Ativa (VETO mudanças inesperadas).
+
+✓ **Resolution Applied:** Separação clara entre execução (estrita/mínima) e supervisão (ativa/protetora). O agente executa conservadoramente e veta agressivamente.
+
+✓ **Operacionalização:** Fluxo EXECUTE → VERIFY → VETO/CONFIRM garante confiança sem abandono de responsabilidade de oversight.
+
+✓ **Alignment:** Coerente com AN_KE_086 (Confirmation Before Mutation) e mandato de self-supervision para agentes de IA em domínio sensível (dados, infra, codebase).