auroq-os 1.4.0 → 1.5.0

package/.claude/commands/AuroqOS/agents/ops.md

@@ -188,15 +188,24 @@ O expert so precisa pedir "atualiza o sistema" — Ops faz o resto.
 - `.synapse/` — manifest, constitution, global, context
 - `bin/` — installer
 - `package.json` — dependencias
+- `agents/squad-forge/` — meta squad oficial
+- `agents/mind-forge/` — meta squad oficial
+- `agents/worker-forge/` — meta squad oficial
+- `agents/clone-forge/` — meta squad oficial
+- `agents/etlmaker/` — meta squad oficial
+- `agents/organizer/` — meta squad oficial
 
 **NAO ATUALIZA (L4 — dados do expert):**
 - `business/` — campanhas, processos, cockpit, vault, templates preenchidos
 - `docs/knowledge/` — expert-mind, expert-business, biblioteca-pmi (conteudo do expert)
 - `agents/companion/data/` — contexto-dinamico, log-decisoes, padroes, backlog
 - `agents/companion/knowledge/expert-essencial.md` — perfil do expert
+- `agents/companion/` — companion e personalizado pelo expert (nome, persona)
 - `.claude/commands/companion.md` (ou `{nome}-companion.md`) — personalizado pelo expert
 - `agents/companion/agents/companion.md` — personalizado com nome do expert
-- Qualquer squad/worker/mind que o expert instalou em `agents/`
+- `agents/{squad-customizado-pelo-expert}/` — squads que o expert criou via Squad Forge ficam intactos (qualquer pasta em agents/ que NAO seja meta squad oficial nem companion)
+- `agents/clone-forge/minds/` — clones em andamento ou prontos do expert (state, sources, outputs)
+- `agents/{meta-squad}/minds/` — outputs de qualquer meta squad (mind-forge/minds/, etlmaker/minds/, etc)
 - `.claude/CLAUDE.md` — SE o expert personalizou (verificar antes de sobrescrever)
 
 **Logica de copia:**
@@ -205,6 +214,7 @@ Para cada arquivo da versao nova:
 2. SE e L4 e o arquivo local NAO existe → copiar (novo template)
 3. SE e L4 e o arquivo local EXISTE → NAO tocar (dados do expert)
 4. SE e CLAUDE.md → verificar se expert customizou. SE sim: nao sobrescrever, avisar. SE nao: atualizar
+5. SE e meta squad em agents/ (squad-forge, mind-forge, worker-forge, clone-forge, etlmaker, organizer) → sobrescrever framework MAS preservar subpasta `minds/` se existir (e onde o expert tem outputs)
 
 **Passo 5 — Pos-atualizacao**
 1. `npm install` — atualizar dependencias

package/.gitignore

@@ -23,3 +23,6 @@ Thumbs.db
 # Temp files
 *.tmp
 *-snapshot.md
+
+# Backups locais pré-sync (não vão pro npm/git)
+_backup-pre-sync/

package/agents/squad-forge/README.md

@@ -1,6 +1,6 @@
 # Squad Forge
 
-Extrai processos complexos da sua cabeca e transforma em squads AIOS funcionais. Extracao profunda com 8 lentes iterativas.
+Extrai processos complexos da sua cabeca e transforma em squads AIOS funcionais com profundidade real. Extracao profunda com 8 lentes iterativas + Story-Driven Development + instalacao automatica.
 
 ## Ativacao
 
@@ -8,50 +8,103 @@ Extrai processos complexos da sua cabeca e transforma em squads AIOS funcionais.
 /squadForge
 ```
 
+## Modos
+
+| Modo | Comando | O que faz |
+|------|---------|-----------|
+| Criar | `*start` | Pipeline completo: extracao → playback → arquitetura → montagem → instalacao |
+| Atualizar | `*update {squad}` | Modificacao cirurgica preservando profundidade |
+| Consertar | `*fix {squad}` | Audit + auto-fix + lista de fixes manuais |
+| Refazer | `*rebuild {squad}` | Reverse-extract + reconstrucao com profundidade nova |
+| Auto-test | `*self-test` | Audita o proprio squad-forge |
+
 ## Agentes
 
 | Agente | Funcao |
 |--------|--------|
-| @forge-chief | Orquestrador do pipeline, playback validation |
-| @process-archaeologist | Especialista em extracao profunda de processos |
-| @forge-smith | Construtor AIOS, transforma processo em squad |
+| @forge-chief | Orquestrador do pipeline, playback validation, modo selector |
+| @process-archaeologist | Especialista em extracao profunda de processos (8 lentes) |
+| @forge-smith | Construtor AIOS, PRD/Stories, hard gates de profundidade |
 
-## Pipeline
+## Pipeline (modo Criar)
 
 ```
 Fase 0: Setup → Fase 1: Extracao → Fase 2: Playback
-→ Fase 3: Arquitetura → Fase 4: Montagem → Fase 5: Validacao + Install
+→ Fase 3: Arquitetura + PRD + Stories + Tracker
+→ Fase 4: Montagem com profundidade obrigatoria
+→ Fase 5: Validacao + Instalacao Automatica
 ```
 
 ## Quality Gates
 
-- QG-SF-001: Extraction Completeness (processo extraido com profundidade)
-- QG-SF-002: User Validation (playback aprovado pelo dono do processo)
-- QG-SF-003: Architecture Coherence (squad bem estruturado)
-- QG-SF-004: Nuclear Structure (agents, tasks, workflows validos)
-- QG-SF-005: Squad Operational (smoke tests passam)
+- **QG-SF-001:** Extraction Completeness — >=15 PUs, 6/8 lentes, confianca >=0.7
+- **QG-SF-002:** User Validation — playback aprovado pelo dono
+- **QG-SF-003:** Architecture Coherence — agentes coerentes + PRD + Stories + Tracker
+- **QG-SF-004:** Nuclear Structure + Profundidade — squad-validator PASS + self-audit (agentes >=250 linhas, 3+ Output Examples, 3+ Immune triggers, KB rica)
+- **QG-SF-005:** Squad Operational — smoke tests + aprovacao + instalacao automatica
+
+## Squad Autocontido (NON-NEGOTIABLE)
+
+Squad gerado e SELF-CONTAINED. Funciona zipado e enviado pra qualquer maquina.
+
+- **PROIBIDO:** ref a `docs/knowledge/...`, `squads/etlmaker/kbs/...`, `business/...`, `~/euriler-brain/`, absolute paths `/Users/...` em runtime
+- **PERMITIDO:** refs internas (`squads/{this-squad}/`), framework AIOS (`.aios-core/`), URLs/APIs externas
+- **Build-time:** fontes externas sao LIDAS, ADAPTADAS e ESCRITAS como conteudo proprio em `squads/{name}/data/`
+- **Hard gate:** QG-SF-004 falha se grep encontra ref externa proibida
+
+Razao: squads sao distribuidos pra alunos da Mentoria Arcane. Refs externas quebram fora do ambiente original.
+
+## Profundidade obrigatoria (hard gates)
+
+Cada agente gerado deve ter:
+- >=250 linhas
+- >=3 OUTPUT EXAMPLES concretos do processo
+- >=3 IMMUNE SYSTEM triggers rastreaveis a PUs
+- >=5 Frases-Chave (Voice DNA)
+- >=5 regras NUNCA + >=5 regras SEMPRE
+
+KB minimum por tipo:
+- Operacional: >=800 linhas
+- Analitico/Criativo: >=600 linhas
+- Dev/Tecnico: >=400 linhas
+
+Thresholds em `data/quality-thresholds.yaml`.
+
+## Story-Driven Development (Article III Constitution)
+
+Cada squad gerado vem com:
+- `docs/prd/squad-{slug}.md` — PRD com FRs/NFRs/CONs/SCs rastreaveis aos PUs
+- `docs/stories/squad-forge/{slug}/` — 1 epic story (5 ACs = 5 QGs) + 1 story por fase
+- `business/campanhas/squad-{slug}/tracker.md` — Project Tracker Protocol
+
+## Instalacao automatica (Fase 5)
+
+Apos QG-SF-005 PASS:
+1. Backup automatico do squad anterior em `squads/_archive/`
+2. Cópia `minds/{slug}/04-squad/` → `squads/{name}/`
+3. Skill registrada em `.claude/commands/{slashPrefix}.md`
+4. MEMORY.md atualizado em "Squads Instalados"
+5. Tracker do squad atualizado com LOG
+6. Validacao pos-instalacao + rollback se falhar
+
+Squad fica imediatamente disponivel via `/{slashPrefix}`.
 
 ## Output
 
-Squad completo em `minds/{slug}/04-squad/`:
+Squad completo em `squads/{name}/`:
 
 ```
-04-squad/
-├── agents/      — Agentes do squad
-├── tasks/       — Tasks executaveis
+{name}/
+├── agents/      — Agentes do squad (>=250 linhas cada, com Output Examples + Immune System)
+├── tasks/       — Tasks executaveis (8 campos TASK-FORMAT-SPEC-V1)
 ├── workflows/   — Pipeline do squad
-├── knowledge/   — KB extraida do processo
+├── data/        — KB rica (Regras Cardinais, Decision Trees, Tabelas de Referencia)
+├── checklists/  — Validacoes
 ├── squad.yaml   — Configuracao
 └── README.md    — Documentacao
 ```
 
-## Instalacao
-
-Automatica no final do pipeline (Fase 5):
-1. Output copiado para `agents/{slug}/`
-2. Skill registrada em `.claude/commands/{slashPrefix}.md`
-3. Ativacao imediata via `/{slashPrefix}`
-
 ## Dependencias
 
-Nenhuma obrigatoria.
+- Opcional: ETLmaker (para incorporar conhecimento existente em squads operacionais)
+- Opcional: `squad-validator.js` em `.aios-core/development/scripts/squad/` (fallback pra checklist nuclear)

package/agents/squad-forge/agents/forge-chief.md

@@ -68,26 +68,56 @@ FASE 5: Validacao   → Chief + @forge-smith
 
 **State Management:**
 
-Pipeline e pausavel/resumivel. O Chief mantem estado em `.state.json`:
+Pipeline e pausavel/resumivel. Estado vive em `minds/{slug}/.state.json`. Cada agente atualiza nas transicoes (ver protocolos em `process-archaeologist.md` e `forge-smith.md`).
+
+**Schema do `.state.json`:**
 
 ```yaml
 state:
   process_slug: "{slug}"
-  current_phase: 0-5
+  process_name: "{nome}"
+  scope: "{descricao}"
+  target_audience: "internal"  # "internal" (so Euriler) | "distributed" (alunos/clientes — REGRA AUTOCONTIDO ativa)
+  current_phase: 0  # 0..5 (6 fases totais)
   phase_status:
-    phase_0: "pending|in_progress|completed"
-    phase_1: "pending|in_progress|completed"
-    phase_2: "pending|in_progress|completed"
-    phase_3: "pending|in_progress|completed"
-    phase_4: "pending|in_progress|completed"
-    phase_5: "pending|in_progress|completed"
+    phase_0: "completed"        # setup
+    phase_1: "in_progress"      # extracao
+    phase_2: "pending"          # playback
+    phase_3: "pending"          # arquitetura
+    phase_4: "pending"          # montagem
+    phase_5: "pending"          # validacao
   extraction_rounds: 0
   total_pus: 0
-  quality_gates_passed: []
+  quality_gates_passed: []      # ["QG-SF-001", ...]
+  rounds_log: []                # 1 entrada por round (archaeologist grava)
+  blueprint_path: ""            # smith preenche apos QG-SF-003
+  squad_artifacts:              # smith preenche apos QG-SF-004
+    agents: 0
+    tasks: 0
+    workflows: 0
+    kb_files: 0
+  total_lines_generated: 0
+  installed_to: ""              # path em squads/ apos Fase 5 (instalacao auto)
+  started_at: "{ISO}"
   paused_at: ""
   resumed_at: ""
+  completed_at: ""
 ```
 
+**Protocolo `*resume`:**
+
+1. Ler `.state.json` da pasta `minds/{slug}/`
+2. Identificar primeira fase com status != "completed"
+3. Anunciar: "Retomando pipeline em Fase {N} — {nome da fase}. Ultimo state em {paused_at}"
+4. Roteiar pra agente correto da fase:
+   - phase_1: handoff @process-archaeologist
+   - phase_2: chief executa playback-validate
+   - phase_3, 4: handoff @forge-smith
+   - phase_5: chief + smith
+5. Atualizar `resumed_at` no state
+
+**Se state corrompido ou ausente:** avisar usuario e oferecer recriar a partir do que existe em `01-extraction/`, `02-process-map/`, etc.
+
 ### 2. PLAYBACK VALIDATION (Fase 2)
 
 **Nivel de Autoridade:** Total
@@ -170,7 +200,11 @@ Gaps geram perguntas cirurgicas pro proximo round.
 
 | Comando | Descricao |
 |---------|-----------|
-| `*start` | Iniciar pipeline (setup + primeiro round de extracao) |
+| `*start` | Criar squad novo — pipeline completo de extracao |
+| `*update {squad-name}` | Atualizar squad existente (modificacao cirurgica) |
+| `*fix {squad-name}` | Diagnosticar e consertar squad existente |
+| `*rebuild {squad-name}` | Refazer squad do zero mantendo o que funciona |
+| `*self-test` | Rodar audit no proprio squad-forge (`*fix` em si mesmo) |
 | `*status` | Mostrar estado atual do pipeline |
 | `*resume` | Retomar pipeline pausado |
 | `*playback` | Executar playback validation manualmente |
@@ -178,12 +212,17 @@ Gaps geram perguntas cirurgicas pro proximo round.
 | `*help` | Listar comandos |
 | `*exit` | Sair do modo agente |
 
+> Notas:
+> - `*update`, `*fix`, `*rebuild`: implementados em tasks dedicadas (ver `tasks/update-squad.md`, `fix-squad.md`, `rebuild-squad.md`)
+> - `*self-test`: implementado em `tasks/self-test.md` (Fase 6 do plano de correcao)
+
 ---
 
 ## STRICT RULES
 
 ### O Chief NUNCA:
 
+- **Aprova squad com referencia a paths externos do repo Euriler.** Squads sao distribuidos pra alunos da Mentoria Arcane. Se squad referencia `docs/knowledge/...`, `squads/etlmaker/kbs/...`, `business/...` ou similar em runtime, quebra fora do ambiente original. Bloqueia QG-SF-004 sem excecao. (Ver REGRA AUTOCONTIDO no forge-smith.md)
 - Inventa passos ou decisoes que o usuario nao mencionou
 - Passa pro Fase 3 sem confirmacao explicita do usuario no Playback
 - Ignora quality gates — se nao passa, nao avanca

package/agents/squad-forge/agents/forge-smith.md

@@ -30,9 +30,9 @@ O Smith usa a mesma infraestrutura de validacao do Craft para garantir que squad
 
 | Script | Path | Funcao |
 |--------|------|--------|
-| **squad-validator.js** | `.auroq-core/development/scripts/squad/squad-validator.js` | Validacao estrutural contra JSON Schema + AIOS standards |
-| **squad-analyzer.js** | `.auroq-core/development/scripts/squad/squad-analyzer.js` | Metricas de cobertura e sugestoes de melhoria |
-| **squad-schema.json** | `.auroq-core/development/schemas/squad-schema.json` | JSON Schema do manifest |
+| **squad-validator.js** | `.aios-core/development/scripts/squad/squad-validator.js` | Validacao estrutural contra JSON Schema + AIOS standards |
+| **squad-analyzer.js** | `.aios-core/development/scripts/squad/squad-analyzer.js` | Metricas de cobertura e sugestoes de melhoria |
+| **squad-schema.json** | `.aios-core/schemas/squad-schema.json` | JSON Schema do manifest |
 
 **Regra:** squad-validator.js e OBRIGATORIO na Fase 4 (Montagem). NAO e opcional. Se o validator nao existir no path, usar checklist nuclear como fallback.
 
@@ -275,7 +275,7 @@ Validar o squad gerado contra padroes AIOS usando a mesma infraestrutura do Squa
 **OBRIGATORIO — squad-validator.js:**
 
 ```bash
-node .auroq-core/development/scripts/squad/squad-validator.js minds/{slug}/04-squad/
+node .aios-core/development/scripts/squad/squad-validator.js minds/{slug}/04-squad/
 ```
 
 O validator checa automaticamente:
@@ -302,7 +302,7 @@ O validator checa automaticamente:
 **OPCIONAL — squad-analyzer.js (metricas de cobertura):**
 
 ```bash
-node .auroq-core/development/scripts/squad/squad-analyzer.js minds/{slug}/04-squad/
+node .aios-core/development/scripts/squad/squad-analyzer.js minds/{slug}/04-squad/
 ```
 
 Gera relatorio de cobertura: componentes, metricas, sugestoes de melhoria.
@@ -358,6 +358,7 @@ Para cada PU-STEP, classificar o tipo de executor:
 
 ### O Smith NUNCA:
 
+- **Gera squad com referencia a paths externos** — KB do squad vive DENTRO de `squads/{name}/data/`, nunca aponta pra `docs/knowledge/...`, `squads/etlmaker/kbs/...`, `business/...`, `~/euriler-brain/`, ou qualquer path fora de `squads/{name}/`. Squad precisa rodar como pacote zipado entregue pra aluno. (Ver REGRA AUTOCONTIDO abaixo)
 - Gera squad sem process map validado pelo usuario (Fase 2 obrigatoria)
 - Cria task sem os 8 campos obrigatorios
 - Ignora a classificacao de executor — cada passo tem seu tipo
@@ -367,6 +368,57 @@ Para cada PU-STEP, classificar o tipo de executor:
 - Automatiza passos que o usuario disse que PRECISA fazer pessoalmente
 - Inventa quality gates que o usuario nao mencionou como criterio
 
+---
+
+## REGRA AUTOCONTIDO (NON-NEGOTIABLE)
+
+**Squad autocontido > squad limpo-mas-dependente.** Se zipar `squads/{name}/` e mandar pro aluno, ele tem que conseguir usar tudo. Se quebrar, e burrice.
+
+### Por que essa regra existe
+
+Squads ficavam fracos no passado: usuario despejava ETL/KBs como fonte bruta, smith fazia squad simples com referencia externa. Aluno recebia squad que dependia de paths que ele nao tinha. Confronto explicito do Euriler em 05/05/2026: "Isso é a maior burrice que ja vi."
+
+### Fontes (build-time inputs) vs Squad (runtime artefato)
+
+- **Fontes externas** (ETL, KBs do repo Euriler, transcricoes, docs): so existem em **build-time**. Smith le, **processa, sintetiza, ADAPTA ao contexto dos agentes do squad**, e ESCREVE arquivos novos em `squads/{name}/data/`.
+- **Squad runtime**: so referencia caminhos dentro de `squads/{name}/`.
+
+### O que e PROIBIDO em arquivo gerado de squad
+
+| Proibido | Razao |
+|----------|-------|
+| `docs/knowledge/euriler-business/...` em runtime ref | Path do repo Euriler, nao existe no aluno |
+| `squads/etlmaker/kbs/...` em runtime ref | Outro squad — quebra portabilidade |
+| `business/...`, `business/campanhas/...` em runtime ref | Privado do Euriler |
+| `~/aios/...`, `/Users/euriler/...` (absolute) | Absolute paths do dono |
+| `~/euriler-brain/...` | Vault privado |
+| "Ver KB completa em {path externo}" | Equivale a entregar bruto |
+| Imports/links/symlinks pra fora do squad | Quebra portabilidade |
+
+### O que e PERMITIDO em runtime
+
+- Refs internas: `squads/{this-squad}/data/*.md`, `squads/{this-squad}/agents/*.md`, etc
+- Refs ao framework AIOS (`.aios-core/`) — infra compartilhada, todo aluno tem
+- Refs a tools/CLIs padrao do sistema (git, node, npm, etc)
+- Refs a APIs/URLs externas com autenticacao do proprio aluno
+
+### Build-time: incorporar, nao linkar
+
+Ao processar fonte externa (Step 6b do `assemble-squad.md`):
+
+1. **Ler** arquivo completo da fonte
+2. **Extrair** conteudo relevante pro escopo do squad
+3. **Adaptar** ao contexto dos agentes do squad (nao copiar literal — ressintese)
+4. **Escrever** em `squads/{name}/data/{nome-tematico}.md` como conteudo novo
+5. **Citar proveniencia opcional** em comentario de cabecalho (`<!-- Adaptado de X em build-time -->`), mas NAO como path runtime
+6. **NUNCA** deixar refs `[ver X em path-externo]` no output
+
+### Heuristica final
+
+Antes de fechar o squad, perguntar: "Se o Euriler zipasse `squads/{name}/`, mandasse num email pra um aluno em outra maquina, e o aluno descompactasse — o squad funciona 100%?"
+
+Se a resposta nao e "sim, integralmente": squad **nao esta pronto**. Voltar e internalizar o que falta.
+
 ### O Smith SEMPRE:
 
 - Usa TASK-FORMAT-SPECIFICATION-V1 (8 campos) em cada task
@@ -403,6 +455,43 @@ Para cada PU-STEP, classificar o tipo de executor:
 
 - **@forge-chief:** Squad completo pronto pra validacao final
 
+### State Updates (OBRIGATORIO em cada transicao de fase)
+
+O Smith atualiza `.state.json` ao entrar e ao sair de cada fase:
+
+**Ao entrar Fase 3 (Arquitetura):**
+```yaml
+current_phase: 3
+phase_status.phase_3: "in_progress"
+phase_3_started_at: "{ISO}"
+```
+
+**Ao concluir Fase 3 (apos QG-SF-003 PASS):**
+```yaml
+phase_status.phase_3: "completed"
+quality_gates_passed: [..., "QG-SF-003"]
+blueprint_path: "minds/{slug}/03-blueprint/squad-blueprint.yaml"
+phase_3_completed_at: "{ISO}"
+```
+
+**Ao entrar Fase 4 (Montagem):**
+```yaml
+current_phase: 4
+phase_status.phase_4: "in_progress"
+phase_4_started_at: "{ISO}"
+```
+
+**Ao concluir Fase 4 (apos QG-SF-004 PASS):**
+```yaml
+phase_status.phase_4: "completed"
+quality_gates_passed: [..., "QG-SF-004"]
+squad_artifacts: {agents: N, tasks: N, workflows: N, kb_files: N}
+total_lines_generated: N
+phase_4_completed_at: "{ISO}"
+```
+
+Sem essas atualizacoes, `*resume` do chief nao funciona — pipeline retoma do lugar errado.
+
 ### Arquivos que Gera
 
 ```

package/agents/squad-forge/agents/process-archaeologist.md

@@ -232,6 +232,27 @@ Vamos la:
 
 ### Fim de Round
 
+**1. Atualizar `.state.json` (OBRIGATORIO antes de qualquer mensagem ao usuario):**
+
+```yaml
+state_update:
+  current_phase: 1
+  phase_status.phase_1: "in_progress"  # "completed" so apos QG-SF-001 PASS
+  extraction_rounds: {N}  # incrementar
+  total_pus: {total}
+  rounds_log:
+    - round: {N}
+      timestamp: "{ISO}"
+      pus_added: {N}
+      lens_covered: [{lentes deste round}]
+      avg_confidence: 0.XX
+      gaps_detected: [...]
+```
+
+Implementacao: ler `.state.json`, atualizar campos, gravar de volta. Se nao gravar, `*resume` do chief nao funciona.
+
+**2. Mensagem ao usuario:**
+
 ```
 === FIM DO ROUND {N} ===
 
@@ -252,6 +273,16 @@ Gaps detectados:
 {Se completude >= 0.95: "Extracao completa. Proximo passo: Playback Validation."}
 ```
 
+### Apos QG-SF-001 PASS
+
+Atualizar `.state.json`:
+
+```yaml
+phase_status.phase_1: "completed"
+quality_gates_passed: [..., "QG-SF-001"]
+phase_1_completed_at: "{ISO}"
+```
+
 ---
 
 ## TECNICAS ESPECIAIS DE EXTRACAO

package/agents/squad-forge/checklists/nuclear-structure-validation.md

@@ -2,7 +2,7 @@
 
 Validacao da Fase 4 — Montagem do Squad AIOS.
 
-**Metodo primario:** Rodar `node .auroq-core/development/scripts/squad/squad-validator.js {squad_path}`
+**Metodo primario:** Rodar `node .aios-core/development/scripts/squad/squad-validator.js {squad_path}`
 **Este checklist manual:** Usado como FALLBACK se o script nao estiver disponivel.
 
 ## Manifest (squad.yaml)

package/agents/squad-forge/data/forge-kb.md

@@ -116,17 +116,28 @@ Cada PU alimenta DOIS destinos no squad. O erro historico era mandar tudo so pra
 
 **Regra:** STEP operacional = step que contem COMO fazer algo (protocolo, tecnica, estrategia). Vai pra task E pra KB. STEP estrutural = step mecanico (abrir tela, clicar botao). So vai pra task.
 
-## Integracao com ETL Existente
+## Integracao com ETL Existente (build-time only — REGRA AUTOCONTIDO)
 
-Quando o dominio ja tem output do ETLmaker (volumes em `docs/knowledge/expert-business/` ou `agents/etlmaker/kbs/`), o Squad Forge DEVE incorporar esse conhecimento na KB do squad.
+> **REGRA AUTOCONTIDO ativa.** ETL e fonte externa em build-time. Squad gerado runtime NAO referencia caminhos `docs/knowledge/...` ou `squads/etlmaker/kbs/...`. Conteudo e LIDO em build-time, ADAPTADO ao contexto dos agentes do squad, e ESCRITO como conteudo proprio em `squads/{name}/data/`.
 
-**Fluxo:**
-1. Na Fase 3 (architect-squad), checar se ETL existe pro dominio
-2. Mapear quais volumes/secoes sao relevantes pro escopo do squad
-3. Na Fase 4 (assemble-squad, Step 6b), ler os volumes e extrair conteudo operacional
-4. A KB do squad e subconjunto RICO do ETL — nao resumo raso
+Quando o dominio ja tem output do ETLmaker (volumes em paths externos do repo Euriler), o Squad Forge DEVE **internalizar** esse conhecimento na KB do squad — NAO referenciar.
 
-**Anti-padrao detectado:** ETL produz 3.000+ linhas de conhecimento rico. Squad building comprime pra 150 linhas de skeleton. Resultado: squad nao sabe operar. A KB do squad deve preservar profundidade, exemplos, tabelas e decision trees do ETL.
+**Fluxo (build-time):**
+1. Na Fase 3 (architect-squad Step 5a), checar se ETL existe pro dominio (`ls docs/knowledge/...`, `ls squads/etlmaker/kbs/...` — comandos rodam na maquina do Euriler em build-time)
+2. Mapear quais volumes/secoes sao relevantes pro escopo do squad em `kb_plan.internalize_from`
+3. Na Fase 4 (assemble-squad Step 6b), LER os volumes em build-time e EXTRAIR conteudo operacional
+4. ADAPTAR ao contexto dos agentes do squad — nao copiar literal, ressintetizar
+5. ESCREVER em `squads/{name}/data/{nome-tematico}.md` como conteudo proprio
+6. Citar proveniencia opcional em comentario HTML (build-time only): `<!-- Adaptado de X em build-time -->`
+7. **NUNCA** deixar refs runtime apontando pra fonte externa
+
+**Anti-padrao detectado (Andromeda, Audience):**
+- ETL produz 3.000+ linhas de conhecimento rico
+- Squad building cria skeleton de 150 linhas que **referencia** o ETL externo
+- Aluno recebe squad — nao tem o ETL — squad nao sabe operar
+- Confronto Euriler 06/05/2026: "É a maior burrice que ja vi."
+
+A KB do squad deve PRESERVAR profundidade, exemplos, tabelas e decision trees do ETL — internalizando, nao linkando.
 
 ## Classificacao de Squads por Tipo de KB
 
@@ -172,8 +183,8 @@ O Squad Forge usa a mesma infraestrutura de validacao automatizada do Squad Crea
 
 | Script | Path | Quando Usar | Obrigatorio |
 |--------|------|-------------|-------------|
-| **squad-validator.js** | `.auroq-core/development/scripts/squad/squad-validator.js` | Fase 4 (Step 7) + Fase 5 (Step 1) | SIM |
-| **squad-analyzer.js** | `.auroq-core/development/scripts/squad/squad-analyzer.js` | Fase 4 (Step 8) | Recomendado |
+| **squad-validator.js** | `.aios-core/development/scripts/squad/squad-validator.js` | Fase 4 (Step 7) + Fase 5 (Step 1) | SIM |
+| **squad-analyzer.js** | `.aios-core/development/scripts/squad/squad-analyzer.js` | Fase 4 (Step 8) | Recomendado |
 
 ### squad-validator.js — O que valida
 
@@ -188,10 +199,10 @@ O Squad Forge usa a mesma infraestrutura de validacao automatizada do Squad Crea
 
 ```bash
 # Validar squad gerado na Fase 4
-node .auroq-core/development/scripts/squad/squad-validator.js minds/{slug}/04-squad/
+node .aios-core/development/scripts/squad/squad-validator.js minds/{slug}/04-squad/
 
 # Analisar cobertura (opcional)
-node .auroq-core/development/scripts/squad/squad-analyzer.js minds/{slug}/04-squad/
+node .aios-core/development/scripts/squad/squad-analyzer.js minds/{slug}/04-squad/
 ```
 
 ### Self-Healing Loop