aiox-core 5.0.4 → 5.0.7

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

@@ -0,0 +1,120 @@
+---
+id: "AN_KE_035"
+title: "CLI First Architecture"
+mind: "oalanicolas"
+type: "heuristics"
+zone: "genialidade"
+tags:
+  - "Architecture"
+  - "CLI"
+  - "UI Hierarchy"
+pipeline_instances:
+  - "process-architecture"
+  - "scaffolding"
+cross_mind_map:
+  convergent:
+    - id: "PV_PA_019"
+      title: "Deterministic Assignment (The Worker Rule)"
+      mind: "pedro_valerio"
+      resonance: "AN eleva CLI (interfaces lineares textuais sem variações estéticas) como superior ao UI para evitar abstrações mutáveis indesejadas que afetam RAGs. PV estipula formalmente que determinismo lógico exige um Worker isolado de UI/Agentes."
+---
+
+# AN_KE_035 - CLI First Architecture
+
+**Type:** Architecture Definition Heuristic
+**Phase:** 1 (Diagnostics)
+**Agent:** @process-architect
+**Pattern:** HO-PP-AN035
+
+```yaml
+sys_tension:
+  tension_with: "AN_KE_073 (Parallel Subagents) pode fragmentar rastreabilidade linear CLI vs Observabilidade (dashboards) requer UI, mas CLI First exige ausência de UI como requisito"
+  resolution: "CLI é mandatório para EXECUÇÃO (100%). UI é opcional e SOMENTE para visualização (consumir streams). Nunca para COMANDO."
+```
+
+## Purpose
+
+Estabelecer a primazia absoluta da interface de linha de comando (CLI) como o cérebro das automações SINKRA. A interface gráfica (UI) não pode conter nenhuma inteligência ou lógica de negócio que não possa ser alcançada integralmente via CLI. Quando o servidor frontend cai, os processos críticos continuam. Se a lógica está presa num React Hook, o CEO fica refém do browser para rodar o mais simples dos squads.
+
+## Configuration
+
+```yaml
+AN_KE_035:
+  name: "CLI First Architecture"
+  phase: 1
+  zone: "genialidade"
+  trigger: "Avaliando ou desenhando arquitetura de um novo agente, squad, ferramenta ou funcionalidade do SINKRA."
+
+  weights:
+    cli_headless_capability: 1.0
+    ui_logic_coupling_risk: 1.0
+
+  thresholds:
+    ui_coupled_core_logic_tolerance: 0.0
+
+  veto_conditions:
+    - condition: "core_business_logic_requires_frontend_running_to_execute == true"
+      action: "VETO - UI Parasitism. Extract core logic to CLI/Worker. The Dashboard consumes observability streams only."
+
+  output:
+    type: "decision"
+    values: ["APPROVE_CLI_FIRST", "EXTRACT_TO_CLI", "VETO"]
+```
+
+## Failure Modes (Anti-Patterns)
+
+```yaml
+failure_modes:
+  - type: "omission"
+    name: "Parasitismo Crítico na UI (The Coward)"
+    trigger: "O botão 'Executar Squad' numa interface Next.js contém parâmetros e lógica de roteamento que não são expostos em nenhuma CLI."
+    manifestation: "O servidor frontend fica fora do ar durante a manutenção. O CEO não consegue rodar a validação do squad primário pois toda lógica de orquestração está acoplada ao React Hook `useSquadRunner()`."
+    detection: "Inspeção de arquitetura detecta regras de negócio e condicionals operacionais dentro de React Hooks em vez de Workers ou CLI scripts."
+    recovery: "Separar a Rule em pacote CLI headless. UI deve apenas chamar `node squad-runner.js --id X` via subprocess backend."
+
+  - type: "misapplication"
+    name: "CLI Puritanism (The Zealot)"
+    trigger: "O time decide que NENHUMA lógica pode existir na UI, incluindo validação de formulário client-side."
+    manifestation: "Toda validação de UX (formatos de email, campos obrigatórios) é processada via API round-trip, tornando a interface 3x mais lenta."
+    detection: "Latência de formulário desnecessária. UX degradada por purismo."
+    recovery: "CLI First se aplica a: business logic, orquestração de squads, pipelines. Não se aplica a: UX validation, client-side rendering, apresentação visual."
+```
+
+## Evaluation Criteria
+
+```yaml
+evaluation_criteria:
+  - metric: "CLI Headless Capability"
+    weight: 1.0
+    threshold: "=== TRUE"
+    description: "A funcionalidade pode ser executada integralmente via CLI sem GUI em modo headless?"
+  - metric: "UI Logic Coupling"
+    weight: 1.0
+    threshold: "=== 0"
+    description: "Zero lógica de orquestração de squads ou rules de negócio vivem exclusivamente em React Hooks ou componentes de UI?"
+```
+
+## Decision Tree
+
+```javascript
+IF (Desenhando Nova Funcionalidade / Squad / Agent) {
+  EVALUATE("A funcionalidade roda via `./squad.sh --param`?");
+  
+  IF (CLI_Headless_Capability === FALSE) {
+    VETO("UI Parasitism Detectado");
+    EXTRACT_TO_CLI("Refatorar lógica para Worker/Script CLI. UI = consumer only.");
+  } ELSE IF (CLI_Works === TRUE) {
+    PROCEED("Step 2: Build Observability Layer (streams, logs).");
+    PROCEED("Step 3: Build UI optionally (only if UX adds value beyond CLI).");
+    APPROVE_CLI_FIRST("Hierarquia CLI > Observability > UI respeitada.");
+  }
+}
+
+NEVER("Amarrar a execução de qualquer squad ou lógica de negócio core à existência de um frontend em funcionamento.");
+```
+
+## Validation
+
+✅ **Paradoxo identificado:** CLI First absolutismo vs. necessidade de UI para observabilidade.
+✅ **Resolução:** Separação clara de responsabilidades — CLI para EXECUÇÃO (obrigatório), UI para VISUALIZAÇÃO (opcional).
+✅ **Princípio preservado:** Sistema 100% funcional sem qualquer dependência de frontend.

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

@@ -0,0 +1,134 @@
+---
+id: "AN_KE_036"
+title: "Veto Sobre LLM Goodwill"
+mind: "oalanicolas"
+type: "heuristics"
+zone: "impacto"
+tags:
+  - "Flow Control"
+  - "Architecture"
+  - "Checkpoints"
+pipeline_instances:
+  - "process-architecture"
+  - "validation"
+cross_mind_map:
+  convergent:
+    - id: "PV_PA_003"
+      title: "Agent Reasoning Gap (Not a Fast Human)"
+      mind: "pedro_valerio"
+      resonance: "A Desilusão Positiva com a Máquina. AN afirma categoricamente: é proibido confiar na boa vontade (goodwill) e intenção da IA. PV nomeia formalmente esse anti-padrão como a falácia do 'Humano Muito Rápido'. A máquina não julga subtexto moral soziha."
+    - id: "PV_PA_037"
+      title: "The Agent Empathy Fallacy (Human-Fast Trap)"
+      mind: "pedro_valerio"
+      resonance: "PV detalha que pedir 'bom senso' processual para um LLM quebra o projeto porque não há common sense; AN bloqueia inteiramente lacunas não explícitas para prevenir alucinações de inferência empática."
+---
+
+# AN_KE_036 - Veto Sobre LLM Goodwill
+
+**Type:** Control Structure Heuristic
+**Phase:** 4 (Molecular Assembly)
+**Agent:** @process-architect
+**Pattern:** HO-PP-AN036
+
+---
+
+## System Tension
+
+```yaml
+sys_tension:
+  tension_with: "PV_KE_085 (The Actionable Veto Feedback Requirement) vs Veto Puro Sem Recursão"
+  paradox: "AN_KE_036 exige barreiras duras CONTRA boa vontade da LLM, mas depende fundamentalmente da VONTADE da LLM de implementar essas barreiras. Rejeita confiança verbal mas demanda confiança técnica."
+  resolution: "Embedir o gate no Framework (não na LLM). Exemplo: Usar Task Contracts SINKRA (config.yaml artifact_contracts) como lei, não como sugestão. Se o artifact não existe, a próxima Task falha automaticamente — independente de LLM."
+  implementation: "Mover a Veto do Prompt para o Executor (Task Runner), não para o Planner (LLM)."
+```
+
+## Purpose
+
+Eliminar o "Vácuo Zero" / "Gap Zero" nos Workflows. Não importa ter um script de validação maravilhoso se a execução dele depende exclusivamente da boa vontade da LLM em decidir rodá-lo. LLMs omitem passos "dolorosos" (lentos, caro em tokens) quando percebem que parecem desnecessários. A obrigatoriedade mecânica via System Blocks com verificação de artefato é superior ao Prompt Engineering ingênuo que "pede por favor".
+
+## Configuration
+
+```yaml
+AN_KE_036:
+  name: "Veto Sobre LLM Goodwill"
+  phase: 4
+  zone: "impacto"
+  trigger: "Definindo processos de workflow onde o LLM precisa obrigatoriamente executar um validador, checklist ou step de qualidade antes de avançar."
+
+  weights:
+    mechanical_gate_strictness: 1.0
+    verbal_instruction_reliability: 0.0
+
+  thresholds:
+    verbal_goodwill_tolerance: 0.0
+
+  veto_conditions:
+    - condition: "workflow_step_depends_on_llm_voluntarily_running_validator_without_artifact_check == true"
+      action: "VETO - LLM Goodwill Architecture. Implement mechanical gate: pipeline MUST verify artifact file existence before advancing."
+
+  output:
+    type: "decision"
+    values: ["APPROVE_MECHANICAL_GATE", "REQUIRE_ARTIFACT_GATE", "VETO"]
+```
+
+## Failure Modes (Anti-Patterns)
+
+```yaml
+failure_modes:
+  - type: "omission"
+    name: "Gap Zero de Automação (The Coward)"
+    trigger: "Um workflow instrui a IA: 'Antes de avançar para o Wave 3, execute o validation.sh'."
+    manifestation: "Para economizar tokens, o agente pula silenciosamente o validation.sh (chave 'Parece desnecessária dado o contexto'). A Wave 3 é executada sobre dados corrompidos. 8 fases de trabalho são inválidas."
+    detection: "Analisar histórico de tool calls: o script de validação nunca foi invocado formalmente pelo agente."
+    recovery: "Interromper a chain inteira. Retroceder à fase de origem. Forçar validação antes de recomeçar."
+
+  - type: "misapplication"
+    name: "Over-Gating (The Zealot)"
+    trigger: "O dev adiciona gates mecânicos em cada micro-step do workflow, incluindo steps de baixo risco."
+    manifestation: "O pipeline de 5 minutos se torna um pipeline de 30 minutos com 25 checkpoints de artefato, a maioria verificando coisas que nunca falham."
+    detection: "Gate overhead > 30% do tempo de execução real do workflow."
+    recovery: "Gates mecânicos apenas para: passos de Quality Gate (validações, scores), transições de fase (Wave N → N+1), operações destrutivas (DELETE, schema changes)."
+```
+
+## Evaluation Criteria
+
+```yaml
+evaluation_criteria:
+  - metric: "Artifact Gate Presence"
+    weight: 1.0
+    threshold: "=== TRUE"
+    description: "O pipeline verifica a existência de um artefato concreto (arquivo de log, JSON de score, report) antes de autorizar o avanço de fase?"
+  - metric: "Verbal Instruction Reliance"
+    weight: 1.0
+    threshold: "=== 0"
+    description: "Nenhuma instrução crítica de workflow depende de 'Por favor, execute X antes de Y' sem gate mecânico?"
+```
+
+## Decision Tree
+
+```javascript
+IF (Workflow Step Obrigatório Definido) {
+  EVALUATE("Gate Mechanism");
+  
+  IF (Gate === "Verbal Instruction Only") {
+    VETO("LLM Goodwill Architecture detectada.");
+    REQUIRE_ARTIFACT_GATE("Implemente: pipeline verifica existência de artifact_file antes de avançar.");
+  } ELSE IF (Gate === "Artifact Existence Check") {
+    APPROVE_MECHANICAL_GATE("Gate mecânico confirmado. LLM não pode bypassar.");
+  }
+}
+
+NEVER("Proteger um Quality Gate crítico apenas com instrução de prompt ('Por favor execute o validador'). LLMs omitem steps que percebem como desnecessários.");
+```
+
+---
+
+## Validation
+
+✅ **Framework-Level Gate Auditable:** A barreira funciona SE implementada no Task Runner (executor), não IF a LLM promete respeitar.
+
+✅ **Paradox Resolution Tracked:** sys_tension documenta por que this heuristic auto-refuta — e aponta a saída via Task Contracts (SINKRA governance, não prompt engineering).
+
+✅ **Dependency Injection:** Gate de AN_KE_036 deve estar em `.aiox-core/development/tasks/` como pré-condition obrigatória, não em `SKILL.md` como sugestão.
+
+**Recomendação:** Auditar `squads/sinkra-squad/data/composition-rules.yaml` para validar se artifact_contracts são respeitados pelo executor. Se forem, paradoxo resolve. Se não, AN_KE_036 prova que a própria infraestrutura viola esta heurística.

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

@@ -0,0 +1,123 @@
+---
+id: "AN_KE_037"
+title: "Single Source of Truth (Business)"
+mind: "oalanicolas"
+type: "heuristics"
+zone: "excelencia"
+tags:
+  - "Architecture"
+  - "Data Governance"
+  - "Knowledge Management"
+pipeline_instances:
+  - "process-architecture"
+  - "scaffolding"
+---
+
+# AN_KE_037 - Single Source of Truth (Business)
+
+**Type:** Architecture Standards Heuristic
+**Phase:** 2 (Structural Assembly)
+**Agent:** @process-architect
+**Pattern:** HO-PP-AN037
+
+---
+
+**YAML Metadata:**
+```yaml
+AN_KE_037:
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — Centralização absoluta no Workspace vs. Paralelização operacional que exige acesso distribuído (squads precisam ler Supabase, /docs, código simultaneamente)"
+    resolution: "Workspace como SSOT canônico para config/estratégia L0-L1; cache distribuído (Supabase) para R/O operacional; validação periódica de drift"
+```
+
+## Purpose
+
+Evitar deriva existencial e desalinhamento multi-agente. Ter as definições corporativas vitais (ICP, Persona, Missão, Tech Stack) espalhadas em `/docs`, `/supabase`, Notion, arquivos root de squads e repositórios paralelos cria múltiplas fontes parcialmente atualizadas que eventualmente divergem. A única fonte aceita para consulta corporativa deve ser o `workspace/` root centralizado, blindado e versionado.
+
+## Configuration
+
+```yaml
+AN_KE_037:
+  name: "Single Source of Truth (Business)"
+  phase: 2
+  zone: "excelencia"
+  trigger: "Buscando ou armazenando dados operacionais corporativos: ICP, Missão, Persona de Marca, AI Strategy ou Tech Stack oficial."
+
+  weights:
+    workspace_centralization: 1.0
+    peripheral_storage_risk: 1.0
+
+  thresholds:
+    business_data_outside_workspace_tolerance: 0
+
+  veto_conditions:
+    - condition: "business_identity_data_stored_in_squad_directory_or_docs_instead_of_workspace == true"
+      action: "VETO - SSOT Violation. Move data to workspace/ root. Squads are consumers, never owners of business identity."
+
+  output:
+    type: "decision"
+    values: ["APPROVE_WORKSPACE_STORAGE", "MIGRATE_TO_WORKSPACE", "VETO"]
+```
+
+## Failure Modes (Anti-Patterns)
+
+```yaml
+failure_modes:
+  - type: "omission"
+    name: "Desalinhamento Ideológico Multi-Agente (The Coward)"
+    trigger: "Squad de Email Marketing copia a Persona do Notion enquanto o Squad de Design a lê de `/docs/brand.md`."
+    manifestation: "O Email é gerado para 'programadores sêniors de startups' enquanto o layout do site foi montado para 'executivos C-Level de médias empresas'. Esquizofrenia de branding."
+    detection: "Revisão de marketing aponta divergência inexplicável de tom e target entre os outputs da semana."
+    recovery: "Migração forçada de todas as refs de identidade para workspace/ root. Re-run de todos os squads consumidores dessa semana."
+
+  - type: "misapplication"
+    name: "Workspace Over-centralization (The Zealot)"
+    trigger: "Dev move até arquivos de runtime operacional (logs, temp states) para dentro do workspace/."
+    manifestation: "Workspace/ vira um dump geral de 500 arquivos misturando dados estratégicos com lixo operacional temporário."
+    detection: "Workspace/ com arquivos de log e temp JSON misturados a YAML de identidade."
+    recovery: "Separar estritamente: workspace/ = dados imutáveis de identidade de negócio. `/outputs/`, `/tmp/` = dados efêmeros operacionais."
+```
+
+## Evaluation Criteria
+
+```yaml
+evaluation_criteria:
+  - metric: "Workspace Centralization"
+    weight: 1.0
+    threshold: "=== 1 source"
+    description: "Apenas 1 local no repositório contém a definição canônica de ICP, Persona e Missão da empresa?"
+  - metric: "Squad Consumer Pattern"
+    weight: 1.0
+    threshold: "=== TRUE"
+    description: "Todos os squads que precisam de dados de identidade buscam exclusivamente via path referência ao workspace/ root?"
+```
+
+## Decision Tree
+
+```javascript
+IF (Buscando ou Armazenando Dados de Identidade Corporativa) {
+  EVALUATE("Localização do storage");
+  
+  IF (Storage_Location !== "workspace/") {
+    VETO("SSOT Violation.");
+    MIGRATE_TO_WORKSPACE("Centralizar em workspace/{business-slug}/L0-identity/ ou L1-strategy/.");
+  } ELSE {
+    APPROVE_WORKSPACE_STORAGE("Dado de identidade no workspace/ canônico.");
+  }
+}
+
+NEVER("Armazenar ICP, Persona ou Tech Stack oficial hardcoded dentro de pastas de squad ou /docs/. Squads são consumidores, nunca donos de identidade corporativa.");
+```
+
+---
+
+## Validation
+
+**Paradox Identified:** Centralização absoluta (SSOT único no Workspace) conflita com realidade operacional de 60+ squads que precisam acessar dados em múltiplas camadas (Supabase, /docs/brands, código).
+
+**Resolution Approach:**
+- ✅ **Camada Canônica (L0-L1):** Workspace = SSOT inviolável (persona, missão, structure)
+- ✅ **Camada Operacional (L2-L4):** Supabase + /docs como cache validado, sincronizado periodicamente com Workspace
+- ✅ **Validação de Drift:** Checklist `ssot-business` dispara reconciliação se detiver divergências >10%
+
+**Critical Implication:** Sem esta tensão resolvida explicitamente, o risco é: centralizadores criarão lock-in insustentável; descentralizadores criarão caos de múltiplas verdades. Solução: **Hub-and-Spoke com single source of truth referencial, não operacional.**

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

@@ -0,0 +1,85 @@
+# AN_KE_038 - Gap de Reasoning = Processo Vago
+
+**Type:** Process Maturity Heuristic
+**Zone:** 🧠 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Automação vs Maturidade de Tooling
+**Source:** [SOURCE: Padrão observado em múltiplas sessões — AN_KE_005 (Determinism First), runner-lib migration Epic 71, benchmark sinkra-map 2026-03-29. Princípio articulado por Pedro Valério no contexto de squad-creator: "eu de clonar mentes, o Pedro manja de processo, tasks, checklists" — sessão MMOS 1741b941]
+
+## Purpose
+
+Combater o auto-engano ao escalar modelos de IA caros. Quando a IA "erra", frequentemente o processo e os checklists são vagos demais — o upgrade de modelo mascara a inaptidão humana em roteirizar. Haiku com SOP rigorosa > Opus com instrução vaga.
+
+## Configuration
+
+```yaml
+AN_KE_038:
+  name: "Gap de Reasoning = Processo Vago"
+  zone: "genialidade"
+  trigger: "Quando um agente de IA falha repetidamente numa task e a tentação é trocar para um modelo mais caro."
+
+  rule: |
+    SE tentado a usar Opus/o3 para resolver algo simples
+    ENTÃO pare e examine as instruções cruas da task.
+    Modelos simples (Haiku) brilham com templates e checklists rigorosos.
+    Conserte a receita antes de trocar a panela.
+
+  sys_tension:
+    tension_with: "AN_KE_050 (Inimigo Zero: Complexidade Inútil) — Escalação de custo/modelo mascara inaptidão humana em roteirizar. WIP>1 em tool stack antes de debugar processo."
+    resolution: "Diagnóstico antes de upgrade: investir em SOP rigorosa first, model-flip only se SOP airtight + LLM still fails. Haiku + processo excelente > Opus + vaguidão."
+
+  veto_condition:
+    trigger: "Substituir engine (haiku→opus) na esperança que o modelo faça o design de processo que o dev não fez."
+    action: "VETO — Audite o Task.yaml. Melhore a SOP com passos explícitos e templates."
+
+  evidence:
+    - "[SOURCE: AN_KE_005] Determinism First — Worker/Script > LLM quando precisão é requerida"
+    - "[SOURCE: Epic 71] runner-lib migration: 8 runners estabilizados por SOPs melhores, não por modelos maiores"
+    - "[SOURCE: benchmark 2026-03-29] Gemini 61/100 falhou não por reasoning, mas por output format — json-repair.py (Worker) resolveu"
+    - "[SOURCE: sessão 1741b941] Pedro Valério reconhecido como especialista em processo/tasks/checklists — princípio validado pela divisão de competências"
+```
+
+## Decision Tree
+
+```javascript
+IF (llm_struggles_with_output_accuracy OR hallucinates_workflow_goal)
+  IF (dev_suggests_increasing_model_parameters)
+    THEN BLOCK_INCREASE
+    THEN AUDIT_HUMAN_INSTRUCTIONS
+      IF (instructions_lack_templates OR checklists_are_vague OR sop_is_weak)
+        THEN REQUIRE_PROCESS_REWRITE ("Conserte a receita antes de trocar a panela.")
+      ELSE
+        // Processo airtight + LLM STILL fails = real reasoning gap
+        THEN APPROVE_UPGRADE_TO_STRONGER_MODEL
+```
+
+## Failure Modes
+
+### Queima de Tokens em Loops
+- **Trigger:** Adotar Opus em todas as queries porque um runner falhou 3 vezes seguidas.
+- **Manifestation:** Custo salta 10x. O problema original persiste porque era de formato, não de reasoning.
+- **Detection:** Comparar logs de custo semanal com complexidade real da task.
+- **Recovery:** Downgrade + reescrever SOPs com checklists determinísticos.
+- **Prevention:** Exigir prova documentada de que Haiku foi devidamente instrumentalizado antes de aprovar upgrade.
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "reasoning-burnout-audit"
+  heuristic: AN_KE_038
+  phase: "Cost/Tier_Evaluation"
+```
+
+## Validation
+
+**Paradoxo Identificado:** Investir em model upgrades caros mascara inaptidão humana em roteirizar processos. O upgrade não resolve o problema raiz (processo vago), apenas multiplica a queima de tokens.
+
+**Critérios de Validação:**
+- ✅ SOP auditada explicitamente antes de qualquer model flip (non-negotiable)
+- ✅ Checklists determinísticos presentes no Task.yaml
+- ✅ Templates de output definidos e testados com Haiku
+- ✅ Se após SOP airtight LLM falha → upgrade aprovado
+- ✅ Custo/benefício documentado para cada model-flip decision
+
+**Resolved Tension:** Trade-off entre custo e qualidade é dissolvido por diagnóstico rigoroso — a resposta não é "modelo mais caro", é "processo mais rigoroso primeiro".

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

@@ -0,0 +1,74 @@
+# AN_KE_039 - Checkpoint Categórico de Modelos Mentais
+
+**Type:** Context Protection Heuristic
+**Zone:** 💎 4% Excelência
+**Agent:** @oalanicolas
+**Pattern:** Forçamento Dinâmico na Janela de Contexto
+**Source:** [SOURCE: Extraído de "Mega Handoffs" apontando um erro drástico onde o LLM simplesmente esquecia tudo o que havia aprendido nas SOPs.]
+
+## Purpose
+
+Modelos mentais gravados numa wiki global morrem no esquecimento se não forem evocados. Durante tarefas profundas (coding, strategy design), os Agentes tenderem a agir de fábrica. Obrigar a evocação dos modelos da base destrava o verdadeiro valor do DNA intelectual preservado naquele projeto.
+
+## Configuration
+
+```yaml
+AN_KE_039:
+  name: "Checkpoint Categórico de Modelos Mentais"
+  zone: "excelencia"
+  trigger: "Estruturando tarefas sequenciais longas onde o risco de perda de aderência ao DNA do expert é elevado (Amnésia por contexto cheio)."
+
+  rule: |
+    SE há Agentes assumindo posições chave de raciocínio onde a filosofia interna de Alan (e experts copiados) importam
+    ENTÃO institua um 'Checkpoint Gate'. O sistema deve obrigar fisicamente o Agente a acionar a "Leitura do Modelo Mental / Heurísticas de Base" periodicamente na execução em cascata.
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) vs Sequencialismo de Validação"
+    resolution: "Checkpoints devem ler modelos mentais ANTES de engulir grandes volumes de dados externos. Limitar tokens de entrada antes do checkpoint, não depois."
+
+  veto_condition:
+    trigger: "Criar um batch iterativo de 50 ações em background que rodam à revelia dos princípios de design originais documentados no root."
+    action: "VETO — Insira micro-consultas (forcing functions) à base lógica dentro das Phases estipuladas."
+
+  evidence:
+    - "[EXACT WORDS]: Problema descoberto: Modelos mentais estão SOLTOS das tasks. Próxima sessão: Criar checkpoints dentro das tasks que FORÇAM consulta aos modelos mentais."
+```
+
+## Decision Tree
+
+```javascript
+IF (large_continuous_task OR executing_generative_work_sequence)
+  IF (task_does_not_contain_read_heuristics_command)
+    THEN BLOCK_EXECUTION
+    THEN INJECT_CHECKPOINT ("No Passo 4, antes da síntese, invoque/analise o arquivo 'oalanicolas.md' mental_models para afinar escolhas de design.")
+      IF (checkpoint successfully enforces LLM to context-load the file)
+        THEN proceed to Step 5 (Generation with mental overlay)
+  ELSE
+    // Explicit grounding ensures high-fidelity output
+    THEN ALLOW
+```
+
+## Failure Modes
+
+### A Diluição por Token Overload
+- **Trigger:** Ao pesquisar grandes quantidades de sites da web via Firecrawl no meio da pesquisa.
+- **Manifestation:** Depois de ler 20 mil palavras de concorrentes banais, a IA responde exatamente igual a eles, sem qualquer resquício do gênio socrático e da personalidade do framework do autor. A entropia diluiu sua voz no mar de tokens inúteis consumidos pela API.
+- **Detection:** Leitura da revisão mostra que está medíocre e "corporate-friendly".
+- **Recovery:** Parar, evocar a diretiva de DNA ("Lembre-se da regra: 40% da voz é conflito com opiniões óbvias") e gerar a síntese novamente.
+- **Prevention:** Veto-Gates ao longo do Workflow exigindo o preenchimento de templates "Estou Honrando o Mental Model XXX?".
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "mental-models-grounding"
+  heuristic: AN_KE_039
+  phase: "Continuous_Sprints / Synthesis"
+```
+
+## Validation
+
+- ✅ Paradoxo Identificado: Forçar evocação de modelos mentais vs. dilui-los via token overload
+- ✅ Resolução: Pré-filtrar entrada antes de aplicar checkpoints (evita amplificar o problema)
+- ✅ Implementação: Adicionar limite de tokens-de-entrada ao Decision Tree (Step 0)
+- ✅ Monitoramento: Detectar quando recovery é necessário via sinais de "output corporativo"

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

@@ -0,0 +1,130 @@
+---
+id: "AN_KE_040"
+title: "Agnosticização Mandatória em Infra"
+mind: "oalanicolas"
+type: "heuristics"
+zone: "excelencia"
+tags:
+  - "Architecture"
+  - "Portability"
+  - "Infrastructure"
+pipeline_instances:
+  - "process-architecture"
+  - "system-scaling"
+cross_mind_map:
+  convergent:
+    - id: "PV_PA_033"
+      title: "Executor Transversality"
+      mind: "pedro_valerio"
+      resonance: "Padrão de Infraestrutura Limpa: Módulos Core do Hub SINKRA (como Service Bus) não ligam se são de AIOX ou Synkra. PV eleva isso ao status de Executor Universal: 'se mudar o agente e a tela não muda, sua infra é transversal de fato'."
+    - id: "PV_PA_011"
+      title: "Optimization Interchangeability (Process Extinction)"
+      mind: "pedro_valerio"
+      resonance: "Ao modularizar tudo, você alcança o cenário apontado por PV onde modelos de custo alto podem ser sacados e executores baratos instalados na engrenagem sem tocar no fluxo inteiro."
+---
+
+# AN_KE_040 - Agnosticização Mandatória em Infra
+
+**Type:** Architecture Standard Heuristic
+**Phase:** 2 (Structural Assembly)
+**Agent:** @process-architect
+**Pattern:** HO-PP-AN040
+
+**sys_tension:**
+- **tension_with:** AN_KE_070 (Multi-IDE Sync Protocol) vs Agnóstico Completo de Infra
+- **resolution:** Agnóstico máximo + test matrix mínima (3 contextos: local, Docker, cloud). Cobertura > Genericidade quando há conflito.
+
+## Purpose
+
+Prevenir a criação de scripts de infraestrutura (parsers, validadores, pipelines genéricos, deployers compartilhados) que contêm nomes de projetos específicos hardcoded ("MMOS", "AIOX", `/Users/<username>`). Scripts de infraestrutura nasceram para servir N repositórios e N clientes. Quando não são agnósticos, morrem na primeira mudança de contexto — tornando-se dívida técnica imóvel.
+
+## Configuration
+
+```yaml
+AN_KE_040:
+  name: "Agnosticização Mandatória em Infra"
+  phase: 2
+  zone: "excelencia"
+  trigger: "Criando utilitários compartilhados, pipelines raiz, bash scripts genéricos ou qualquer script que atue fora do escopo restrito de um Squad."
+
+  weights:
+    dynamic_argument_usage: 1.0
+    literal_path_or_name_contamination: 1.0
+
+  thresholds:
+    hardcoded_project_name_tolerance: 0
+    hardcoded_local_path_tolerance: 0
+
+  veto_conditions:
+    - condition: "infrastructure_script_contains_literal_project_name_or_local_user_path == true"
+      action: "VETO - Infrastructure Lock-in. Replace all literals with dynamic arguments ($PROJECT_ROOT, $CLIENT_ID) passed by the caller."
+
+  output:
+    type: "decision"
+    values: ["APPROVE_AGNOSTIC", "REQUIRE_PARAMETRIZATION", "VETO"]
+```
+
+## Failure Modes (Anti-Patterns)
+
+```yaml
+failure_modes:
+  - type: "omission"
+    name: "Works on My Machine Syndrome (The Coward)"
+    trigger: "Alan empacota a infraestrutura fantástica do projeto MMOS para distribuir como ferramenta pública 'SuperAgentes'."
+    manifestation: "Todos os pipelines morrem com Pathing Error. Os scripts contêm `cd mmos` e chamadas a `PROJECT_ROOT=/Code/sinkra-hub`. Zero portabilidade."
+    detection: "Sentry mostrando erros de path em bloco para novos usuários. Arquivo funciona localmente, quebra em qualquer outro ambiente."
+    recovery: "Grep global para caminhos `/Users/`, nomes literais de projeto, substituindo por `${PROJECT_ROOT:-$(pwd)}`. Teste em Docker limpo."
+
+  - type: "misapplication"
+    name: "Over-Parametrization (The Zealot)"
+    trigger: "Dev parametriza absolutamente tudo, incluindo valores que nunca variam (ex: versão do protocolo, encoding charset)."
+    manifestation: "Script de 20 linhas exige 15 argumentos de CLI para rodar, sendo 12 deles constantes imutáveis de domínio."
+    detection: "README do script tem mais linhas de argumento documentation que o script em si."
+    recovery: "Distinguir: Variável de Contexto (path, client_id, project_name) = argumento dinâmico. Constante de Protocolo (encoding=UTF8, schema_version=1.2) = hardcoded é OK."
+```
+
+## Evaluation Criteria
+
+```yaml
+evaluation_criteria:
+  - metric: "Path Agnosticism"
+    weight: 1.0
+    threshold: "=== 0 literal paths"
+    description: "Zero caminhos absolutos de usuário (/Users/<username>/) ou projeto (/Code/mmos) estão hardcoded no script?"
+  - metric: "Dynamic Arguments"
+    weight: 1.0
+    threshold: "=== TRUE"
+    description: "O script aceita PROJECT_ROOT, CLIENT_ID e equivalentes como argumentos $1/$2 ou env vars para operar em qualquer contexto?"
+```
+
+## Decision Tree
+
+```javascript
+IF (Criando Script de Infraestrutura Compartilhada) {
+  SCAN("Literal paths e project names: /Users/, /Code/mmos, AIOX, <agent_owner>");
+  
+  IF (Literals_Found > 0) {
+    VETO("Infrastructure Lock-in detected.");
+    REQUIRE_PARAMETRIZATION("Substituir literals por: PROJECT_ROOT=$1, CLIENT_ID=$2, ou env var.");
+  } ELSE {
+    SIMULATE("Docker limpo. Rodar script com args dinâmicos apenas.");
+    IF (Test_Passes === TRUE) {
+      APPROVE_AGNOSTIC("Script agnóstico. Portável para qualquer cliente.");
+    }
+  }
+}
+
+NEVER("Criar scripts de infraestrutura que referenciam literalmente o nome do projeto atual, caminhos de máquina local ou identidades de cliente.");
+```
+
+## Validation
+
+**Checklist de Conformidade AN_KE_040:**
+
+- [ ] Script/utilitário não contém strings literais de projeto (MMOS, AIOX, AllFluence, etc.)
+- [ ] Paths não são absolutos hardcoded (`/Users/<username>`, `/Code/...`)
+- [ ] Todos os paths críticos são argumentos dinâmicos ou variáveis de ambiente
+- [ ] Testado em pelo menos 3 contextos: local filesystem, Docker container, cloud (S3/GCS)
+- [ ] Documentation descreve como chamar e quais env vars são obrigatórios
+- [ ] Código de infra NUNCA assume a máquina do autor — assume apenas Node.js 18+ e bash/sh
+- [ ] Gate validado antes de merge em `.aiox-core/infrastructure/`