aiox-core 5.0.4 → 5.0.7

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

@@ -0,0 +1,60 @@
+# AN_KE_112 - Fluid Narrative Over Rigid Blocks
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 6780346b, aiox-stage — "não podemos deixar engessado, quero algo fluído que respeite a narrativa"]
+
+## Purpose
+
+Sistemas geradores de conteúdo geridos por LLM tendem à preguiça formulaica. O programador cria um JSON com `[ { "titulo_H2": "..." }, { "descricao": "..." }, { "bullet_points": [...] } ]`. Todo artigo sai parecendo um robô do LinkedIn engessado em blocos quadrados. A conversão afunda. O AIOX decreta o Veto à Formatação de Metal. A regra exige que as abstrações do copy gerem prosa "viciante" interlacada e flexível. Elementos opcionais não podem estar forçados. O texto / UI tem a função central de competir com a dopamina fragmentada das redes sociais (TikTok).
+
+## Configuration
+
+```yaml
+AN_KE_112:
+  name: "Fluid Narrative Over Rigid Blocks"
+  zone: "genialidade"
+  trigger: "Estruturando parsers estruturais (JSON/Schema) para Content Generation, Landing Pages, Onboarding UX ou Copy."
+
+  rule: |
+    SE instanciando geradores massivos de templates, perfis de UI e redatores
+    ENTÃO NUNCA algeme o layout/texto em formulas repetitivas estritas (`[INTRO] + [3 BUGGLETS] + [OUTRO]`).
+    A narrativa final DEVE fluir dinamicamente e quebrar blocos.
+    Se não captura a atenção frente a um reel do TikTok, falhou estruturalmente.
+
+  veto_condition:
+    trigger: "Agente projeta o banco para os Relatórios AIOX exigindo, Obrigatoriamente, o preenchimento de `h3`, `quote` e `table` sem chance de omitir as partes supérfluas."
+    action: "VETO — 'não podemos deixar engessado, quero algo fluído que respeite assima de tudo a narrativa, o texto preguiça ser viciante, para tirar as pessoas do tiktok pra lerem'."
+
+  sys_tension:
+    tension_with: "AN_KE_110 (Abstraction Funneling / Everything is an Artifact) — rigidez de artefatos vs. fluidez narrativa"
+    resolution: "Aplicar flexibilidade narrativa DENTRO de contrato de dados validável. Schema define campos obrigatórios de negócio; geração de conteúdo omite elementos UI/prosa sob demanda textual sem violar integridade dos dados. Paradigma: estrutura nos limites, fluidez no interior."
+
+  evidence:
+    - "[SOURCE: sessão 6780346b, aiox-stage/copy] 'tem cosias que nao acho que necesariaemnte precisamso ter em todos... não podemos deixar engessado, quero algo fluído que respeite assima de tudo a narrativa, o texto preguiça ser viciante, para tirar as pessoas do tiktok pra lerem'"
+```
+
+## Decision Tree
+
+```javascript
+IF (designing_content_structure_for_apps_or_pages)
+  STEP_1: AVOID rigid schema definitions for storytelling parts (`Record<string, string>`).
+  STEP_2: FAVOR fluid arrays of modular components (like Markdown/PortableText AST).
+    -> Permits the AI to drop a component if it breaks flow.
+  STEP_3: INJECT system prompt instructing the agent to actively ignore specific formalisms in favor of a gripping, conversational narrative cadence.
+```
+
+## Failure Modes
+
+### Monotonia Robótica de Interface
+- **Trigger:** Todos os alunos recebem o "Seu Perfil Mapeado" no Curseduca através de um H1 e 1 lista não ordenada.
+- **Manifestation:** Retenção lida do e-mail / pagec cai de 80% pra 10% porque 4 linhas abaixo da fold todos já notam ser um autômato previsível respondendo.
+- **Prevention:** Estruturar a geração flexível omitindo/incluindo componentes lógicos sob demanda textual orgânica.
+
+---
+
+## Validation
+
+**Paradoxo Identificado:** Estrutura rígida (necessária para consistência de dados e governança) vs. Narrativa fluida (essencial para engagement e retenção).
+
+**Resolução:** O paradoxo é falso. A rigidez pertence ao **contrato de dados** (quais campos DEVEM existir, tipos, validações), enquanto a fluidez pertence à **camada de apresentação** (como o conteúdo é renderizado, quais elementos são opcionais, qual a sequência narrativa). Separar ambas as preocupações permite que a IA gere estruturas conformes aos limites de negócio mas narrativas adaptativas que competem por atenção.
+
+**Indicador de Sucesso:** Relatório de leitura/retenção sobe acima de 60% (vs. baseline robótico 10-20%) mantendo auditoria de dados em 100%.

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

@@ -0,0 +1,74 @@
+# AN_KE_113 - Heavy Assets Lazy Loading
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão 8c6ffe77, aiox-performance — "erro brutal de performance de carregamento"]
+
+## Purpose
+
+As engrenagens de um Frontend luxuoso desmoronam se a orquestração de imagens trafega blobs nativos no primeiro LCP (Largest Contentful Paint). Ao consumir perfis, posters educacionais ou backgrounds no MMOS, puxar o raw HD (ex: 2.5MB png) trava toda a thread renderizadora. O UX congela. A lei determina a imposição sumária de técnicas de performance de imagens: Cloudinary resizes integradados, `<picture>` tags com variação WEPB e lazy loaders (ex: framer-motion estrito, placeholder blur) a nível fundamental do React/Edge. Carregamento invisível em partes pesadas. 
+
+## Configuration
+
+```yaml
+AN_KE_113:
+  name: "Heavy Assets Lazy Loading"
+  zone: "genialidade"
+  trigger: "Construindo Hero Sections, Listas de Cards visuais intensos, Páginas que renderizam `<img>` não contidas."
+
+  paradox: |
+    Qualidade visual exige resolução alta, mas performance exige resolução baixa.
+    Lazy loading difere carregamentos (ganha performance) mas cria layouts iniciais vazios (piora perceived performance).
+    CDN caches reduzem latência mas aumentam custo operacional.
+
+  sys_tension:
+    - tension_with: "AN_KE_103 (Local Caching Over Live Database)"
+      resolution: "Usar responsive srcsets + blur-up placeholders para manter estética sem sacrificar métrica vitais"
+    - tension_with: "AN_KE_050 (Cost Optimization)"
+      resolution: "Implementar intelligent caching (14d TTL) e regional CDN distribution para otimizar custo/performance ratio"
+
+  rule: |
+    SE implementando renderizações de imagem vindas de S3, Supabase Storage ou remotas
+    ENTÃO DEVE aplicar restritor de payload. Exija lazy loading estrito `loading="lazy"` (abaixo da fold).
+    NUNCA carregue resolução bruta para uma view diminuta (A thumbnail de Card não pode possuir 2000px).
+    Falta de compressão ou deferment quebra as métricas vitais web do luxo.
+
+  veto_condition:
+    trigger: "Agente monta componente `ProfileGrid` mapeando usuários e instanciando o Storage Object integral para ilustrar pequenas miniaturas de 32x32 numa navbar."
+    action: "VETO — 'As imagens estão sendo carregados em sua totalidade, isso também é um erro brutal de performance de carregamento.'."
+
+  evidence:
+    - "[SOURCE: sessão 8c6ffe77, aiox-performance] 'As imagens estão sendo carregados em sua totalidade, isso também é um erro brutal de performance de carregamento.'"
+```
+
+## Decision Tree
+
+```javascript
+IF (generating_ui_code_with_media_like_avif_webp_png)
+  STEP_1: QUERY target rendering size (Is this a 30px avatar OR a fullscreen Hero Video?)
+  STEP_2: IF (Below the Fold or ListView)
+    -> APPEND `loading="lazy"` instantly.
+  STEP_3: IMPLEMENT responsive Srcsets / Next/Image optimizer proxies IF using full frameworks.
+  STEP_4: Provide blur-up or skeleton placeholders preventing layout shift during dynamic payload resolution.
+```
+
+## Failure Modes
+
+### Quebra do TTI (Time to Interactive)
+- **Trigger:** Carregamento de dashboard Admin AIOX tenta baixar todos os 30 fundos de imagem dos templates de layout antes de montar o Sidebar.
+- **Manifestation:** Tela Branca que penaliza o First Paint por 4 segundos e joga fora a estética "Luxury/Fast" pretendida pela arquitetura de interface. O site parece barato.
+- **Prevention:** Estruturação assíncrona da media de massa (Deferring Assets).
+
+## Validation
+
+**Paradox Resolution:** A tensão entre qualidade visual (alta resolução) e performance (baixa latência) é resolvida via **adaptive delivery**: servir resolução apropriada ao contexto de layout usando responsive srcsets + blur-up placeholders. Isso preserva estética sem sacrificar métricas Web Vitals.
+
+**Tension Mapping:**
+- ✅ Resolvida com AN_KE_001: Blur-up placeholders mantêm percepção de qualidade durante lazy loading
+- ✅ Resolvida com AN_KE_050: Regional CDN + intelligent caching reduz custo operacional sem sacrificar performance
+
+**Implementation Checklist:**
+- [ ] Todas imagens acima da fold usam srcsets responsivos (AVIF, WebP, PNG)
+- [ ] Todas imagens abaixo da fold aplicam `loading="lazy"`
+- [ ] Placeholders blur ou skeleton implementados para transições suaves
+- [ ] Cloudinary transforms configurados para resolução contextual
+- [ ] Cache headers ajustados (14d TTL imagens, 1h assets dinâmicos)
+- [ ] Web Vitals monitorados (LCP, FID, CLS)

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

@@ -0,0 +1,55 @@
+# AN_KE_114 - Dynamic Variances in UX
+**Zone:** 🧠 0,8% Genialidade | **Agent:** @oalanicolas
+**Source:** [SOURCE: sessão c6cc1808, aiox-ui — "nao tao engessados ... variar de titulos"]
+
+## Purpose
+
+O efeito "Deja Vu" digital é mortal (A fadiga da uniformidade). Quando o React Component tem Títulos ou Textos fixos como `"Seu Portal AIOX"` engessados em todo maldito reload, a interface para de surpreender o cérebro humano. A heurística dita que um software premium que lida com inteligência artifical é *Vivo e Dinâmico*. Insira vetores randomizados com classe (Greetings temporais baseados no relógio, variações em títulos secundários de sub-header no Load). O frontend deve oscilar organicamente para evitar parecer um bloco rígido semalma programada via template obsoleto.
+
+## Configuration
+
+```yaml
+AN_KE_114:
+  name: "Dynamic Variances in UX"
+  zone: "genialidade"
+  trigger: "Programando componentes vitais estáticos de Welcome, Headers, Onboarding text ou Landing Pages."
+  sys_tension:
+    tension_with: "AN_KE_027 (Zero Emojis & Design Consistente)"
+    resolution: "Variações dinâmicas respeitam DNA visual (paleta, tipografia, tone-of-voice). Caos criativo dentro de um framework estruturado."
+
+  rule: |
+    SE implementando um template massificado de visualização do domínio UX
+    ENTÃO ELIMINE engessamentos robóticos. A interface DEVE ter variações no copy textual embarcado.
+    Mude o tom. Varie os greetings. Não repita mecanicamente a mesma descrição "Abaixo todos os seus itens" se puder randomizar gentilmente 4 strings no frontend para fluidez psicológica.
+
+  veto_condition:
+    trigger: "Agente encerra a Dashboard de cursos contendo estaticamente um `h1>Bem Vindo ao Dashboard</h1` que nunca oscila com o retorno ou uso do aluno."
+    action: "VETO — 'nao faz sentido ser o mesmo título sempre, quero variaaccao de titulos... aproveitar melhor o design da página para sermos mais fluidos, e nao tao engessados'."
+
+  evidence:
+    - "[SOURCE: sessão c6cc1808, aiox-ui] 'nao faz sentido ser o mesmo título sempre, quero variaaccao de titulos, e nao quero falar de figma tanto quanto estamos falando, precisamos aproveitar melhor o design da página para sermos mais fluidos, e nao tao engessados'"
+```
+
+## Decision Tree
+
+```javascript
+IF (hardcoding_generic_greeting_titles_or_copy_in_TSX_UI)
+  STEP_1: PAUSE construction of static texts.
+  STEP_2: REPLACE static `<h1>Dashboard AIOX Front</h1>` with dynamic arrays or contextual hooks.
+    `const titles = ["Pronto para avançar?", "Seus assets arquiteturais:", "Mapeado e ativo."]`
+    `const title = sample(titles)`
+  STEP_3: IMPLEMENT intelligent UI logic taking advantage of the space fluidity (dynamic heights, changing sub-components) rather than blocky borders.
+```
+
+## Failure Modes
+
+### Sintomatologia Clássica de Software Legado
+- **Trigger:** Portal administrativo sempre dá o exato mesmo texto robótico padrão do TailwindUI ou Next.js starter pack em suas páginas centrais.
+- **Manifestation:** Destrói o gatilho da sofisticação de um software que deveria ser customizado ao portador; fica idêntico ao dashboard da loja da esquina de bairro.
+- **Prevention:** Aleatoriedade injetada no frontend com contexto temporal ou comportamental (Fluid UX).
+
+## Validation
+
+**Paradoxo Identificado:** Ordem (templates estáticos) vs Caos (variações dinâmicas sem critério) = interface confusa ou inconsistente.
+
+**Resolução:** Estruturar a aleatoriedade. Bancos de copy pré-aprovados + contexto temporal/comportamental (não puro random). Exemplo: greetings variam por período do dia (bom dia, boa tarde, boa noite) ou por estado do usuário (first-login, returning-user, power-user). Assim há **previsibilidade estruturada** (a interface não é idêntica ao refresh, mas é confiável). Esta é a síntese: caos criativo dentro de guardrails de marca.

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

@@ -0,0 +1,126 @@
+---
+id: "AN_KE_115"
+title: "Task to Skill: The Right Question"
+mind: "oalanicolas"
+type: "heuristics"
+zone: "genialidade"
+tags:
+  - "Skill Design"
+  - "Workflow Architecture"
+  - "Framework Design"
+pipeline_instances:
+  - "process-architecture"
+  - "scaffolding"
+cross_mind_map:
+  convergent:
+    - id: "PV_PA_013"
+      title: "Task-First Primacy"
+      mind: "pedro_valerio"
+      resonance: "Ambos exigem que a task tenha inputs/outputs claros e independentes de quem a executa. PV define task pelo I/O (não pelo executor). AN define se a task pode se tornar skill pelo mesmo critério de I/O autossuficiente."
+    - id: "PV_PA_004"
+      title: "Zero-Cost Determinism (Worker First)"
+      mind: "pedro_valerio"
+      resonance: "PV usa I/O clarity para decidir se uma task vai para Worker. AN usa o mesmo critério de I/O standalone para decidir se uma task vira Skill. Mesmo teste, decisões diferentes mas complementares."
+  tension:
+    - id: "PV_PA_040"
+      title: "Transparent Exchange Fallacy"
+      mind: "pedro_valerio"
+      divergence: "Ângulo de entrada inverso — não contradição. PV opera em execution time: 'o que auditar DENTRO do workflow ao trocar executor?' AN opera em design time: 'o que pode SAIR do workflow como skill?' São ortogonais: nunca se encontram no mesmo ponto de decisão. Premissa compartilhada: o workflow é o organismo primário que dita as regras."
+      invalidates: false
+---
+
+# AN_KE_115 - Task to Skill: The Right Question
+
+**Type:** Framework Design Heuristic
+**Phase:** 1 (Diagnostics)
+**Agent:** @process-architect
+**Pattern:** HO-PP-AN115
+
+## Purpose
+
+A pergunta "skill vs squad?" é a pergunta errada. A pergunta certa é: "quando uma task deve virar skill?" A resposta: uma task vira skill quando ela é **standalone** — pode ser 100% realizada fora de um workflow, com inputs e outputs claros que não dependem de outras tasks. Se a task depende de outras tasks para ter sentido (inputs/outputs conectados), então não é a task que vira skill — **é o workflow inteiro que deve virar a skill**.
+
+> **Cross-Mind:** PV_PA_013 chega ao mesmo critério pelo ângulo oposto — define task pelo I/O (não pelo executor). Ambos convergem: I/O autossuficiente = unidade atômica válida.
+
+## Configuration
+
+```yaml
+AN_KE_115:
+  name: "Task to Skill: The Right Question"
+  phase: 1
+  zone: "genialidade"
+  trigger: "Decisão sobre quando transformar uma task em skill, ou quando o workflow inteiro deve ser encapsulado como skill."
+
+  weights:
+    correct_question_framing: 1.0
+    standalone_dependency_check: 1.0
+
+  thresholds:
+    skill_vs_squad_false_dichotomy_tolerance: 0
+
+  veto_conditions:
+    - condition: "team_framing_decision_as_skill_vs_squad_instead_of_task_standalone_check == true"
+      action: "VETO - Wrong Question. 'Não é skill vs squad. A pergunta certa é: quando uma task deve virar skill?' Check if task is standalone (clear I/O, no task dependencies)."
+
+  output:
+    type: "decision"
+    values: ["TASK_BECOMES_SKILL", "WORKFLOW_BECOMES_SKILL", "KEEP_AS_TASK"]
+```
+
+## Failure Modes (Anti-Patterns)
+
+```yaml
+failure_modes:
+  - type: "omission"
+    name: "Skill vs Squad Dichotomy (The Coward)"
+    trigger: "Time debatendo 'devo criar uma skill ou um squad para isso?' sem avaliar se a task é standalone."
+    manifestation: "Debate circular sem resposta. Tasks dependentes viram skills órfãs que só funcionam em contexto específico mas são tratadas como reutilizáveis. Quebra de contrato de I/O."
+    detection: "Skill que exige que outra skill seja executada primeiro para ter input válido. Skill com dependência implícita não declarada."
+    recovery: "Reframing: 'esta task tem inputs/outputs claros sem depender de outras tasks?' → SIM: task vira skill. NÃO: o workflow que contém as tasks deve virar skill."
+
+  - type: "misapplication"
+    name: "Everything is Standalone (The Zealot)"
+    trigger: "Dev declara toda task como standalone e converte tudo em skills individuais."
+    manifestation: "Skills que só funcionam juntas em sequência específica mas são registradas como independentes. Usuário invoca skill isolada e recebe erro por falta de contexto."
+    detection: "Skill que, ao ser invocada sozinha, falha ou retorna resultado sem valor por falta de input de outra skill."
+    recovery: "Teste de standalone: 'posso invocar esta skill em qualquer contexto, com inputs diretos do usuário, e obter output útil?' Se NÃO → não é standalone → workflow vira skill."
+```
+
+## Evaluation Criteria
+
+```yaml
+evaluation_criteria:
+  - metric: "Standalone Check"
+    weight: 1.0
+    threshold: "=== EVALUATED before skill creation"
+    description: "A task foi avaliada quanto à independência de inputs/outputs antes de ser promovida a skill?"
+  - metric: "IO Clarity"
+    weight: 1.0
+    threshold: "=== CLEAR inputs and outputs without external task dependency"
+    description: "A skill tem inputs e outputs 100% claros e autossuficientes, sem depender de outras tasks para operar?"
+```
+
+## Decision Tree
+
+```javascript
+IF (Decisão Sobre Transformar Task em Skill) {
+  REFRAME("A pergunta errada é: 'skill vs squad?'");
+  ASK("A pergunta certa é: 'esta task é standalone?'");
+
+  CHECK_STANDALONE({
+    "Test 1": "Inputs vêm DIRETAMENTE do usuário (não de output de outra task)?",
+    "Test 2": "Outputs são úteis SEM precisar passar para outra task?",
+    "Test 3": "Pode ser invocada em qualquer contexto e entregar valor por si só?"
+    // Cf. PV_PA_013: task definida pelo I/O, executor é atributo transversal
+  });
+
+  IF (All_Tests_Pass) {
+    TASK_BECOMES_SKILL("Task standalone → vira SKILL. I/O autossuficiente.");
+  } ELSE {
+    WORKFLOW_BECOMES_SKILL("Task tem dependências → o WORKFLOW inteiro deve virar a SKILL.");
+    // Cf. PV_PA_040: se a task vive dentro de pipeline, auditar todo o organismo
+  }
+}
+
+NEVER("Transformar task dependente em skill isolada. Se a task precisa de output de outra task para funcionar, é o workflow que encapsula ambas que deve virar skill.");
+```

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

@@ -0,0 +1,76 @@
+# AN_KE_116 - LLM Completion Mirage (Status Revert on Gate Fail)
+
+**Type:** Architecture Heuristic
+**Zone:** 🧠 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Phantom Completion
+**Source:** [SOURCE: sessão sinkra-hub 4775d0c3 — domain-decoder runner, primeiro run real]
+**Tags:** [Agnostic, Automation, Pipeline]
+
+## Purpose
+
+LLMs sinalizam "PHASE_COMPLETE" textualmente mesmo quando não cumpriram o contrato real (ex: nenhum arquivo escrito em disco). Se o pipeline marca o status como "complete" baseado na sinalização textual, a próxima iteração do loop vê "complete" e PULA a fase — criando uma fase fantasma que nunca executou. O fix é contraintuitivo: o status DEVE ser revertido para "in_progress" quando o gate de qualidade falha, independente do que o LLM disse.
+
+## Configuration (True L3-State)
+
+```yaml
+AN_KE_116:
+  name: "LLM Completion Mirage (Status Revert on Gate Fail)"
+  zone: "genialidade"
+  trigger: "Pipeline multi-fase com LLM executor onde status é persistido entre iterações."
+
+  sys_tension:
+    tension_with: "AN_KE_088 (Runners as Product Process)"
+    resolution: "Runners produtizados DEVEM ter gate de qualidade. Sem gate, runner vira automação de lixo."
+
+  rule: |
+    SE LLM sinaliza PHASE_COMPLETE MAS gate de qualidade falha (ex: zero arquivos em disco)
+    ENTÃO REVERTER status para "in_progress" antes do retry
+    NUNCA confiar na sinalização textual do LLM como fonte de verdade — disco é a verdade
+
+  failure_modes:
+    omission: "Pipeline marca 'complete', próximo loop pula fase. Resultado: fase fantasma sem output real."
+    misapplication: "Reverter status em TODA falha (incluindo falhas parciais válidas) pode causar loops infinitos. Gate deve ter threshold claro."
+
+  evidence_threshold: "[EMPIRICAL]"
+  evidence:
+    - "[SOURCE: sessão sinkra-hub 4775d0c3] 'Gate fail didnt revert status: when LLM signals PHASE_COMPLETE but E9 gate fails (no files on disk), the next iteration saw complete and skipped'"
+```
+
+## Decision Tree (Strict Format)
+
+```text
+STEP_1: IF (LLM signals PHASE_COMPLETE)
+          THEN verify gate conditions (files exist? validation passed? metrics OK?)
+          AND VETO (status update if gate fails)
+STEP_2: IF (gate FAILS)
+          THEN revert status to "in_progress"
+          AND increment retry counter
+STEP_3: IF (retry > max_retries)
+          THEN HALT with explicit error (not silent skip)
+NEVER:
+  - Trust LLM text output as completion proof
+  - Let status remain "complete" when disk state contradicts
+```
+
+## Confidence Requirements & Reversibility
+
+- **High-Commitment (One-Way Door):** Status persistence in state files — wrong status propagates to all future iterations.
+- **Tactical (Two-Way Door):** Retry count tuning (3 vs 5) — adjustable without architectural change.
+
+## Validation & Cross-Mind Divergence
+
+### Self-Validation Ask
+1. "O gate de qualidade verifica DISCO ou TEXTO? Se texto, a heurística não está aplicada."
+
+### Divergence Analysis (Baseline IA vs Mente Zero)
+- **Base LLM Tendency:** Aceitar "PHASE_COMPLETE" como verdade e prosseguir.
+- **Mind Zero Override:** Disco é a verdade. LLM mente. Gate verifica disco. Status reverte se disco contradiz.
+
+## Behavioral Evidence (Real-World Application)
+
+**Example:** "O Domain Decoder que pulou Phase 2"
+- **Context:** Primeiro run real do decoder pipeline com 6 fases.
+- **Information Available:** LLM sinalizou PHASE_COMPLETE em Phase 2, mas não usou Write tool.
+- **Heuristic Application:** Adicionado revert de status + prompt explícito "use Write tool".
+- **Outcome:** Próximos runs executam todas as fases corretamente — zero fases fantasma.

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

@@ -0,0 +1,65 @@
+# AN_KE_117 - Explicit Write Instruction for LLM Executors
+
+**Type:** Veto Heuristic
+**Zone:** 💎 4% Excelencia
+**Agent:** @oalanicolas
+**Pattern:** Tool Blindness
+**Source:** [SOURCE: sessao sinkra-hub 4775d0c3 — domain-decoder runner]
+**Tags:** [Agnostic, Automation, Pipeline]
+
+## Purpose
+
+LLMs em modo agente possuem tools (Read, Write, Edit, Bash) mas NÃO as usam proativamente a menos que o prompt instrua explicitamente. O caso mais crítico: LLM analisa código, gera output textual, diz "pronto" — mas nunca chamou Write tool. Resultado: zero arquivos em disco. O prompt DEVE conter instrução explícita "use Write tool to save files to disk" com warning de que PHASE_COMPLETE sem arquivos = gate failure + retry.
+
+## Configuration (True L3-State)
+
+```yaml
+AN_KE_117:
+  name: "Explicit Write Instruction for LLM Executors"
+  zone: "excelencia"
+  trigger: "Prompt template para LLM executor que deve produzir arquivos em disco."
+
+  rule: |
+    SE prompt template envia LLM para executar fase de pipeline
+    ENTÃO incluir instrução explícita: "Use the Write tool to save each output file to disk"
+    E incluir warning: "PHASE_COMPLETE without files on disk = gate failure + retry"
+    NUNCA assumir que LLM vai usar Write tool por iniciativa própria
+
+  failure_modes:
+    omission: "LLM gera output textual brilhante, diz PHASE_COMPLETE, mas zero arquivos em disco. Gate falha. Retry desperdiça tokens."
+    misapplication: "Forçar Write para TUDO (incluindo análise exploratória) burocratiza fases que não precisam de output em disco."
+
+  evidence_threshold: "[EMPIRICAL]"
+  evidence:
+    - "[SOURCE: sessão sinkra-hub 4775d0c3] 'LLM not writing files: prompt now explicitly instructs to use the Write tool to save files to disk, with warning that PHASE_COMPLETE without files will trigger gate failure and retry'"
+```
+
+## Decision Tree (Strict Format)
+
+```text
+STEP_1: IF (prompt template expects file outputs)
+          THEN add explicit Write tool instruction
+          AND add gate failure warning
+STEP_2: IF (phase is analysis-only, no file output expected)
+          THEN skip Write instruction (text response is sufficient)
+NEVER:
+  - Assume LLM will proactively use tools without instruction
+  - Rely on LLM "understanding" that files need to be on disk
+```
+
+## Validation & Cross-Mind Divergence
+
+### Self-Validation Ask
+1. "O prompt template menciona EXPLICITAMENTE 'Write tool' ou equivalente? Se não, LLM vai gerar texto e dizer pronto."
+
+### Divergence Analysis (Baseline IA vs Mente Zero)
+- **Base LLM Tendency:** Gerar análise textual completa e sinalizar completion sem persistir.
+- **Mind Zero Override:** "Sem Write, sem completion. Disco é a verdade."
+
+## Behavioral Evidence (Real-World Application)
+
+**Example:** "Phase 2 que gerou análise perfeita mas zero arquivos"
+- **Context:** Domain decoder Phase 2 (characterization). LLM analisou 50+ arquivos, gerou assessment completo.
+- **Information Available:** Output textual excelente no response. Nenhum arquivo em outputs/.
+- **Heuristic Application:** Adicionado "MANDATORY: Use Write tool" no prompt template.
+- **Outcome:** Todas as fases subsequentes produzem arquivos em disco consistentemente.

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

@@ -0,0 +1,72 @@
+# AN_KE_118 - Incremental Context Accumulation in Multi-Phase Pipelines
+
+**Type:** Architecture Heuristic
+**Zone:** 🧠 0,8% Genialidade
+**Agent:** @oalanicolas
+**Pattern:** Snowball Context
+**Source:** [SOURCE: sessão sinkra-hub d571db80 — domain-decoder runner, prior phase injection]
+**Tags:** [Agnostic, Automation, Pipeline, SINKRA]
+
+## Purpose
+
+Pipelines multi-fase onde cada fase é executada por um LLM perdem contexto entre fases. A solução ingênua é passar TODO o source como contexto em cada fase — explodindo tokens e diluindo foco. A solução correta: injetar outputs de fases anteriores como MANDATORY READS antes do source, em ordem cronológica. Cada fase acumula incrementalmente: Phase 0 sem priors, Phase 1 lê Phase 0 outputs, Phase 2 lê Phase 0+1, etc. Isso cria um efeito bola de neve onde cada fase REFINA o entendimento anterior em vez de redescobrir do zero.
+
+## Configuration (True L3-State)
+
+```yaml
+AN_KE_118:
+  name: "Incremental Context Accumulation in Multi-Phase Pipelines"
+  zone: "genialidade"
+  trigger: "Pipeline com 3+ fases executadas por LLM onde cada fase depende de descobertas das anteriores."
+
+  sys_tension:
+    tension_with: "Context window limits vs completude de informação"
+    resolution: "Prior phase outputs são RESUMOS estruturados (YAML/MD), não raw source. Compactos por natureza."
+
+  rule: |
+    SE pipeline multi-fase com LLM executor
+    ENTÃO build_prior_context() scans completed phase dirs e gera MANDATORY READS section
+    E prompt template enforça: "Read ALL prior phase outputs BEFORE reading source codebase"
+    NUNCA enviar apenas source codebase sem prior phase context — cada fase redescobre do zero
+
+  failure_modes:
+    omission: "Cada fase redescobre insights que a fase anterior já encontrou. Redundância massiva, inconsistência entre fases."
+    misapplication: "Injetar prior context de fases MUITO anteriores em pipelines longos (10+ fases) pode diluir foco. Considerar sliding window."
+
+  evidence_threshold: "[EMPIRICAL]"
+  evidence:
+    - "[SOURCE: sessão sinkra-hub d571db80] 'build_prior_context() scans outputs/decoded/{slug}/{phase_dir}/ for all completed phases and generates a MANDATORY READS section listing every file with its repo-relative path and size'"
+    - "[SOURCE: sessão 02ad333a, decoder.sh] 'Evolução: prior context mudou de LISTA de arquivos (LLM precisa fazer Read) para CONTEÚDO INLINE (3KB/file truncado direto no prompt). Elimina turns gastos em Read — LLM usa turns para ler SOURCE em vez de prior outputs.'"
+    - "[SOURCE: sessão opus run] 'Confirmado: prompt cresce 3878→4951→5920 bytes entre fases. Zero fallback para Gemini. Context incremental inline funciona. Anthropic confirma: structured context objects (200-500 tokens) >> full forwarding (5-20K).'"
+```
+
+## Decision Tree (Strict Format)
+
+```text
+STEP_1: IF (multi-phase pipeline, phase N > 0)
+          THEN scan completed phases 0..N-1 for output files
+          AND generate MANDATORY READS section with paths + sizes
+STEP_2: IF (total prior context > 50% of context window)
+          THEN apply sliding window: keep last 3 phases only
+STEP_3: Inject prior context BEFORE source codebase in prompt
+NEVER:
+  - Start a phase without reading prior phase outputs
+  - Pass raw source as the only context (ignoring prior work)
+```
+
+## Validation & Cross-Mind Divergence
+
+### Self-Validation Ask
+1. "A Phase N recebe outputs das Phases 0..N-1? Se não, está redescobindo o que já sabe."
+
+### Divergence Analysis (Baseline IA vs Mente Zero)
+- **Base LLM Tendency:** Tratar cada prompt como independente — sem memória entre fases.
+- **Mind Zero Override:** "Pipeline é INCREMENTAL. Cada fase constrói sobre a anterior. Sem prior context, não é pipeline — é N execuções desconectadas."
+
+## Behavioral Evidence (Real-World Application)
+
+**Example:** "Domain Decoder Phase 3 que contradisse Phase 1"
+- **Context:** Sem prior injection, Phase 3 (extraction) gerou bounded contexts diferentes de Phase 1 (discovery).
+- **Information Available:** Phase 1 já tinha mapeado os contextos. Phase 3 não leu.
+- **Heuristic Application:** build_prior_context() injeta MANDATORY READS.
+- **Outcome:** Phase 3+ consistentes com descobertas anteriores. Zero contradições inter-fase.

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

@@ -0,0 +1,58 @@
+# AN_KE_119 - Auto-Derive Over Mandatory Parameters
+
+**Type:** Decision Heuristic
+**Zone:** 🔥 20% Impacto
+**Agent:** @oalanicolas
+**Pattern:** Zero-Config UX
+**Source:** [SOURCE: sessão sinkra-hub 8b2b58da + 8dfc9a1b — domain-decoder runner]
+**Tags:** [Agnostic, Automation, CLI]
+
+## Purpose
+
+CLIs que pedem parâmetros deriváveis criam fricção desnecessária. Se o source path contém um config.yaml com version, ou um package.json, o CLI pode auto-detectar version e slug sem pedir ao user. Cada parâmetro que pode ser derivado da fonte e é pedido ao user é uma barreira de adoção. A regra: auto-derive tudo que for derivável, aceitar override explícito, nunca pedir o que pode calcular.
+
+## Configuration (True L3-State)
+
+```yaml
+AN_KE_119:
+  name: "Auto-Derive Over Mandatory Parameters"
+  zone: "impacto"
+  trigger: "Desenhando CLI interface para pipeline que opera sobre source com metadata."
+
+  rule: |
+    SE parâmetro pode ser derivado do source (version, slug, name, etc.)
+    ENTÃO auto-derivar com fallback chain (config.yaml → package.json → pyproject.toml → timestamp)
+    E permitir override explícito (--version, --slug) para casos edge
+    NUNCA pedir como parâmetro obrigatório o que pode ser calculado
+
+  failure_modes:
+    omission: "User precisa lembrar versão exata, slug format, etc. Erro de digitação = run perdido."
+    misapplication: "Auto-derive de campo ambíguo (ex: 'name' que existe em 3 configs diferentes) sem prioridade clara = bug silencioso."
+
+  evidence_threshold: "[EMPIRICAL]"
+  evidence:
+    - "[SOURCE: sessão sinkra-hub 8b2b58da] 'Version is auto-detected from source codebase: 1. package.json 2. config.yaml pack.version 3. pyproject.toml 4. VERSION file 5. Fallback: timestamp'"
+    - "[SOURCE: sessão sinkra-hub 8dfc9a1b] 'basename of --source is slugified: squads/squad-creator → squad_creator'"
+```
+
+## Decision Tree (Strict Format)
+
+```text
+STEP_1: IF (parameter can be derived from source metadata)
+          THEN implement derivation chain with ordered fallbacks
+          AND accept explicit override via CLI flag
+STEP_2: IF (derivation is ambiguous — multiple sources conflict)
+          THEN log warning with both values, use first in priority chain
+NEVER:
+  - Make a derivable value a required CLI parameter
+  - Fail silently on derivation — always log what was derived and from where
+```
+
+## Validation & Cross-Mind Divergence
+
+### Self-Validation Ask
+1. "Quantos parâmetros obrigatórios meu CLI tem? Cada um pode ser derivado? Se sim, por que é obrigatório?"
+
+### Divergence Analysis (Baseline IA vs Mente Zero)
+- **Base LLM Tendency:** Criar CLI com todos os parâmetros explícitos para "clareza".
+- **Mind Zero Override:** "Menos parâmetros = mais adoção. Auto-derive > pedir."