aiox-core 5.0.4 → 5.0.7

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

@@ -0,0 +1,69 @@
+# AN_KE_019 - Bug de Produção → Módulo Shared
+
+**Type:** Decision Heuristic
+**Zone:** 🔥 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Incident → Systemic Protection
+**Source:** [SOURCE: conversa Eudes 2026-03-29 sobre JSON mal-formado → json-validator.sh protege 14 runners]
+**sys_tension:** (localized_fix_vs_systemic_module, h3_threshold_decision)
+
+## Purpose
+
+Quando um bug de produção aparece, perguntar "outros scripts têm o mesmo risco?" Se sim, a correção deve ser um módulo shared, não um fix pontual. Custo igual, blast radius de proteção Nx maior.
+
+## Configuration
+
+```yaml
+AN_KE_019:
+  name: "Bug → Módulo Shared"
+  zone: "genialidade"
+  trigger: "Bug de produção reportado"
+
+  rule: |
+    SE bug de produção aparece
+    ENTÃO PERGUNTAR: "Outros scripts/runners têm o MESMO risco?"
+    SE SIM (3+ afetados) → criar módulo shared, não fix pontual
+    SE NÃO (isolado) → fix pontual OK
+
+  rationale: |
+    Custo de 1 módulo ≈ custo de 1 fix pontual
+    Mas proteção de 1 módulo = N scripts protegidos
+    ROI cresce linearmente com número de consumidores
+
+  evidence:
+    - "Eudes: JSON mal-formado em 1 pipeline"
+    - "Análise: 14 runners parsam JSON de LLM"
+    - "Fix pontual: protege 1. json-validator.sh: protege 14"
+    - "Custo: ~2h em ambos os casos"
+    - "Funções: json_extract (4 strategies), json_validate, json_get, json_has_fields"
+
+  tension_with: "AN_KE_007 (REUSE > CREATE) vs Quando criar módulo shared para bug sistêmico"
+```
+
+## Decision Tree
+
+```
+IF (production_bug_reported)
+  THEN count affected_scripts = grep across codebase
+    IF (affected_scripts >= 3)
+      THEN create shared module (H3 threshold met)
+      THEN integrate into all affected scripts
+    ELSE IF (affected_scripts == 1)
+      THEN fix pontual is OK
+    ELSE (affected_scripts == 2)
+      THEN fix pontual NOW, extract when 3rd appears (H3)
+```
+
+## Failure Modes
+
+### O JSON que Derrubou 14 Runners
+- **Trigger:** LLM gera JSON mal-formado. Sem json-validator.sh, 14 runners falhavam silenciosamente.
+- **Manifestation:** Bug descoberto em 1 script → mesma vulnerabilidade em 14 outros.
+- **Detection:** Eudes reportou JSON parsing error no pipeline.
+- **Prevention:** Bug em 1 script + afeta N scripts = shared module. json-validator.sh protege todos 14.
+
+## Validation
+
+**Paradoxo Identificado:** Custo de criação (1 módulo shared) ≈ Custo de fix pontual. Mas impacto de proteção é assimétrico: **1 fix protege 1 runner** vs **1 módulo protege 14 runners**. A decisão não é econômica (custo), é estratégica (cobertura de risco). O H3 threshold (3+ afetados) é o ponto de inflexão onde a assimetria justifica o investimento.
+
+**Resolução:** When cost is equal, blast radius of protection determines the decision. Systemic protection always wins over localized fixes when N ≥ 3.

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

@@ -0,0 +1,67 @@
+# AN_KE_020 - Formato Do Artefato É o Contrato
+
+**Type:** Decision Heuristic
+**Zone:** 🚀 20% Impacto
+**Agent:** @oalanicolas
+**Pattern:** Schema as Contract
+**Source:** [SOURCE: Epic 70+71 — validation.log e score_card.yaml padronizados via reporting.sh, 3 formatos → 1]
+**sys_tension:** (code_flexibility_vs_schema_rigidity, unified_schema_enforced_via_shared_emitters)
+
+## Purpose
+
+O formato do artefato de saída (log, score_card, state.json, progress.txt) é o contrato entre o runner e seus consumidores. Padronizar o formato é mais importante que padronizar o código.
+
+## Configuration
+
+```yaml
+AN_KE_020:
+  name: "Formato = Contrato"
+  zone: "impacto"
+  trigger: "Definindo outputs de pipeline/runner/processo"
+
+  rule: |
+    SE múltiplos scripts produzem artefatos consumidos por outros
+    ENTÃO padronizar o SCHEMA do artefato (campos, tipos, formato)
+    Código interno pode variar — o que importa é o output
+    Dois scripts podem ter código totalmente diferente
+    DESDE QUE produzam artefatos no mesmo schema
+
+  evidence:
+    - "validation.log: 3 formatos diferentes → 1 (Target/Type/Score/Verdict/Dims)"
+    - "score_card.yaml: 3 schemas → 1 (validation/checks/dimensions/scores)"
+    - "Qualquer ferramenta que lê score_card de qualquer runner sabe o schema"
+    - "reporting.sh: emit_validation_log() + emit_score_card_yaml() = contrato"
+
+  tension_with: "AN_KE_021 (Repair Layer Between Generator and Validator) — Schema rigidez vs flexibilidade de adaptação"
+```
+
+## Decision Tree
+
+```javascript
+IF (defining_pipeline_outputs)
+  STEP_1: DEFINE output schema (fields, types, format)
+    SCHEMA is the contract, not the code
+  STEP_2: VALIDATE all producers emit same schema
+    IF (producer_A.schema != producer_B.schema) → ALIGN schemas
+  STEP_3: CODE is free to vary internally
+    Two scripts with different code but same output schema = OK
+  NEVER: standardize code but leave outputs inconsistent
+```
+
+## Failure Modes
+
+### Os 3 Formatos de Score Card
+- **Trigger:** validate-skill, validate-squad, sinkra-map each produce score cards in different formats.
+- **Manifestation:** Consumer tool can't read score cards from different producers.
+- **Detection:** 3 parsers needed for 3 producers. Should be 1 parser, 1 schema.
+- **Prevention:** emit_score_card_yaml() as shared function. Schema = contract.
+
+## Validation
+
+**✓ Verified:** Schema standardization enforces contract invariants across heterogeneous producers.
+
+**✓ Evidence:** reporting.sh emit_validation_log() + emit_score_card_yaml() demonstrate single schema consumable by N producers with M internal implementations (code free to vary, schema immutable).
+
+**✓ Resolution:** Tension resolved via shared emitter functions — code flexibility achieved by centralizing schema contract, not duplicating it across producers.
+
+**✓ Applied in:** validate-skill, validate-squad, sinkra-map (unified score_card.yaml schema, parallel codebases).

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

@@ -0,0 +1,114 @@
+# AN_KE_021 - Repair Layer Between Generator and Validator
+
+**Type:** Architecture Heuristic
+**Zone:** 🚀 20% Impacto
+**Agent:** @oalanicolas
+**Pattern:** Defense in Depth
+**Source:** [SOURCE: Sessao 2026-03-29 — yaml-repair.py desbloqueou Opus (0% → 67% completion)]
+**sys_tension:** (Repair gratuito ($0) vs custo de implementar/manter worker determinístico | Resolver com automação open-source: json_repair (3M+ downloads), yaml-repair.py — um padrão já validado pela indústria)
+
+## Purpose
+
+Entre a geracao do LLM e a validacao, deve existir uma camada de repair deterministica. Repair e instantaneo e gratuito. Retry custa tokens e tempo.
+
+## Configuration
+
+```yaml
+AN_KE_021:
+  name: "Repair Layer"
+  zone: "impacto"
+  trigger: "Pipeline com LLM gerando structured output + validation"
+
+  rule: |
+    SEMPRE ter Worker de repair entre geracao e validacao
+    Fluxo: LLM gera → repair (deterministic, $0) → validate → retry (se necessario)
+    NUNCA validar output cru do LLM sem repair primeiro
+    Repair e mais barato que 1 retry (tokens vs $0)
+
+  anti_pattern: "Validar direto → falhar → retry → LLM gera mesmo erro → retry → circuit breaker"
+
+  tension_with: "AN_KE_058 (Verify LLM Output) — Direct validation vs repair-then-validate"
+
+  evidence:
+    - "Opus sem repair: 0/9 fases (5 iteracoes desperdicadas na fase 1)"
+    - "Opus com repair: 6/9 fases ($0.28, yaml-repair corrigiu 11 erros em <1s)"
+    - "Haiku sem repair: 0/9 fases (nested quotes repetiam 5x)"
+    - "Haiku com repair: 5/9 fases ($0.08)"
+    - "json_repair (pip): 3M+ downloads/mes — industria ja usa este pattern"
+    - "Custo de 1 repair: $0, <1s. Custo de 1 retry: ~$0.02-0.05, ~60s"
+
+  architecture:
+    flow: |
+      LLM.generate()
+        → repair_worker(output)     # $0, <1s, deterministic
+          → schema_validate(output) # $0, <1s, deterministic
+            → [PASS] use output
+            → [FAIL] retry_with_error_context(max=3)  # $$ per retry
+              → [STILL FAIL] fallback_model or escalate
+
+    repair_types:
+      json:
+        library: "json_repair (pip)"
+        fixes: "missing quotes, trailing commas, unescaped chars, incomplete objects"
+      yaml:
+        library: "yaml-repair.py (custom)"
+        fixes: "colon-in-value, nested quotes, tabs→spaces, scalar-with-child"
+      markdown:
+        library: "none needed (tolerant format)"
+
+  cost_comparison:
+    without_repair:
+      avg_retries: 2.5
+      cost_per_retry: "$0.02-0.05"
+      total_wasted: "$0.05-0.13 per phase"
+      time_wasted: "150-300s per phase"
+    with_repair:
+      repair_cost: "$0"
+      repair_time: "<1s"
+      avg_retries: 0.3
+      total_saved: "~$0.04-0.10 per phase"
+```
+
+## Decision Tree
+
+```javascript
+IF (pipeline_has_llm_generating_structured_output)
+  CHECK: is there a repair layer between generate and validate?
+    IF (NO) → ADD repair layer
+    IF (YES) → verify it covers most common error types
+
+  FLOW: LLM.generate() → repair($0, <1s) → validate($0) → [PASS|FAIL→retry($$)]
+
+  REPAIR_TYPE_SELECTION:
+    IF (json output) → use json_repair (pip, 3M+ downloads)
+    IF (yaml output) → use yaml-repair.py (custom: colon-in-value, nested quotes)
+    IF (markdown output) → no repair needed (tolerant format)
+
+  NEVER: validate raw LLM output without repair first
+  NEVER: use LLM for repair (defeats purpose — repair must be $0)
+```
+
+## Failure Modes
+
+### O Opus que Custou 5x Mais
+- **Trigger:** Opus generates YAML with syntax errors. No repair layer. 5 retries per phase.
+- **Manifestation:** 0/9 phases completed. 5 iterations wasted on phase 1. Cost: $0.05-0.13/phase in retries.
+- **Detection:** Retry rate > 2 per phase. Same error category repeating.
+- **Prevention:** yaml-repair.py between generate and validate. 0% → 67% completion. Repair cost: $0, <1s.
+
+## Validation
+
+**Checkpoints:**
+- [ ] Pipeline tem LLM gerando structured output (JSON/YAML)?
+- [ ] Existe repair layer entre generate e validate?
+- [ ] Repair é determinístico (não usa LLM)?
+- [ ] Repair custa $0 e roda em <1s?
+- [ ] Cobre json_repair (3M+ downloads) para JSON?
+- [ ] Cobre yaml-repair.py para YAML?
+- [ ] Retry só ocorre pós-repair e validation?
+- [ ] Métricas rastreiam retry rate vs repair cost?
+
+**Validação de Efetividade:**
+- Baseline: Retry rate > 2 por phase = sinal de falta de repair
+- Com repair: Retry rate cai para 0.3 por phase (90% redução)
+- ROI: ~$0.04-0.10 economizado por phase em retries evitados

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

@@ -0,0 +1,75 @@
+# AN_KE_022 - Format Follows Generator
+
+**Type:** Architecture Heuristic
+**Zone:** 🔥 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Output Format Selection
+**Source:** [SOURCE: Sessao 2026-03-29 — benchmark 4 modelos SINKRA map-process, migracao YAML→JSON]
+
+```yaml
+sys_tension:
+  tension_with: "AN_KE_021 (Repair Layer Between Generator and Validator) vs Format Mutation Cost"
+  conflict: "JSON is 5x safer for LLM generation (98% validity vs 0% YAML errors), but YAML is +11.8pp better for human consumption"
+  resolution: "Use generator format for creation (JSON), convert deterministically to consumer format (YAML/MD) post-generation. Generator safety trumps consumer preference at creation time."
+  trade_off: "Accept JSON-to-YAML conversion overhead to eliminate 5x retry cost. Cost of failed generation >> cost of deterministic conversion."
+```
+
+## Purpose
+
+O formato de output deve ser escolhido pela capacidade do gerador, nao pela preferencia do consumidor. Gerar no formato mais seguro e converter no destino.
+
+## Configuration
+
+```yaml
+AN_KE_022:
+  name: "Format Follows Generator"
+  zone: "genialidade"
+  trigger: "Escolhendo formato de output pra LLM"
+
+  rule: |
+    SE LLM gera o output → JSON (sintaticamente rigido, sem ambiguidade)
+    SE humano consome → converter JSON→YAML/MD no destino (deterministico)
+    NUNCA pedir pro LLM gerar no formato de consumo se existe formato mais seguro
+
+  evidence:
+    - "3/4 erros YAML nao existem em JSON (colon-in-value, nested quotes, indentation)"
+    - "Opus 0% completion com YAML vs ~98-100% JSON validity"
+    - "Haiku bloqueio 100% por YAML, nao por capacidade"
+    - "StructEval 2025: JSON generation >90% validity; YAML melhor pra leitura (+11.8pp)"
+```
+
+## Decision Tree
+
+```javascript
+IF (choosing_output_format_for_llm)
+  STEP_1: WHO generates? LLM or deterministic code?
+    IF (LLM) → JSON (syntactically rigid, no ambiguity)
+    IF (code) → any format (deterministic = no risk)
+  STEP_2: CONSUMER needs different format?
+    IF (yes) → convert JSON→YAML/MD deterministically POST-generation
+    IF (no) → keep as JSON
+  STEP_3: COST of format failure?
+    YAML: ~5x retry rate (colon-in-value, indentation, nested quotes)
+    JSON: ~0.3x retry rate (syntactically strict)
+  NEVER: ask LLM to generate in consumer format if safer format exists
+```
+
+## Failure Modes
+
+### O Opus que Não Completou (0% YAML)
+- **Trigger:** Asking Opus to generate YAML output for squad config.
+- **Manifestation:** 0% completion rate. Every response has YAML syntax errors.
+- **Detection:** Opus $0.28/run with 0% usable output vs JSON at ~98% validity.
+- **Prevention:** Format Follows Generator. LLM → JSON → convert to YAML deterministically.
+
+---
+
+## Validation
+
+**Paradox Identified:** Security vs. Usability trade-off
+- **JSON Generation Security:** 98% validity rate, 0.3x retry factor
+- **YAML Readability:** +11.8pp human comprehension improvement
+- **Resolution Proof:** Deterministic JSON→YAML conversion eliminates both risks (safe generation + usable output)
+- **Evidence:** 4-model benchmark (Opus, Sonnet, Haiku, Quantized) shows 100% YAML blocker but 5x JSON success with conversion overhead < generation retry cost
+
+**Status:** ✓ Validated via empirical benchmark data and failure mode analysis

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

@@ -0,0 +1,60 @@
+# AN_KE_023 - Tier System e Invisivel
+
+**Type:** Observability Heuristic
+**Zone:** 💎 4% Excelencia
+**Agent:** @oalanicolas
+**Pattern:** Transparency in Abstraction
+**Source:** [SOURCE: Sessao 2026-03-29 — --model haiku resolvia pra opus silenciosamente]
+**sys_tension:** (transparency vs. resource optimization, resolve via explicit logging + user control)
+
+## Purpose
+
+Abstracoes de routing devem ser transparentes. Se o usuario pede haiku e recebe opus, a abstracao falhou. Todo override deve ser logado.
+
+## Configuration
+
+```yaml
+AN_KE_023:
+  name: "Tier System e Invisivel"
+  zone: "excelencia"
+  trigger: "Implementando abstracao de routing (modelo, runtime, provedor)"
+
+  rule: |
+    SE abstracao sobrescreve decisao do usuario → LOGAR explicitamente
+    SEMPRE logar modelo REAL, nao o pedido
+    OFERECER bypass explicito (--force-model)
+
+  tension_with: "AN_KE_106 (Subagents Over Flattened Tasks) — Abstrações de routing para ganho de throughput vs Transparência de recursos"
+
+  evidence:
+    - "--model haiku resolvia pra opus nas fases high (tier system silencioso)"
+    - "Benchmark 'Haiku' $0.29 = 'Opus' $0.28 — eram o mesmo modelo"
+    - "Fix: --force-model + log do modelo real por fase"
+```
+
+## Decision Tree
+
+```javascript
+IF (implementing_routing_abstraction: model, runtime, provider)
+  REQUIRE: log ACTUAL resource used (not just requested)
+  REQUIRE: log OVERRIDE if abstraction changed user's choice
+  REQUIRE: --force-{resource} bypass flag
+  IF (user_request != actual_used) → LOG: "Requested: X, Used: Y, Reason: Z"
+  NEVER: silently substitute without logging
+```
+
+## Failure Modes
+
+### O Benchmark que Cusava o Dobro
+- **Trigger:** `--model haiku` silently routed to opus. Benchmark showed haiku $0.29 ≈ opus $0.28.
+- **Manifestation:** "Eram o mesmo modelo" — tier system invisible, costs hidden.
+- **Detection:** Cost analysis shows haiku suspiciously expensive. Same price = same model.
+- **Prevention:** Log real model per phase. `--force-model` bypass for benchmarking.
+
+## Validation
+
+✓ **Paradox Identified:** Abstraction (routing optimization) contradicts transparency (user must know what runs). User requests haiku for cost control, system substitutes opus, cost remains similar (masking the swap).
+
+✓ **Tension Resolved:** Explicit logging of actual model used + `--force-model` flag restores user control while allowing optimization. When costs are identical, transparency reveals the truth.
+
+✓ **Heuristic Sound:** Applies to any routing layer (model, runtime, provider). Prevention requires dual mechanism: logging + user override.

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

@@ -0,0 +1,66 @@
+# AN_KE_024 - Resume = Same Run
+
+**Type:** State Management Heuristic
+**Zone:** 💎 4% Excelencia
+**Agent:** @oalanicolas
+**Pattern:** Pipeline Continuity
+**Source:** [SOURCE: Sessao 2026-03-29 — --phase 8 criou run nova, QA deu 4/100 em pasta vazia]
+
+## Purpose
+
+Retomar pipeline = continuar NA MESMA pasta. Criar nova run pra resume quebra dependencias entre fases.
+
+## Configuration
+
+```yaml
+AN_KE_024:
+  name: "Resume = Same Run"
+  zone: "excelencia"
+  trigger: "Implementando resume/retry em pipeline multi-fase"
+
+  rule: |
+    SE --phase N (resume) → resolver ultima run → continuar nela
+    NUNCA criar novo RUN_ID pra resume
+    Artefatos anteriores DEVEM estar acessiveis
+
+  evidence:
+    - "--phase 8 criou run nova sem artefatos 1-7 → score 4/100 (invalido)"
+    - "Score real na run correta: 83.05/100 (MAP-READY)"
+    - "Fix: resolver symlink 'latest' em vez de criar novo RUN_ID"
+
+  sys_tension:
+    tension_with: "AN_KE_025 (Determinism Over LLM) — Resume must be deterministic (same run always) vs Default pipeline behavior (create new RUN_ID on new phase invocation)"
+    resolution: "Resolver symlink 'latest' → last RUN_ID antes de criar run. Verificar artefatos anteriores existem em mesmo diretório antes de iniciar fase N. Se ausentes, erro + não prosseguir em estado vazio."
+```
+
+## Decision Tree
+
+```javascript
+IF (implementing_resume_in_pipeline)
+  REQUIRE: --phase N resolves to LATEST run, not new run
+  REQUIRE: artifacts from phases 1..N-1 accessible in same directory
+  IMPLEMENTATION:
+    RESOLVE: symlink 'latest' → last RUN_ID
+    RESUME: continue in 'latest/' directory
+    VERIFY: previous phase artifacts exist before starting phase N
+  IF (previous artifacts missing) → ERROR with message, don't proceed with empty state
+  NEVER: create new RUN_ID for resume — breaks inter-phase dependencies
+```
+
+## Failure Modes
+
+### O Score 4/100 na Pasta Vazia
+- **Trigger:** `--phase 8` creates new run directory. QA runs on empty directory without phases 1-7.
+- **Manifestation:** Score 4/100 (invalid) vs correct run's 83.05/100 (MAP-READY).
+- **Detection:** Score anomalously low + phase artifacts missing from run directory.
+- **Prevention:** Resume resolves 'latest' symlink. All artifacts in same directory.
+
+## Validation
+
+✓ **Paradoxo identificado:** Resume automático cria novo RUN_ID (quebra dependências) vs Resume deve manter MESMA run (preserva estado)
+
+✓ **Resolução implementada:** Symlink 'latest' resolve para último RUN_ID válido. Verificação obrigatória de artefatos anteriores antes de iniciar fase N.
+
+✓ **Critério de sucesso:** Score QA na run resumida ≥ 80/100. Score em pasta vazia < 10/100 (rejeição automática).
+
+✓ **Aplicação:** Pipeline multi-fase + resume/retry scenarios.

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

@@ -0,0 +1,81 @@
+# AN_KE_025 - Determinism Over LLM
+
+**Type:** Core Architecture Heuristic
+**Zone:** 🧠 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Tech Stack vs LLM
+**Source:** [SOURCE: Extraído de discussões sobre testes, validações e limites técnicos, onde bash resolve em milissegundos o que LLMs falham em resolver por tokens.]
+
+## Purpose
+
+Prevenir alucinações de LLM e lentidão em tarefas de "fato exato" que não exigem raciocínio cognitivo, como matemática, checagem de existência de arquivo ou parse de regex. O Worker Executivo (script/bash) é mais barato, infalível e milissegundo.
+
+## Configuration
+
+```yaml
+AN_KE_025:
+  name: "Determinism Over LLM"
+  zone: "genialidade"
+  trigger: "Decidindo se uma funcionalidade de validação deve ser confiada ao Workflow ou se a IA deve interpretar os arquivos cruamente."
+
+  rule: |
+    SE o processo exige contar itens, validar caminhos exatos, checar chaves num YAML ou bater regex
+    ENTÃO resolva com Python ou Bash. O custo é 0 e a falha também.
+    LLMs são para 'entendimento' e não para parser mecânico.
+
+  veto_condition:
+    trigger: "Tentativa de usar o Claude ou agente para contar tokens, ler listas de JSON brutos grandes para validação exata."
+    action: "VETO — Construa um parser script."
+
+  evidence:
+    - "[EXACT WORDS]: LLMs falham ao validar caminhos ou contar itens; bash/python acerta e custa $0."
+
+  sys_tension:
+    tension_with: "AN_KE_073 (Parallel Subagents for Throughput) — Complexidade de parsing local vs throughput paralelo."
+    resolution: "Resolver via **meta-guard** determinístico: o script é a fonte de verdade. O agente executa script primeiro, depois atua apenas sobre resultado concreto. Não há decisão sobre mecanismo—há execução de script e processamento de saída."
+```
+
+## Decision Tree
+
+```javascript
+IF (task requires logical validation OR numerical extraction OR static file check)
+  IF (task relies on interpretation of unstructured text)
+    THEN ALLOW_LLM
+  ELSE
+    THEN BLOCK_LLM
+    THEN DELEGATE_TO_DETERMINISTIC_SCRIPT (Bash / Python)
+      IF (script throws exception)
+        THEN pipe the exact stdout/stderr to LLM for debugging only
+      ELSE
+        THEN proceed safely with deterministic result
+```
+
+## Failure Modes
+
+### Agent Validation Fatigue
+- **Trigger:** Pedir ao agente para conferir se 10 arquivos .yaml seguem uma chave num array de 500 linhas.
+- **Manifestation:** O agente diz "Tudo parece correto!" e ignora 4 arquivos mal formatados por preguiça/truncamento de contexto.
+- **Detection:** Código quebra na execução pós-LLM check.
+- **Recovery:** Escrever um `validator.sh` simples.
+- **Prevention:** Incorporar a lógica desde a sub-task com script pronto.
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "llm-determinism-gate"
+  heuristic: AN_KE_025
+  phase: "Task_Execution"
+
+  validation_questions:
+    - "Daria pra fazer isso com 3 linhas de bash ao invés de usar contexto de IA?"
+    - "Existe a possibilidade de alucinação impactar criticamente este array de dados?"
+```
+
+## Validation
+
+✅ **Paradox Resolved:** O loop circular (LLM decidindo se bloqueia LLM) é neutralizado pela **delegação compulsória ao script**. O agente não decide—executa.
+
+✅ **Operacionalização:** Todo checkpoint contém call-out determinístico antes de qualquer interpretação cognitiva.
+
+✅ **Critério de Sucesso:** Tarefa mecanicista falha por erro de script (falso positivo), nunca por alucinação LLM.

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

@@ -0,0 +1,82 @@
+# AN_KE_026 - Squad Agnosticism
+
+**Type:** Architecture Standard Heuristic
+**Zone:** 💎 4% Excelência
+**Agent:** @oalanicolas
+**Pattern:** Encapsulamento de Agent / Squad
+**Source:** [SOURCE: Extraído de decisões corporativas para isolar a regra estratégica de negócios da operação pura do squad.]
+
+## Purpose
+
+Proteger a arquitetura agnóstica dos Squads (que são produtos ou entidades que resolvem problemas genéricos) impedindo que lógicas específicas de projetos (ex: o cliente "MMOS" ou "Academy") sejam inseridas cruamente em código core.
+
+## Configuration
+
+```yaml
+AN_KE_026:
+  name: "Squad Agnosticism"
+  zone: "excelencia"
+  trigger: "Criando ou editando as tarefas e workflows de um Squad."
+
+  rule: |
+    SE você criar código, workflows ou prompts para um Squad
+    ENTÃO não coloque variáveis estáticas exclusivas da corporação do cliente. Busque isso na Workspace/Truth.
+
+  veto_condition:
+    trigger: "Encontrar nomes como 'Academy', caminhos literais do mac locais em scripts globais ou emails estáticos."
+    action: "VETO — Externalizar para variáveis de configuração ou workspace."
+
+  evidence:
+    - "[EXACT WORDS]: SE construir regras para o squad, elas devem consultar o workspace para os metadados core."
+
+  sys_tension:
+    tension_with: "AN_KE_007 (REUSE > CREATE) vs Squad Agnosticism"
+    description: "Squads must remain agnostic (no hardcoded business names) yet simultaneously must resolve business-specific context at runtime (brand, domain, locale). This creates a circular dependency: agnosticism requires abstraction, but abstraction must bind to specific context layers."
+    resolution: "Separate concerns via Configuration Injection Pattern — Squad code stays pure (agnostic), configuration resolution happens at squad instantiation time via Workspace + Environment bindings. The squad itself never hardcodes; the system binds context to squads via dependency injection."
+```
+
+## Decision Tree
+
+```javascript
+IF (writing_squad_code OR scripting_workflow)
+  IF (variable_refers_to_business_identity OR domain OR local_path)
+    THEN BLOCK_HARDCODING
+    THEN RETRIEVE_FROM (Workspace / Knowledge Base / env)
+      IF (knowledge base lacks this info)
+        THEN trigger prompt request to user "Por favor forneça no workspace configurador da marca XYZ"
+      ELSE
+        THEN use reference securely
+  ELSE
+    THEN ALLOW (only if universal framework logic)
+```
+
+## Failure Modes
+
+### Hardcoded Legacy Break
+- **Trigger:** Usar o squad `Content_Creator` para outro cliente.
+- **Manifestation:** O squad gera resultados fantásticos, mas assina tudo como "AIOX Academy", enviando os emails da empresa antiga.
+- **Detection:** Reclamação dos consumos em downstream reportando chaves erradas.
+- **Recovery:** Buscar o grep de todos os "AIOX", "Alan", e transformar em `{{brand_name}}` templates ligados à camada Workspace.
+- **Prevention:** Veto na implementação se o código referenciar string de empresa literais.
+
+## Integration with Workflow
+
+```yaml
+checkpoint:
+  id: "agnostic-squad-validator"
+  heuristic: AN_KE_026
+  phase: "Squad_Architecture"
+
+  criteria:
+    - metric: "has_business_specific_strings_in_core"
+      threshold: FALSE
+      operator: "=="
+```
+
+## Validation
+
+✅ **Paradox identified & resolved:**
+- **Paradox:** Agnosticism vs. contextual binding (circular dependency)
+- **Resolution mechanism:** Configuration Injection Pattern decouples squad code from business context
+- **Test case:** Squad code scans clean (no "Academy", "AIOX", "Alan") → Context resolved at instantiation → Output correctly branded
+- **Implementation:** `@squad-creator-pro` enforces via linter rule `no-hardcoded-business-strings` in squad config validation