auroq-os 1.4.1 → 1.6.0

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

@@ -35,11 +35,12 @@ persona:
 
       1. Salvar progresso — commit inteligente com mensagem de negocio
       2. Enviar pro remote — push com checagem pre-push
-      3. Instalar agente — squad, mind ou worker a partir de zip
-      4. Instalar pack — multiplos agentes de uma vez (pack da mentoria)
-      5. Atualizar sistema — baixar e aplicar nova versao do Auroq OS
-      6. Checar saude — diagnostico completo do ambiente
-      7. Setup completo — bootstrap do zero (ambiente, MCPs, GitHub, Supabase)
+      3. Instalar agente — squad, mind ou worker NOVO a partir de zip
+      4. Atualizar squad — substituir squad existente por versao nova (preserva teus dados)
+      5. Instalar pack — multiplos agentes de uma vez (pack da mentoria)
+      6. Atualizar sistema — baixar e aplicar nova versao do Auroq OS
+      7. Checar saude — diagnostico completo do ambiente
+      8. Setup completo — bootstrap do zero (ambiente, MCPs, GitHub, Supabase)
 
       O que precisa?
 
@@ -59,7 +60,9 @@ commands:
   - name: yolo
     description: "Trocar modo de permissao do Claude Code (auto/acceptEdits/default)"
   - name: install
-    description: "Instalar squad/worker/mind a partir de zip ou pasta"
+    description: "Instalar squad/worker/mind NOVO a partir de zip ou pasta (se ja existe, reroteira pra *update-squad)"
+  - name: update-squad
+    description: "Atualizar squad existente com versao nova (preserva minds/, .state.json, e backup do squad antigo)"
   - name: install-pack
     description: "Instalar pack com multiplos squads/agents de uma vez"
   - name: cleanup
@@ -928,10 +931,12 @@ Trocar modo de permissao do Claude Code.
 4. Sempre informar: "Reinicia o Claude Code pra aplicar o novo modo."
 
 ### *install
-Instalar squad, worker, mind ou agente a partir de arquivo zip ou pasta.
+Instalar squad, worker, mind ou agente NOVO a partir de arquivo zip ou pasta.
 
 O expert arrasta o zip pro chat ou informa o path. Ops faz o resto.
 
+> **Importante:** se o squad/agente JA existe instalado, este comando NAO atualiza — reroteia pro `*update-squad` (que preserva dados do expert). `*install` e exclusivo pra instalacao limpa de algo novo.
+
 **Passo 1 — Receber e identificar**
 1. Expert arrasta zip pro chat OU informa path do arquivo/pasta
 2. SE zip: extrair pra pasta temporaria
@@ -940,17 +945,61 @@ O expert arrasta o zip pro chat ou informa o path. Ops faz o resto.
    - Tem `agents/{nome}.md` + `tasks/`? → Worker ou Mind
    - Tem `agents/` com multiplos .md + `workflows/`? → Squad multi-agente
 4. Detectar nome (slug) do squad/agent
-5. Mostrar: "Detectei: {tipo} chamado {nome}. {N} arquivos. Instalo?"
+5. Detectar versao (do `squad.yaml`/`config.yaml` campo `version:`)
+6. Mostrar: "Detectei: {tipo} chamado {nome} v{versao}. {N} arquivos. Instalo?"
+
+**Passo 2 — Detectar conflito com squad existente (NOVO — Smart Detection)**
+
+Antes de tentar instalar, checar se ja existe:
+
+```bash
+# Squad ja instalado?
+ls agents/{slug}/squad.yaml 2>/dev/null || ls agents/{slug}/config.yaml 2>/dev/null
+```
+
+**SE squad ja existe (conflito):**
+
+Ler versao atual do squad instalado e comparar com a versao do zip:
+
+```
+=== CONFLITO DETECTADO ===
+
+Voce ja tem {nome} instalado:
+  Versao atual: v{old_version}
+  Versao do zip: v{new_version}
+
+Tres opcoes:
 
-**Passo 2 — Verificar integridade**
+1. **Atualizar** (recomendado) — usa `*update-squad`
+   - Substitui arquivos framework pela versao nova
+   - PRESERVA teus dados: minds/, .state.json, outputs do expert
+   - Cria backup do squad antigo em agents/_archive/
+   - Se voce modificou arquivos do framework, faz backup das tuas
+     modificacoes em _backup-tuas-mods/ antes de sobrescrever
+
+2. **Reinstalar do zero** — apaga TUDO e instala do zip
+   - Apaga agents/{slug}/ inteiro (incluindo minds/, .state.json)
+   - Instala como se fosse novo
+   - Use SO se quiser comecar do zero (raro)
+
+3. **Cancelar**
+
+Qual? (1 / 2 / 3)
+```
+
+- **Resposta 1:** "Beleza, vou rerotear pra `*update-squad`." → executar `*update-squad` com mesmo zip
+- **Resposta 2:** continuar com `*install` original (Passo 3 em diante), mas confirmar AGAIN: "Tem certeza que quer apagar minds/ e tudo mais? (sim/nao)"
+- **Resposta 3:** abortar, limpar temp
+
+**SE squad NAO existe (sem conflito):** continuar normalmente com Passo 3.
+
+**Passo 3 — Verificar integridade**
 1. Arquivo principal do agente existe? (agents/{nome}.md)
 2. Task start.md existe?
 3. SE squad: workflow existe? Quality gates existem?
 4. Nao tem arquivos suspeitos? (executaveis, scripts desconhecidos)
-5. Nao conflita com agente existente? (mesmo nome ja instalado)
-   → SE conflita: "Ja existe {nome} instalado. Quer sobrescrever?"
 
-**Passo 3 — Instalar**
+**Passo 4 — Instalar**
 1. Copiar pra `agents/{slug}/`
 2. Criar slash command em `.claude/commands/{slug}.md`:
    ```markdown
@@ -965,7 +1014,7 @@ O expert arrasta o zip pro chat ou informa o path. Ops faz o resto.
 3. SE tem skill.md: registrar skill tambem
 4. SE tem dependencias (package.json dentro do squad): `npm install`
 
-**Passo 4 — Testar**
+**Passo 5 — Testar**
 1. Verificar que slash command aparece: "/{slug} esta disponivel"
 2. Verificar que agente carrega (ler persona, confirmar greeting)
 3. SE squad com workflow: verificar que fases referenciam tasks existentes
@@ -975,7 +1024,7 @@ O expert arrasta o zip pro chat ou informa o path. Ops faz o resto.
 === INSTALACAO COMPLETA ===
 
 Tipo: {Worker/Mind/Squad}
-Nome: {nome}
+Nome: {nome} v{versao}
 Ativacao: /{slug}
 Arquivos: {N} instalados em agents/{slug}/
 Command: .claude/commands/{slug}.md criado
@@ -986,16 +1035,244 @@ Command: .claude/commands/{slug}.md criado
 Pronto pra usar. Ative com /{slug}
 ```
 
-**Passo 5 — Limpar**
+**Passo 6 — Limpar**
 1. Remover arquivos temporarios (zip extraido)
 2. SE expert quer: commitar instalacao
    → `setup: instalou {tipo} {nome}`
 
 **Protecoes:**
 - NUNCA instalar sem mostrar o que vai ser instalado primeiro
-- NUNCA sobrescrever agente existente sem confirmar
+- NUNCA sobrescrever agente existente sem oferecer roteamento pro `*update-squad`
 - NUNCA executar scripts do zip automaticamente (verificar antes)
 - SE arquivo parecer suspeito: ALERTAR e pedir confirmacao
+- SE squad ja existe: ALWAYS oferecer `*update-squad` antes de sobrescrever (Passo 2)
+
+---
+
+### *update-squad
+Atualizar squad existente com versao nova a partir de zip ou pasta. **Preserva dados do expert** (minds/, .state.json) e cria backup do squad antigo.
+
+**Quando usar:** voce ja tem um squad instalado e baixou da plataforma a versao nova (zip nomeado tipo `slide-forge-v2.0.0.zip`). Use `*update-squad` pra atualizar sem perder seu trabalho.
+
+**Diferenca pra `*install`:**
+
+| Operacao | `*install` | `*update-squad` |
+|----------|-----------|-----------------|
+| Squad ja existe? | Reroteia pra `*update-squad` (ou apaga tudo se confirmar) | Espera que ja exista |
+| Squad nao existe? | Instala normal | Reroteia pra `*install` |
+| `agents/{slug}/minds/` (outputs do expert) | Apaga (instalacao limpa) | **Preserva sempre** |
+| `agents/{slug}/.state.json` (estado) | Apaga | **Preserva sempre** |
+| Arquivos framework | Cria do zip | Substitui pelos do zip |
+| Modificacoes locais do expert no framework | N/A | **Backup em `_backup-tuas-mods/`** + sobrescreve |
+| Backup do squad antigo | N/A | **Sempre** em `agents/_archive/{slug}-v{old}-{timestamp}/` |
+
+**Passo 1 — Receber zip e identificar**
+
+1. Expert arrasta zip pro chat OU informa path do arquivo/pasta
+2. SE zip: extrair pra pasta temporaria (`/tmp/squad-update-{slug}-{timestamp}/`)
+3. Identificar tipo (squad/worker/mind) — mesma logica do `*install`
+4. Detectar nome (slug) e versao (campo `version:` do `squad.yaml`/`config.yaml`)
+5. Confirmar: "Detectei: {tipo} {nome} v{new_version} no zip. {N} arquivos."
+
+**Passo 2 — Verificar squad atual**
+
+1. Squad existe em `agents/{slug}/`?
+   - **NAO existe:** "Voce ainda nao tem `{slug}` instalado. Vou pra `*install` instalar como novo. OK?" → reroteia
+   - **EXISTE:** continuar
+2. Ler `version:` do squad atual (`agents/{slug}/squad.yaml` ou `config.yaml`)
+3. Comparar:
+
+```
+=== UPDATE DETECTADO ===
+
+Squad: {slug}
+Versao instalada: v{old_version}
+Versao do zip:    v{new_version}
+
+{Se old < new:} Update normal: v{old} -> v{new}
+{Se old == new:} Mesma versao. Reinstalacao limpa do framework (preserva teus dados).
+{Se old > new:} ATENCAO: voce tem versao mais nova ({old}) que o zip ({new}). Downgrade?
+
+Continuar?
+```
+
+**Passo 3 — Detectar modificacoes locais do expert (NOVO)**
+
+A principio o expert NAO deve modificar arquivos do framework. Mas se modificou, precisa backupar antes de sobrescrever.
+
+Comparar conteudo de cada arquivo do squad atual com o do zip:
+
+```bash
+# Para cada arquivo do framework no squad atual (excluindo runtime preservado)
+for file in agents/{slug}/agents/* agents/{slug}/tasks/* agents/{slug}/data/* agents/{slug}/workflows/* agents/{slug}/checklists/* agents/{slug}/templates/* agents/{slug}/squad.yaml agents/{slug}/config.yaml agents/{slug}/README.md; do
+  # Comparar com correspondente no zip
+  zip_file="/tmp/squad-update-{slug}-{timestamp}/{equivalente}"
+  if [ -f "$file" ] && [ -f "$zip_file" ]; then
+    if ! diff -q "$file" "$zip_file" >/dev/null; then
+      # Arquivo modificado localmente — pode ser:
+      # a) Nova versao traz arquivo diferente (esperado)
+      # b) Expert modificou localmente (NAO esperado)
+
+      # Heuristica: se versao do squad mudou, assume que e (a)
+      # Senao, e (b) — modificacao local
+      echo "POSSIVEL MOD LOCAL: $file"
+    fi
+  fi
+done
+```
+
+**Heuristica refinada (precisa de signal):**
+Se o squad guardar um manifesto com hashes dos arquivos originais (`.manifest.json` por exemplo), comparar com isso. Senao, qualquer arquivo modificado E que tambem mudou na versao nova fica ambiguo.
+
+**Comportamento conservador (sem manifesto):** mostrar TODOS os arquivos cujo conteudo difere entre squad atual e zip, classificar:
+
+```
+=== ANALISE DE MODIFICACOES ===
+
+Comparei o squad atual com o zip. Os arquivos abaixo divergem:
+
+Arquivos do framework (esperado mudarem com update v{old} -> v{new}):
+- agents/{slug}/agents/chief.md
+- agents/{slug}/tasks/start.md
+- agents/{slug}/data/cardinal-rules.md
+- ... ({N} arquivos)
+
+Arquivos suspeitos (parecem modificacao local — mtime > {data do install antigo}):
+- agents/{slug}/agents/foo.md (modificado em DD/MM HH:MM)
+- agents/{slug}/data/custom-bar.md (NAO existe no zip — adicionado pelo expert?)
+
+A principio voce nao deveria ter modificado arquivos do framework.
+Mas se modificou, vou criar backup das tuas modificacoes em:
+  _backup-tuas-mods/{slug}-v{old}-{timestamp}/
+
+Confirma o backup das modificacoes locais antes de eu sobrescrever?
+(sim / nao / mostrar diff de cada arquivo)
+```
+
+Se expert confirmar: criar `_backup-tuas-mods/{slug}-v{old}-{timestamp}/` copiando arquivos suspeitos.
+Se expert pedir diff: mostrar `diff` arquivo por arquivo, expert decide caso a caso.
+Se expert disser que nao modificou nada (e mtimes dao falso positivo): proceder sem backup-tuas-mods.
+
+**Passo 4 — Backup completo do squad atual (sempre)**
+
+```bash
+TIMESTAMP=$(date +%Y%m%d-%H%M%S)
+mkdir -p agents/_archive
+cp -r agents/{slug} agents/_archive/{slug}-v{old_version}-$TIMESTAMP
+echo "Backup do squad antigo em: agents/_archive/{slug}-v{old_version}-$TIMESTAMP/"
+```
+
+**Retencao:** 30 dias. Apos isso, expert pode deletar manualmente.
+
+**Passo 5 — Identificar runtime a preservar (whitelist)**
+
+Antes de sobrescrever, listar tudo que deve ser preservado do squad atual:
+
+```bash
+PRESERVE=(
+  "agents/{slug}/minds/"           # outputs do expert (clones, mind-forge runs, etc)
+  "agents/{slug}/.state.json"      # estado de pipeline em andamento
+  "agents/{slug}/*-state.json"     # outros state files
+  "agents/{slug}/.local/"          # configs locais (se padrao se estabelecer)
+)
+
+# Criar staging area pro runtime
+mkdir -p /tmp/squad-update-staging-{slug}/
+for path in "${PRESERVE[@]}"; do
+  if [ -e "$path" ]; then
+    cp -r "$path" /tmp/squad-update-staging-{slug}/
+  fi
+done
+```
+
+**Passo 6 — Aplicar update**
+
+1. Apagar conteudo atual de `agents/{slug}/` (exceto runtime que ja foi preservado em staging):
+   ```bash
+   rm -rf agents/{slug}/*
+   rm -rf agents/{slug}/.[!.]*  # arquivos hidden tambem
+   ```
+2. Copiar conteudo do zip pra `agents/{slug}/`:
+   ```bash
+   cp -r /tmp/squad-update-{slug}-{timestamp}/* agents/{slug}/
+   ```
+3. Restaurar runtime preservado:
+   ```bash
+   for item in /tmp/squad-update-staging-{slug}/*; do
+     cp -r "$item" agents/{slug}/
+   done
+   ```
+
+**Passo 7 — Atualizar slash command**
+
+Comparar `.claude/commands/{slug}.md` atual com o que o zip espera (geralmente derivado de `name`/`title`/`description` do squad.yaml).
+
+Se mudou (mudou descricao do squad, mudou nome do agente principal, etc): atualizar.
+
+**Passo 8 — Validar pos-update**
+
+1. `agents/{slug}/squad.yaml` (ou `config.yaml`) parsea sem erro?
+2. `agents/{slug}/tasks/start.md` existe?
+3. `.claude/commands/{slug}.md` aponta pra arquivos existentes?
+4. Versao no `squad.yaml` agora bate com a do zip?
+5. Runtime preservado intacto? (`agents/{slug}/minds/` se existia, `.state.json` se existia)
+
+**SE algum check falhar:** rollback completo:
+```bash
+rm -rf agents/{slug}/
+cp -r agents/_archive/{slug}-v{old_version}-{timestamp}/ agents/{slug}/
+```
+Reportar erro ao expert.
+
+**Passo 9 — Reportar**
+
+```
+=== UPDATE COMPLETO ===
+
+Squad: {slug}
+Versao: v{old} -> v{new}
+
+Arquivos:
+- {N} arquivos framework substituidos
+- {M} arquivos preservados (minds/, .state.json, runtime do expert)
+
+Backups criados:
+- agents/_archive/{slug}-v{old}-{timestamp}/ (squad antigo completo, 30 dias retencao)
+{SE houve modificacoes locais do expert:}
+- _backup-tuas-mods/{slug}-v{old}-{timestamp}/ (tuas modificacoes preservadas)
+
+{SE squad-forge ou similar com greeting versionado:}
+Pra confirmar que ta v{new}: ative com /{slug} e olhe o greeting.
+
+Tudo certo. Pode usar normalmente.
+```
+
+**Passo 10 — Limpar**
+1. Remover `/tmp/squad-update-{slug}-{timestamp}/`
+2. Remover `/tmp/squad-update-staging-{slug}/`
+3. SE expert quer: commitar update
+   → `setup: atualizou {slug} v{old} -> v{new}`
+
+**Protecoes:**
+- NUNCA aplicar update sem mostrar diff de versao primeiro
+- NUNCA sobrescrever `minds/` (outputs do expert)
+- NUNCA sobrescrever `.state.json` (estado em andamento)
+- NUNCA aplicar update sem backup completo do squad atual
+- SE detectar modificacoes locais do expert: ALWAYS oferecer backup-tuas-mods antes de sobrescrever
+- SE qualquer validacao pos-update falhar: ROLLBACK automatico do backup
+
+**Cenarios de erro:**
+
+| Cenario | Acao |
+|---------|------|
+| Zip corrompido / nao parseavel | Abortar antes de tocar squad atual. Reportar erro. |
+| Squad atual sem `version:` no squad.yaml | Tratar como v0.0.0. Continuar update. |
+| Expert tem versao MAIS NOVA que o zip | Confirmar duas vezes ("downgrade?"). Permitir se ele insistir. |
+| Mesma versao (v{old} == v{new}) | Tratar como reinstalacao limpa do framework, preservando dados. Util pra recuperar de modificacao acidental. |
+| Diff de modificacoes locais com 50+ arquivos | Provavelmente nao e modificacao real — e normal apos updates intermediarios. Sugerir "skip backup-tuas-mods". |
+| Rollback automatico ativado por validacao falha | Reportar exatamente qual check falhou. Squad volta intacto pro estado anterior. |
+
+---
 
 ### *install-pack
 Instalar um pack contendo multiplos squads, minds, workers e/ou agents de uma vez.

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