aiox-core 5.0.5 → 5.0.7

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/`

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

@@ -0,0 +1,87 @@
+# AN_KE_041 - Output Path Discipline
+
+```yaml
+---
+id: AN_KE_041
+name: "Output Path Discipline"
+type: "Artifact Classification Heuristic"
+zone: "🔥 20% Impacto"
+agent: "@oalanicolas"
+pattern: "Separação outputs/ vs squads/"
+source: "[SOURCE: Sessão sinkra-hub 058541ef + regra artifact-classification.md]"
+sys_tension:
+  tension_with: "AN_KE_054 (Estrutura Orgânica de Diretórios) vs Isolamento de Outputs: paths devem ser orgânicos mas outputs devem ficar segregados"
+  resolution: "Criar symlinks em outputs/shared/ ou registry index em .aiox-core/core-config.yaml com mapa de outputs reutilizáveis por ID de artefato. Outputs imutáveis → versionados; outputs transitórios → TTL."
+```
+
+## Purpose
+
+Outputs de execução de pipelines/squads vão em `outputs/`, NUNCA dentro de `squads/` ou `workspace/`. Squads contêm config, agents, tasks. Outputs contêm resultados transitórios de execução.
+
+## Configuration
+
+```yaml
+AN_KE_041:
+  name: "Output Path Discipline"
+  zone: "impacto"
+  trigger: "Salvando resultados de pipeline, análise, validação, ou qualquer artefato gerado."
+
+  rule: |
+    SE artefato é resultado de execução de squad/task
+    ENTÃO salvar em outputs/{squad-name}/{context}/
+    NUNCA dentro de squads/{squad-name}/output/
+    NUNCA dentro de workspace/
+
+  veto_condition:
+    trigger: "Pipeline salvando resultados dentro da pasta do squad ao invés de outputs/."
+    action: "VETO — Mover para outputs/. Squads são config, não storage."
+
+  evidence:
+    - "[SOURCE: sessão 058541ef] 'o local certo para salvar isso é outputs na pasta principal e nao dentro do squad sinkra'"
+    - "[SOURCE: .claude/rules/artifact-classification.md] Decision tree: 'É output de execução de squad/task? SIM → outputs/{squad-name}/'"
+```
+
+## Decision Tree
+
+```javascript
+IF (saving_generated_artifact)
+  IF (artifact_is_config OR agent OR task OR template)
+    THEN SAVE in squads/{squad-name}/
+  ELSE IF (artifact_is_execution_output OR analysis OR report)
+    THEN SAVE in outputs/{squad-name}/{context}/
+  ELSE IF (artifact_is_business_document with template + registry)
+    THEN SAVE in workspace/businesses/{slug}/L{N}/
+```
+
+## Failure Modes
+
+### Squad Bloat
+- **Trigger:** Pipeline salva 50MB de outputs dentro de `squads/sinkra-squad/output/`.
+- **Manifestation:** Squad fica pesado, git clone lento, confusão entre config e outputs.
+- **Detection:** `du -sh squads/*/` mostra squad com >10MB.
+- **Recovery:** Mover para `outputs/` e atualizar paths nos scripts.
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "output-path-gate"
+  heuristic: AN_KE_041
+  phase: "Pipeline_Output_Design"
+```
+
+## Validation
+
+**Systemic Tension (sys_tension):**
+- **Tension With:** Pipeline reusability requirements vs. artifact isolation discipline
+- **Paradox:** Outputs must stay isolated in `outputs/` (not in `squads/`) to prevent config bloat → BUT outputs of one squad's execution frequently need to feed into downstream pipelines of other squads → requires fast discovery + access
+- **Resolution Path:** Version and index outputs via centralized registry (`.aiox-core/core-config.yaml → artifact_outputs[]`) instead of embedding paths. Symlinks allow logical grouping without duplication. TTL policies on transitional outputs separate temporary work from reusable artifacts.
+
+**Validation Checklist:**
+- [ ] Output directories contain ONLY execution artifacts (no config files, no agents, no tasks)
+- [ ] No outputs directory is nested inside `squads/{name}/`
+- [ ] `outputs/{squad-name}/{context}/` follows discoverable naming convention
+- [ ] Reusable outputs registered in artifact registry with immutability flag + version
+- [ ] Transitional outputs have explicit TTL; stale outputs pruned via `cleanup:artifacts` task
+- [ ] No pipeline reads outputs by hardcoded path; all reads go through registry lookup
+- [ ] git history shows outputs/ only contains committed outputs when intentional (not CI artifacts)