up-cc 0.16.1 → 2.0.1

package/up/commands/testar.md

@@ -1,7 +1,7 @@
 ---
 name: up:testar
-description: Testar projeto completo — descobre todas paginas e APIs, clica em tudo, testa tudo, corrige o que puder
-argument-hint: "[url ou porta] [--no-fix] [--report-only]"
+description: Use quando o usuario quer testar o produto. Loop DCRV unico (detectar-corrigir-reverificar) num passe. Default roda tudo (visual, interacao, API, UX, mobile, E2E). Flags --ux/--mobile/--e2e focam.
+argument-hint: "[url ou porta] [--ux] [--mobile] [--e2e] [--no-fix]"
 allowed-tools:
   - Read
   - Write
@@ -10,17 +10,24 @@ allowed-tools:
   - Grep
   - Bash
   - Task
+  - AskUserQuestion
   - mcp__plugin_playwright_playwright__*
 ---
 <objective>
-Testar um projeto existente de forma exaustiva. Descobre TODAS as paginas e APIs pelo codigo fonte, roda os 3 detectores DCRV (Visual Critic, Exhaustive Tester, API Tester), corrige issues encontradas, e gera relatorio completo.
+Testar um projeto existente de forma exaustiva, num loop DCRV unico (Detectar -> Corrigir -> Re-verificar). Descobre TODAS as paginas e APIs pelo codigo fonte, roda os detectores, corrige issues e gera relatorio.
 
-NAO planeja, NAO cria features, NAO faz auditoria de codigo. Apenas TESTA e CORRIGE.
+Funde `/up:testar` (DCRV objetivo) + `/up:ux-tester` (experiencia em 6 dimensoes) + `/up:mobile-first` (responsividade multi-viewport) + `/up:adicionar-testes` (gerar testes unitarios/E2E) + `/up:verificar-trabalho` (gate UAT conversacional).
 
-**Standalone:** Funciona em qualquer projeto, qualquer momento. NAO requer .plano/ ou /up:novo-projeto.
-**Diferencial:** Teste objetivo — clica em tudo, testa todo endpoint, verifica visual. Nao opina sobre UX.
+**Default (sem flag): roda TUDO** — visual, interacao, API, UX, mobile e E2E, num passe consolidado.
 
-**Output:** `.plano/teste/` com DCRV-REPORT.md, issues resolvidas, screenshots.
+**Flags focam o escopo:**
+- `--ux` — avalia experiencia em 6 dimensoes (clareza, eficiencia, feedback, consistencia, acessibilidade, performance percebida) e melhora.
+- `--mobile` — responsividade em mobile/tablet sem quebrar desktop (desktop e a referencia sagrada; reverte se desktop mudar).
+- `--e2e` — foca em gerar/rodar testes E2E + unitarios (ex-adicionar-testes: classifica TDD/E2E/Pular, gera com RED-GREEN).
+
+**Standalone:** funciona em qualquer projeto, qualquer momento. NAO requer `.plano/` nem `/up`.
+
+**Output:** `.plano/teste/` com DCRV-REPORT.md, issues resolvidas, screenshots antes/depois.
 </objective>
 
 <execution_context>
@@ -32,13 +39,15 @@ NAO planeja, NAO cria features, NAO faz auditoria de codigo. Apenas TESTA e CORR
 $ARGUMENTS
 
 **Argumentos opcionais:**
-- URL ou porta: `http://localhost:3000` ou `3000` (default: detecta automaticamente)
-- `--no-fix`: Apenas gerar relatorio, NAO corrigir issues
-- `--report-only`: Alias para --no-fix
-
-**Se sem argumentos:** Detecta stack, sobe dev server automaticamente, usa porta padrao.
-**Se .plano/ existe:** Usa PROJECT.md para entender o projeto.
-**Se .plano/ NAO existe:** Descobre tudo pelo codigo fonte.
+- URL ou porta: `http://localhost:3000` ou `3000` (default: detecta automaticamente).
+- `--ux` — foca em UX (6 dimensoes).
+- `--mobile` — foca em responsividade. Aceita `--page /rota` pra uma pagina so.
+- `--e2e` — foca em gerar/rodar testes (TDD unitario + E2E browser).
+- `--no-fix` (alias `--report-only`) — apenas relatorio, NAO corrige.
+
+**Se nenhuma flag de foco:** roda o DCRV completo (todos os detectores).
+**Se sem argumentos:** detecta stack, sobe dev server, usa porta padrao.
+**Se .plano/ existe:** usa PROJECT.md/REQUIREMENTS.md pra entender fluxos. Senao, descobre tudo pelo codigo.
 </context>
 
 <process>
@@ -48,7 +57,6 @@ $ARGUMENTS
 ### 1.1 Detectar Stack e Dev Server
 
 ```bash
-# Detectar stack
 if [ -f package.json ]; then
   node -e "const p=require('./package.json'); console.log(JSON.stringify({name: p.name, scripts: p.scripts, deps: Object.keys(p.dependencies||{}).slice(0,20)}))"
 fi
@@ -62,10 +70,8 @@ Definir $PORT a partir dos argumentos ou detectar automaticamente.
 ### 1.2 Subir Dev Server
 
 ```bash
-# Verificar se ja esta rodando
 curl -s http://localhost:${PORT:-3000} > /dev/null 2>&1
 if [ $? -ne 0 ]; then
-  # Detectar comando de dev
   if [ -f package.json ]; then
     npm run dev > /tmp/up-testar-server.log 2>&1 &
     TESTAR_DEV_PID=$!
@@ -73,8 +79,6 @@ if [ $? -ne 0 ]; then
     python manage.py runserver > /tmp/up-testar-server.log 2>&1 &
     TESTAR_DEV_PID=$!
   fi
-  
-  # Esperar ficar pronto (max 30s)
   for i in $(seq 1 30); do
     curl -s http://localhost:${PORT:-3000} > /dev/null 2>&1 && break
     sleep 1
@@ -88,164 +92,135 @@ Se nao subir: ERRO — informar usuario.
 
 ```bash
 echo "=== Descobrindo paginas ==="
-
 # Next.js App Router
 find app -name "page.tsx" -o -name "page.ts" 2>/dev/null | grep -v node_modules | sort
-
 # Next.js Pages Router
 find pages -name "*.tsx" -o -name "*.ts" 2>/dev/null | grep -v node_modules | grep -v "_app\|_document\|api/" | sort
-
-# React Router (Vite/CRA) — extrair paths
+# React Router (Vite/CRA)
 grep -rn "path:" src/ --include="*.tsx" --include="*.ts" --include="*.jsx" --include="*.js" 2>/dev/null | grep -v node_modules | head -30
-
 # Python (Django)
 grep -rn "path(" */urls.py 2>/dev/null | head -20
-
 # Python (FastAPI) com templates
 grep -rn "templates.TemplateResponse\|return.*html" . --include="*.py" 2>/dev/null | head -20
 ```
 
-Converter caminhos de arquivo para URLs:
-- `app/page.tsx` → `/`
-- `app/dashboard/page.tsx` → `/dashboard`
-- `app/settings/[tab]/page.tsx` → `/settings/general` (usar primeiro valor provavel)
-- `pages/about.tsx` → `/about`
-
-Montar lista `$ROUTES_UI`.
+Converter caminhos de arquivo para URLs e montar lista `$ROUTES_UI`.
 
 ### 1.4 Descobrir TODAS as APIs
 
 ```bash
 echo "=== Descobrindo APIs ==="
-
 # Next.js App Router API routes
 find app -path "*/api/*" -name "route.ts" -o -name "route.js" 2>/dev/null | grep -v node_modules | sort
-
-# Para cada route.ts, extrair metodos exportados
 for route in $(find app -path "*/api/*" -name "route.ts" 2>/dev/null); do
   methods=$(grep -oE "export.*(async )?(function )?(GET|POST|PUT|PATCH|DELETE)" "$route" | grep -oE "GET|POST|PUT|PATCH|DELETE")
   echo "$route: $methods"
 done
-
 # Next.js Pages Router API
 find pages/api -name "*.ts" -o -name "*.js" 2>/dev/null | sort
-
 # Express/Fastify
 grep -rn "app\.\(get\|post\|put\|patch\|delete\)\|router\.\(get\|post\|put\|patch\|delete\)" src/ --include="*.ts" --include="*.js" 2>/dev/null | head -30
-
 # FastAPI (Python)
 grep -rn "@app\.\(get\|post\|put\|patch\|delete\)\|@router\.\(get\|post\|put\|patch\|delete\)" . --include="*.py" 2>/dev/null | head -30
-
 # tRPC
 grep -rn "\.query\|\.mutation" src/ --include="*.ts" 2>/dev/null | grep -i "router\|procedure" | head -20
-
 # Supabase Edge Functions
 ls supabase/functions/*/index.ts 2>/dev/null
 ```
 
 Montar lista `$ROUTES_API` com metodo + path.
 
-### 1.5 Classificar Projeto e Reportar
+### 1.5 Parsear Flags e Definir Escopo
+
+- `--ux` -> SCOPE inclui auditoria de experiencia (6 dimensoes).
+- `--mobile` -> SCOPE inclui responsividade multi-viewport (aceita `--page /rota`).
+- `--e2e` -> SCOPE inclui geracao/execucao de testes (TDD unitario + E2E browser).
+- **Nenhuma flag de foco** -> SCOPE = TUDO (visual + interacao + API + UX + mobile + E2E).
+- `--no-fix`/`--report-only` -> AUTO_FIX=false.
+
+### 1.6 Reportar Descoberta e Criar Diretorio
+
+```bash
+mkdir -p .plano/teste
+```
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  UP > TESTAR — DESCOBERTA COMPLETA
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Projeto: [nome do package.json ou diretorio]
-Stack: [Next.js / Vite / FastAPI / etc.]
-Dev server: http://localhost:{PORT}
-
-Paginas encontradas: {N}
-  [lista de URLs]
-
-APIs encontradas: {N}
-  [lista de METHOD /path]
-
-Detectores a rodar:
-  [x] Visual Critic ({N} paginas × 3 viewports)
-  [x] Exhaustive Tester ({N} paginas, todos elementos)
-  [x] API Tester ({N} endpoints, bateria completa)
-
+Projeto: [nome]   Stack: [...]   Dev server: http://localhost:{PORT}
+Paginas: {N}   APIs: {N}   Escopo: [tudo | ux | mobile | e2e]
 Iniciando testes...
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-### 1.6 Criar Diretorio de Resultados
-
-```bash
-mkdir -p .plano/teste
-```
-
-## Passo 2: Rodar DCRV Global
+## Passo 2: Rodar DCRV
 
 **Referencia:** `@~/.claude/up/workflows/dcrv.md`
 
-Determinar AUTO_FIX baseado nas flags:
-- Se `--no-fix` ou `--report-only`: AUTO_FIX=false
-- Senao: AUTO_FIX=true
-
-Executar workflow DCRV com parametros:
+Executar o workflow DCRV com:
 ```
 SCOPE=global
-PORT={porta do dev server}
+PORT={porta}
 MAX_CYCLES=3
 MAX_ISSUES_PER_CYCLE=20
-AUTO_FIX={true ou false baseado nas flags}
-ROUTES_UI={lista de paginas descobertas}
-ROUTES_API={lista de APIs descobertas}
+AUTO_FIX={true ou false}
+ROUTES_UI={paginas}
+ROUTES_API={APIs}
 DCRV_DIR=.plano/teste
+PASSES={derivado das flags: visual, interacao, api sempre; ux se --ux ou default; mobile se --mobile ou default; e2e se --e2e ou default}
 ```
 
-O DCRV cuida de:
-1. Rodar Visual Critic em todas paginas (3 viewports, CSS extraction, screenshots)
-2. Rodar API Tester em todas rotas (happy path, payloads invalidos, auth, edge cases)
-3. Rodar Exhaustive Tester em todas paginas (clicar em CADA elemento)
-4. Consolidar issues
-5. Se AUTO_FIX: dispatcher roteia para especialistas corrigirem
-6. Re-verificar correcoes
-7. Loop ate resolver ou max ciclos
+O DCRV (workflow unico, ja absorveu ux-tester / mobile-first / builder-e2e) cuida de:
+1. Visual em todas paginas (3 viewports, CSS extraction, screenshots)
+2. API Tester (happy path, payloads invalidos, auth, edge cases)
+3. Exhaustive Tester (clicar em CADA elemento)
+4. UX (6 dimensoes) — quando no escopo
+5. Mobile (responsividade, desktop sagrado) — quando no escopo
+6. E2E + geracao de testes (TDD/E2E classificados, RED-GREEN) — quando no escopo
+7. Consolidar issues -> se AUTO_FIX: dispatcher roteia pra correcao -> re-verificar -> loop ate resolver ou max ciclos
 
 ## Passo 3: Carregar Design Tokens (se existir)
 
 ```bash
-# Checar se projeto tem design tokens definidos
 cat .plano/DESIGN-TOKENS.md 2>/dev/null
-# Ou inferir do Tailwind config
 cat tailwind.config.ts tailwind.config.js 2>/dev/null | head -50
-# Ou de globals.css
 cat app/globals.css src/globals.css styles/globals.css 2>/dev/null | head -50
 ```
 
-Passar como referencia para o Visual Critic.
+Passar como referencia para os detectores visuais.
+
+## Passo 4: Gate UAT (ex-verificar-trabalho)
 
-## Passo 4: Cleanup
+Se `.plano/` tem fase ativa com plano, rodar gate UAT conversacional:
+- Testar cada feature planejada contra REQUIREMENTS.
+- Coletar feedback do usuario via AskUserQuestion.
+- Gerar/atualizar `VERIFICATION.md` na pasta da fase.
+- Se gaps: oferecer `/up:plan <fase> --gaps` pra planejar correcoes.
+- Se aprovado: marcar a fase como verificada.
+
+## Passo 5: Cleanup
 
 ```bash
-# Matar dev server se nos que subimos
-if [ -n "$TESTAR_DEV_PID" ]; then
-  kill $TESTAR_DEV_PID 2>/dev/null
-fi
+if [ -n "$TESTAR_DEV_PID" ]; then kill $TESTAR_DEV_PID 2>/dev/null; fi
 ```
-
 Fechar browser se aberto.
 
-## Passo 5: Apresentar Resultado
+## Passo 6: Apresentar Resultado
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  UP > TESTE COMPLETO
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-## Scores
-
 | Detector | Score | Detalhes |
 |----------|-------|----------|
-| Visual | {N}/10 | {issues} issues em {paginas} paginas |
-| Interacao | {N}% pass | {passed}/{total} elementos funcionam |
-| API | {N}% pass | {passed}/{total} testes passaram |
-
-## Issues
+| Visual    | {N}/10 | {issues} em {paginas} paginas |
+| Interacao | {N}% pass | {passed}/{total} elementos |
+| API       | {N}% pass | {passed}/{total} testes |
+| UX        | {N}/10 | (se no escopo) |
+| Mobile    | {N}/10 | (se no escopo) |
+| E2E       | {M} testes | {pass}/{total} (se no escopo) |
 
 | Severidade | Encontradas | Corrigidas | Pendentes |
 |-----------|-------------|-----------|-----------|
@@ -254,20 +229,7 @@ Fechar browser se aberto.
 | Medium | {N} | {N} | {N} |
 | Low | {N} | — | {N} |
 
-## Top Issues Pendentes (se houver)
-
-[Lista das issues nao corrigidas com descricao]
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Relatorio completo: .plano/teste/DCRV-REPORT.md
-Screenshots: .plano/teste/
-
-Proximos passos:
-- /up:ux-tester — avaliar experiencia do usuario
-- /up:melhorias — auditoria de codigo
-- /up:modo-builder "nova feature" — adicionar funcionalidade
-
+Relatorio: .plano/teste/DCRV-REPORT.md   Screenshots: .plano/teste/
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
@@ -275,13 +237,10 @@ Proximos passos:
 
 <success_criteria>
 - [ ] Stack detectada e dev server rodando
-- [ ] TODAS paginas descobertas pelo codigo fonte
-- [ ] TODAS APIs descobertas pelo codigo fonte
-- [ ] Visual Critic rodou em todas paginas (3 viewports)
-- [ ] Exhaustive Tester clicou em todos elementos de todas paginas
-- [ ] API Tester testou todos endpoints com bateria completa
-- [ ] Issues consolidadas com severidade
-- [ ] Issues corrigidas (se nao --no-fix)
-- [ ] DCRV-REPORT.md gerado em .plano/teste/
-- [ ] Resumo apresentado com scores
+- [ ] TODAS paginas e APIs descobertas pelo codigo fonte
+- [ ] Flags parseadas (default = roda tudo)
+- [ ] DCRV rodou os passes do escopo (visual/interacao/api + ux/mobile/e2e conforme flags)
+- [ ] Issues consolidadas com severidade e corrigidas (se nao --no-fix)
+- [ ] Gate UAT rodado quando ha fase ativa (VERIFICATION.md)
+- [ ] DCRV-REPORT.md gerado e resumo apresentado
 </success_criteria>

package/up/commands/up.md

@@ -0,0 +1,106 @@
+---
+name: up
+description: Porta unica do UP. Sem argumento continua de onde parou (le STATE.md). Com descricao dispara brainstorm e roteia greenfield/brownfield/clone. Subverbos estado e config.
+argument-hint: "[descricao | estado | config]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebFetch
+  - WebSearch
+  - AskUserQuestion
+  - mcp__context7__*
+  - mcp__plugin_playwright_playwright__*
+---
+<objective>
+Porta unica do UP. Um comando que cobre tres situacoes pelo argumento:
+
+1. **Sem argumento** = continuar de onde parou. Le `.plano/STATE.md`, calcula progresso, e roteia pra proxima acao recomendada (planejar, executar, testar, etc.). Se nao existe `.plano/`, ofrece comecar.
+2. **Com descricao** = dispara brainstorm escalado por tamanho (reusa `classify-task`) e roteia: greenfield (do zero), brownfield (feature em projeto existente), ou clone (recriar app a partir de URL).
+3. **Subverbo `estado` ou `config`** = casa de estado e configuracao do projeto.
+
+Regra dura: **maximo 3 subverbos**. So existem `continuar` (default, sem arg), `estado` e `config`. Tudo mais e detectado por contexto.
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/up.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+**Roteamento por argumento:**
+- Vazio -> `continuar` (le STATE.md, roteia pra proxima acao).
+- `estado` (ou `status`, `saude`, `pausar`, `resetar`, `custos`, `remover-fase`) -> subverbo estado.
+- `config` (ou `configurar`, `onboard`, `atualizar`) -> subverbo config.
+- Qualquer outra descricao em texto livre -> brainstorm + roteamento de projeto.
+
+**Deteccao automatica de modo de projeto (quando ha descricao):**
+- URL fornecida (https://...) -> CLONE.
+- Codigo existente no diretorio (package.json, src/, .plano/) -> BROWNFIELD.
+- Diretorio vazio / sem codigo -> GREENFIELD.
+
+**Subverbo `estado`** cobre (sem comando proprio):
+- status do projeto e proxima acao (ex-progresso)
+- diagnostico de integridade do `.plano/` e reparo opcional (ex-saude)
+- handoff `.continue-aqui.md` ao pausar (ex-pausar)
+- restaurar contexto da sessao anterior (ex-retomar)
+- reset do `.plano/` parcial ou total (ex-resetar)
+- estimativa de custo em tokens dos agentes (ex-custos, Claude Code only)
+- remover fase futura e renumerar (ex-remover-fase, operacao estrutural rara)
+- abrir board (flag `--board` -> URL do Multica; **TODO Fase 5 (Multica)**)
+
+**Subverbo `config`** cobre:
+- configurar opcoes do workflow no `.plano/config.json` (ex-configurar)
+- onboarding do dono / criar `~/.claude/up/owner-profile.md` (ex-onboard)
+- atualizar o up-cc via npm (ex-atualizar)
+</context>
+
+<process>
+Execute the up router workflow from @~/.claude/up/workflows/up.md end-to-end.
+
+**Passo 0 — Parsear argumento e decidir rota:**
+
+1. Sem argumento (ou so flags):
+   - Se `.plano/STATE.md` existe: rota `continuar`. Le STATE.md, mostra status, roteia pra proxima acao.
+   - Se `.plano/` NAO existe e NAO ha codigo: mostra como comecar (descrever o projeto pra disparar brainstorm).
+   - Se ha codigo mas sem `.plano/`: oferece registrar/mapear o projeto existente.
+
+2. Primeiro token = `estado` / `config`: rota subverbo correspondente (logica inline no workflow up.md).
+
+3. Descricao em texto livre: rota `brainstorm`.
+
+**Brainstorm escalado por tamanho (quando ha descricao):**
+Reusa `classify-task` (NAO reimplementar):
+```bash
+node "$HOME/.claude/up/bin/up-tools.cjs" classify-task "<descricao>"
+```
+- Trivial (1 arquivo, sem decisao de arquitetura): **0 perguntas**, anuncia em 1 linha, roteia.
+- Pequena (1 subsistema, 1 escolha de design): **1 pergunta** via AskUserQuestion + design em 3 frases.
+- Media/Grande (multi-subsistema, schema/API/auth): **brainstorm full** com aprovacao por secao.
+
+Brainstorm gera BRIEFING.md (intake inline, sem CEO). Em seguida roteia:
+- GREENFIELD -> pipeline de novo projeto (pesquisa + sintese), depois `/up:plan`.
+- BROWNFIELD -> mapeia codebase, depois `/up:plan`.
+- CLONE -> modo clone do mapeador (crawl + design + features + PRD), depois `/up:plan`.
+
+**Interface alvo de orquestracao GitHub-nativa / Multica:**
+As flags `--solo` (default, commit local), `--pr` (worktree/issue/PR), `--board` (espelho Multica), `--auto` (merge se verde) sao a interface alvo. Documentar pro usuario, mas a orquestracao real NAO roda aqui.
+**TODO Fase 4 (GitHub-native):** worktree -> issue -> PR -> merge.
+**TODO Fase 5 (Multica):** espelho de board batched.
+
+**GATE — Owner Profile:**
+Se a rota envolve brainstorm/plan e `~/.claude/up/owner-profile.md` NAO existe neste runtime, rodar config/onboarding primeiro (workflow onboarding.md). Sem profile, o brainstorm fica generico.
+</process>
+
+<success_criteria>
+- [ ] Argumento parseado e rota escolhida (continuar / estado / config / brainstorm)
+- [ ] Sem arg + .plano/ existe: STATE.md lido e proxima acao roteada
+- [ ] Com descricao: classify-task rodado, brainstorm escalado, modo detectado
+- [ ] Subverbos limitados a estado e config (max 3)
+- [ ] Owner profile garantido antes de brainstorm/plan
+</success_criteria>

package/up/hooks/up-session-start.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// UP Session Start - SessionStart hook
+// Injects the `usando-up` skill bootstrap as additionalContext at the start of
+// each session (and after /clear or /compact), so the agent always boots with
+// the UP discipline loaded -- no explicit command needed.
+//
+// Mirrors the auto-activation mechanism: the bootstrap teaches the agent to
+// check skills by context. The full SKILL.md is read at runtime from the
+// installed skills layer; a short embedded fallback is used if it's missing.
+//
+// Additive and fail-open: any error exits 0 without blocking the session.
+
+const fs = require('fs');
+const path = require('path');
+
+// Events that should (re)inject the bootstrap. After clear/compact the context
+// is wiped, so we re-prime the agent.
+const TRIGGER_SOURCES = ['startup', 'clear', 'compact'];
+
+// Short embedded fallback used only if the installed SKILL.md is unavailable.
+const FALLBACK_BOOTSTRAP =
+  'Voce tem o UP instalado: um sistema de desenvolvimento orientado a especificacao, ' +
+  'em portugues, composto por skills que ativam por contexto.\n\n' +
+  'REGRA: se ha mais de 1% de chance de uma skill se aplicar ao que voce vai fazer, ' +
+  'voce DEVE invoca-la com a tool Skill ANTES de qualquer resposta ou acao. ' +
+  'Isso vale ate para perguntas simples e antes de fazer perguntas de esclarecimento. ' +
+  'Skills de processo (brainstorm, depuracao, verificacao) vem antes das de implementacao.\n\n' +
+  'Antes de qualquer trabalho criativo (criar feature, componente, comportamento novo), ' +
+  'use a skill up-brainstorm. Antes de afirmar que algo esta pronto, corrigido ou passando, ' +
+  'use a skill up-verificar-antes-de-concluir: nunca afirme sucesso sem rodar a verificacao ' +
+  'e ler a saida nesta mensagem. Para a porta unica do fluxo, use o comando /up.';
+
+function readBootstrap() {
+  // Resolve the installed SKILL.md relative to this hook:
+  //   <config>/hooks/up-session-start.js  ->  <config>/up/skills/usando-up/SKILL.md
+  // In the repo source layout the hook lives at up/hooks/, so the skill is at
+  //   up/hooks/../skills/usando-up/SKILL.md  ==  up/skills/usando-up/SKILL.md
+  // Both resolve via ../skills/usando-up/SKILL.md from the hook directory.
+  const candidates = [
+    path.resolve(__dirname, '..', 'skills', 'usando-up', 'SKILL.md'),
+    path.resolve(__dirname, '..', 'up', 'skills', 'usando-up', 'SKILL.md'),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        const content = fs.readFileSync(candidate, 'utf8');
+        if (content && content.trim()) return content;
+      }
+    } catch (e) { /* try next */ }
+  }
+
+  return FALLBACK_BOOTSTRAP;
+}
+
+function buildContext(bootstrap) {
+  return '<EXTREMELY_IMPORTANT>\n' +
+    'Voce tem o UP.\n\n' +
+    'Abaixo esta o conteudo completo da sua skill \'usando-up\' -- sua introducao a usar ' +
+    'as skills do UP. Para todas as outras skills, use a tool Skill:\n\n' +
+    bootstrap.trim() + '\n' +
+    '</EXTREMELY_IMPORTANT>';
+}
+
+function emit(bootstrap) {
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: buildContext(bootstrap),
+    },
+  };
+  process.stdout.write(JSON.stringify(output));
+}
+
+let input = '';
+const stdinTimeout = setTimeout(() => {
+  // No stdin within 3s (Windows/Git Bash guard): still inject the bootstrap.
+  try { emit(readBootstrap()); } catch (e) {}
+  process.exit(0);
+}, 3000);
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    let source = null;
+    try {
+      const data = JSON.parse(input);
+      // SessionStart payload carries the trigger in `source` (startup|clear|compact|resume).
+      source = data && (data.source || data.hook_event_source || null);
+    } catch (e) {
+      // No/invalid payload: with no matcher available, inject anyway.
+      source = null;
+    }
+
+    // If a source is present and it is NOT one of our triggers, skip silently.
+    if (source && !TRIGGER_SOURCES.includes(source)) {
+      process.exit(0);
+    }
+
+    emit(readBootstrap());
+  } catch (e) {
+    // Fail-open: never block the session.
+  }
+  process.exit(0);
+});

package/up/references/engineering-principles.md

@@ -1,7 +1,7 @@
 # Engineering Principles
 
 Principios que governam TODA decisao de implementacao no UP.
-Carregado por todos os agentes executores (up-executor, up-frontend-specialist, up-backend-specialist, up-database-specialist).
+Carregado pelo up-executor (que roteia frontend/backend/database por contexto).
 
 Estes principios existem porque IAs tendem a escolher o caminho mais facil, nao o melhor. Cada principio combate um vicio especifico.
 

package/up/references/governance-rules.md

@@ -1,7 +1,7 @@
 # Governance Rules
 
 Regras de governanca aplicadas a TODOS os comandos UP.
-Carregado por supervisores, chiefs e CEO.
+Carregado pelo orquestrador e pelo up-revisor.
 
 ---
 
@@ -10,13 +10,13 @@ Carregado por supervisores, chiefs e CEO.
 ```
 DONO (humano)
   ↓
-CEO (up-project-ceo)
+ORQUESTRADOR (intake/canal com o dono)
   ↓
-CHIEFS (5 — architecture, product, engineer, quality, operations)
+up-revisor (consolidacao + veredito que alimenta o gate)
   ↓
-SUPERVISORES (8 — area especifica)
+GATE deterministico (approvals.log)
   ↓
-OPERACIONAIS (36 — agentes existentes)
+OPERACIONAIS (agentes existentes)
 ```
 
 ## Fluxo de Aprovacao

package/up/references/production-requirements.md

@@ -1,7 +1,7 @@
 # Production Requirements Reference
 
 Checklist de requisitos que TODO sistema pronto para producao deve ter.
-O up-system-designer e up-arquiteto usam esta referencia para injetar requisitos automaticamente.
+O up-arquiteto usa esta referencia para injetar requisitos automaticamente.
 
 Cada item e um requisito com ID sugerido. O arquiteto ajusta IDs para nao colidir com requisitos explicitos do usuario.
 

package/up/references/severity-levels.md

@@ -1,7 +1,7 @@
 # Severity Levels
 
-Niveis de severidade usados pelo CEO para decidir quando interromper o dono.
-Carregado pelo up-project-ceo.
+Niveis de severidade usados para decidir quando interromper o dono.
+Carregado pelo orquestrador e pelo up-revisor.
 
 ---