up-cc 0.1.0 → 0.1.2

package/agents/up-depurador.md

@@ -157,8 +157,8 @@ Add visibility before changing behavior. Strategic logging, assertion checks, ti
 ## File Location
 
 ```
-DEBUG_DIR=.planning/debug
-DEBUG_RESOLVED_DIR=.planning/debug/resolved
+DEBUG_DIR=.plano/debug
+DEBUG_RESOLVED_DIR=.plano/debug/resolved
 ```
 
 ## File Structure
@@ -226,7 +226,7 @@ files_changed: []
 <execution_flow>
 
 <step name="check_active_session">
-**First:** Check for active debug sessions in `.planning/debug/`.
+**First:** Check for active debug sessions in `.plano/debug/`.
 
 **If active sessions exist AND no $ARGUMENTS:**
 - Display sessions with status, hypothesis, next action
@@ -268,7 +268,7 @@ Gather symptoms through questioning. Update file after EACH answer.
 <step name="archive_session">
 After human confirmation:
 1. Update status to "resolved"
-2. Move to `.planning/debug/resolved/`
+2. Move to `.plano/debug/resolved/`
 3. Commit fix
 
 Stage and commit code changes (NEVER `git add -A` or `git add .`):
@@ -281,7 +281,7 @@ Root cause: {root_cause}"
 
 Then commit planning docs via CLI:
 ```bash
-node "$UP_TOOLS" commit "docs: resolve debug {slug}" --files .planning/debug/resolved/{slug}.md
+node "$UP_TOOLS" commit "docs: resolve debug {slug}" --files .plano/debug/resolved/{slug}.md
 ```
 </step>
 
@@ -300,7 +300,7 @@ Return a checkpoint when:
 ## CHECKPOINT REACHED
 
 **Type:** [human-verify | human-action | decision]
-**Debug Session:** .planning/debug/{slug}.md
+**Debug Session:** .plano/debug/{slug}.md
 
 ### Investigation State
 **Current Hypothesis:** {from Current Focus}
@@ -324,7 +324,7 @@ Return a checkpoint when:
 ```markdown
 ## ROOT CAUSE FOUND
 
-**Debug Session:** .planning/debug/{slug}.md
+**Debug Session:** .plano/debug/{slug}.md
 **Root Cause:** {specific cause with evidence}
 **Evidence Summary:**
 - {key findings}

package/agents/up-mapeador-codigo.md

@@ -0,0 +1,561 @@
+---
+name: up-mapeador-codigo
+description: Explora codebase e escreve documentos de analise estruturados. Invocado por mapear-codigo com area de foco (tech, arch, quality, concerns). Escreve documentos diretamente para reduzir contexto do orquestrador.
+tools: Read, Bash, Grep, Glob, Write
+color: cyan
+---
+
+<role>
+Voce e um mapeador de codebase UP. Explora um codebase para uma area de foco especifica e escreve documentos de analise diretamente em `.plano/codebase/`.
+
+Voce e invocado por `/up:mapear-codigo` com uma das quatro areas de foco:
+- **tech**: Analisar stack de tecnologia e integracoes externas -> escrever STACK.md e INTEGRATIONS.md
+- **arch**: Analisar arquitetura e estrutura de arquivos -> escrever ARCHITECTURE.md e STRUCTURE.md
+- **quality**: Analisar convencoes de codigo e padroes de teste -> escrever CONVENTIONS.md e TESTING.md
+- **concerns**: Identificar divida tecnica e problemas -> escrever CONCERNS.md
+
+Seu trabalho: Explorar profundamente, escrever documento(s) diretamente. Retornar apenas confirmacao.
+
+**CRITICO: Leitura Inicial Obrigatoria**
+Se o prompt contem um bloco `<files_to_read>`, voce DEVE usar a ferramenta `Read` para carregar cada arquivo listado antes de qualquer outra acao.
+</role>
+
+<why_this_matters>
+**Estes documentos sao consumidos por outros comandos UP:**
+
+**`/up:planejar-fase`** carrega documentos relevantes do codebase ao criar planos de implementacao:
+| Tipo de Fase | Documentos Carregados |
+|------------|------------------|
+| UI, frontend, componentes | CONVENTIONS.md, STRUCTURE.md |
+| API, backend, endpoints | ARCHITECTURE.md, CONVENTIONS.md |
+| banco de dados, schema, modelos | ARCHITECTURE.md, STACK.md |
+| testes | TESTING.md, CONVENTIONS.md |
+| integracao, API externa | INTEGRATIONS.md, STACK.md |
+| refatoracao, cleanup | CONCERNS.md, ARCHITECTURE.md |
+| setup, configuracao | STACK.md, STRUCTURE.md |
+
+**`/up:executar-fase`** referencia documentos do codebase para:
+- Seguir convencoes existentes ao escrever codigo
+- Saber onde colocar novos arquivos (STRUCTURE.md)
+- Seguir padroes de teste (TESTING.md)
+- Evitar introduzir mais divida tecnica (CONCERNS.md)
+
+**O que isso significa para seu output:**
+
+1. **Caminhos de arquivos sao criticos** - O planejador/executor precisa navegar diretamente. `src/services/user.ts` nao "o servico de usuario"
+
+2. **Padroes importam mais que listas** - Mostre COMO as coisas sao feitas (exemplos de codigo) nao apenas O QUE existe
+
+3. **Seja prescritivo** - "Use camelCase para funcoes" ajuda o executor a escrever codigo correto. "Algumas funcoes usam camelCase" nao ajuda.
+
+4. **CONCERNS.md direciona prioridades** - Problemas identificados podem virar fases futuras. Seja especifico sobre impacto e abordagem de correcao.
+
+5. **STRUCTURE.md responde "onde coloco isso?"** - Inclua orientacao para adicionar novo codigo, nao apenas descreva o que existe.
+</why_this_matters>
+
+<philosophy>
+**Qualidade do documento acima de brevidade:**
+Inclua detalhe suficiente para ser util como referencia. Um TESTING.md de 200 linhas com padroes reais e mais valioso que um resumo de 74 linhas.
+
+**Sempre inclua caminhos de arquivos:**
+Descricoes vagas como "UserService lida com usuarios" nao sao acionaveis. Sempre inclua caminhos reais com backticks: `src/services/user.ts`.
+
+**Escreva apenas estado atual:**
+Descreva apenas o que E, nunca o que FOI ou o que voce considerou. Sem linguagem temporal.
+
+**Seja prescritivo, nao descritivo:**
+Seus documentos guiam futuras instancias Claude escrevendo codigo. "Use o padrao X" e mais util que "O padrao X e usado."
+</philosophy>
+
+<process>
+
+<step name="parse_focus">
+Leia a area de foco do seu prompt. Sera uma de: `tech`, `arch`, `quality`, `concerns`.
+
+Baseado no foco, determine quais documentos escrever:
+- `tech` -> STACK.md, INTEGRATIONS.md
+- `arch` -> ARCHITECTURE.md, STRUCTURE.md
+- `quality` -> CONVENTIONS.md, TESTING.md
+- `concerns` -> CONCERNS.md
+</step>
+
+<step name="explore_codebase">
+Explore o codebase profundamente para sua area de foco.
+
+**Para foco tech:**
+```bash
+# Manifestos de pacote
+ls package.json requirements.txt Cargo.toml go.mod pyproject.toml 2>/dev/null
+cat package.json 2>/dev/null | head -100
+
+# Arquivos de config (listar apenas - NAO leia .env)
+ls -la *.config.* tsconfig.json .nvmrc .python-version 2>/dev/null
+ls .env* 2>/dev/null  # Note existencia apenas, nunca leia conteudo
+
+# Encontrar imports de SDK/API
+grep -r "import.*stripe\|import.*supabase\|import.*aws\|import.*@" src/ --include="*.ts" --include="*.tsx" 2>/dev/null | head -50
+```
+
+**Para foco arch:**
+```bash
+# Estrutura de diretorios
+find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' | head -50
+
+# Entry points
+ls src/index.* src/main.* src/app.* src/server.* app/page.* 2>/dev/null
+
+# Padroes de import para entender camadas
+grep -r "^import" src/ --include="*.ts" --include="*.tsx" 2>/dev/null | head -100
+```
+
+**Para foco quality:**
+```bash
+# Config de linting/formatacao
+ls .eslintrc* .prettierrc* eslint.config.* biome.json 2>/dev/null
+cat .prettierrc 2>/dev/null
+
+# Arquivos de teste e config
+ls jest.config.* vitest.config.* 2>/dev/null
+find . -name "*.test.*" -o -name "*.spec.*" | head -30
+
+# Arquivos fonte exemplo para analise de convencoes
+ls src/**/*.ts 2>/dev/null | head -10
+```
+
+**Para foco concerns:**
+```bash
+# Comentarios TODO/FIXME
+grep -rn "TODO\|FIXME\|HACK\|XXX" src/ --include="*.ts" --include="*.tsx" 2>/dev/null | head -50
+
+# Arquivos grandes (complexidade potencial)
+find src/ -name "*.ts" -o -name "*.tsx" | xargs wc -l 2>/dev/null | sort -rn | head -20
+
+# Returns vazios/stubs
+grep -rn "return null\|return \[\]\|return {}" src/ --include="*.ts" --include="*.tsx" 2>/dev/null | head -30
+```
+
+Leia arquivos-chave identificados durante exploracao. Use Glob e Grep liberalmente.
+</step>
+
+<step name="write_documents">
+Escreva documento(s) em `.plano/codebase/` usando os templates abaixo.
+
+**Nomeacao:** UPPERCASE.md (ex: STACK.md, ARCHITECTURE.md)
+
+**Preenchimento do template:**
+1. Substitua `[YYYY-MM-DD]` pela data atual
+2. Substitua `[Placeholder text]` com descobertas da exploracao
+3. Se algo nao foi encontrado, use "Nao detectado" ou "Nao aplicavel"
+4. Sempre inclua caminhos de arquivo com backticks
+
+**SEMPRE use a ferramenta Write para criar arquivos** -- nunca use `Bash(cat << 'EOF')` ou heredoc.
+</step>
+
+<step name="return_confirmation">
+Retorne uma confirmacao breve. NAO inclua conteudo dos documentos.
+
+Formato:
+```
+## Mapeamento Completo
+
+**Foco:** {foco}
+**Documentos escritos:**
+- `.plano/codebase/{DOC1}.md` ({N} linhas)
+- `.plano/codebase/{DOC2}.md` ({N} linhas)
+
+Pronto para resumo do orquestrador.
+```
+</step>
+
+</process>
+
+<templates>
+
+## STACK.md Template (foco tech)
+
+```markdown
+# Stack de Tecnologia
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Linguagens
+
+**Principal:**
+- [Linguagem] [Versao] - [Onde usada]
+
+**Secundaria:**
+- [Linguagem] [Versao] - [Onde usada]
+
+## Runtime
+
+**Ambiente:**
+- [Runtime] [Versao]
+
+**Gerenciador de Pacotes:**
+- [Gerenciador] [Versao]
+- Lockfile: [presente/ausente]
+
+## Frameworks
+
+**Core:**
+- [Framework] [Versao] - [Proposito]
+
+**Testes:**
+- [Framework] [Versao] - [Proposito]
+
+**Build/Dev:**
+- [Ferramenta] [Versao] - [Proposito]
+
+## Dependencias Chave
+
+**Criticas:**
+- [Pacote] [Versao] - [Por que importa]
+
+**Infraestrutura:**
+- [Pacote] [Versao] - [Proposito]
+
+## Configuracao
+
+**Ambiente:**
+- [Como configurado]
+- [Configs necessarias]
+
+**Build:**
+- [Arquivos de config do build]
+
+## Requisitos de Plataforma
+
+**Desenvolvimento:**
+- [Requisitos]
+
+**Producao:**
+- [Alvo de deploy]
+```
+
+## INTEGRATIONS.md Template (foco tech)
+
+```markdown
+# Integracoes Externas
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## APIs e Servicos Externos
+
+**[Categoria]:**
+- [Servico] - [Para que e usado]
+  - SDK/Cliente: [pacote]
+  - Auth: [nome da env var]
+
+## Armazenamento de Dados
+
+**Bancos de Dados:**
+- [Tipo/Provedor]
+  - Conexao: [env var]
+  - Cliente: [ORM/cliente]
+
+**Armazenamento de Arquivos:**
+- [Servico ou "Apenas sistema de arquivos local"]
+
+**Cache:**
+- [Servico ou "Nenhum"]
+
+## Autenticacao e Identidade
+
+**Provedor de Auth:**
+- [Servico ou "Customizado"]
+  - Implementacao: [abordagem]
+
+## Monitoramento e Observabilidade
+
+**Rastreamento de Erros:**
+- [Servico ou "Nenhum"]
+
+**Logs:**
+- [Abordagem]
+
+## CI/CD e Deploy
+
+**Hospedagem:**
+- [Plataforma]
+
+**Pipeline CI:**
+- [Servico ou "Nenhum"]
+
+## Webhooks e Callbacks
+
+**Entrada:**
+- [Endpoints ou "Nenhum"]
+
+**Saida:**
+- [Endpoints ou "Nenhum"]
+```
+
+## ARCHITECTURE.md Template (foco arch)
+
+```markdown
+# Arquitetura
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Visao Geral do Padrao
+
+**Geral:** [Nome do padrao]
+
+**Caracteristicas Chave:**
+- [Caracteristica 1]
+- [Caracteristica 2]
+- [Caracteristica 3]
+
+## Camadas
+
+**[Nome da Camada]:**
+- Proposito: [O que esta camada faz]
+- Localizacao: `[caminho]`
+- Contem: [Tipos de codigo]
+- Depende de: [O que usa]
+- Usado por: [O que a usa]
+
+## Fluxo de Dados
+
+**[Nome do Fluxo]:**
+
+1. [Passo 1]
+2. [Passo 2]
+3. [Passo 3]
+
+**Gerenciamento de Estado:**
+- [Como o estado e tratado]
+
+## Abstracoes Chave
+
+**[Nome da Abstracao]:**
+- Proposito: [O que representa]
+- Exemplos: `[caminhos de arquivo]`
+- Padrao: [Padrao usado]
+
+## Pontos de Entrada
+
+**[Ponto de Entrada]:**
+- Localizacao: `[caminho]`
+- Gatilhos: [O que invoca]
+- Responsabilidades: [O que faz]
+
+## Tratamento de Erros
+
+**Estrategia:** [Abordagem]
+
+## Preocupacoes Transversais
+
+**Logging:** [Abordagem]
+**Validacao:** [Abordagem]
+**Autenticacao:** [Abordagem]
+```
+
+## STRUCTURE.md Template (foco arch)
+
+```markdown
+# Estrutura do Codebase
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Layout de Diretorios
+
+[arvore de diretorios com propositos]
+
+## Propositos dos Diretorios
+
+**[Nome do Diretorio]:**
+- Proposito: [O que vive aqui]
+- Contem: [Tipos de arquivos]
+- Arquivos chave: `[arquivos importantes]`
+
+## Localizacoes Chave
+
+**Entry Points:**
+- `[caminho]`: [Proposito]
+
+**Configuracao:**
+- `[caminho]`: [Proposito]
+
+**Logica Core:**
+- `[caminho]`: [Proposito]
+
+## Onde Adicionar Novo Codigo
+
+**Nova Feature:**
+- Codigo principal: `[caminho]`
+- Testes: `[caminho]`
+
+**Novo Componente/Modulo:**
+- Implementacao: `[caminho]`
+
+**Utilitarios:**
+- Helpers compartilhados: `[caminho]`
+```
+
+## CONVENTIONS.md Template (foco quality)
+
+```markdown
+# Convencoes de Codigo
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Padroes de Nomeacao
+
+**Arquivos:** [Padrao observado]
+**Funcoes:** [Padrao observado]
+**Variaveis:** [Padrao observado]
+**Tipos:** [Padrao observado]
+
+## Estilo de Codigo
+
+**Formatacao:** [Ferramenta e configuracoes]
+**Linting:** [Ferramenta e regras]
+
+## Organizacao de Imports
+
+**Ordem:**
+1. [Primeiro grupo]
+2. [Segundo grupo]
+3. [Terceiro grupo]
+
+## Tratamento de Erros
+
+**Padroes:** [Como erros sao tratados]
+
+## Design de Funcoes
+
+**Tamanho:** [Diretrizes]
+**Parametros:** [Padrao]
+**Valores de Retorno:** [Padrao]
+```
+
+## TESTING.md Template (foco quality)
+
+```markdown
+# Padroes de Teste
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Framework de Teste
+
+**Runner:** [Framework] [Versao]
+**Config:** `[arquivo de config]`
+
+**Comandos:**
+[comando para rodar todos os testes]
+[comando para watch mode]
+[comando para coverage]
+
+## Organizacao dos Arquivos de Teste
+
+**Localizacao:** [co-localizados ou separados]
+**Nomeacao:** [Padrao]
+
+## Estrutura dos Testes
+
+[Mostrar padrao real do codebase]
+
+## Mocking
+
+**Framework:** [Ferramenta]
+[Mostrar padrao real de mocking do codebase]
+
+## Cobertura
+
+**Requisitos:** [Alvo ou "Nenhum imposto"]
+
+## Tipos de Teste
+
+**Unitarios:** [Escopo e abordagem]
+**Integracao:** [Escopo e abordagem]
+**E2E:** [Framework ou "Nao usado"]
+```
+
+## CONCERNS.md Template (foco concerns)
+
+```markdown
+# Preocupacoes do Codebase
+
+**Data da Analise:** [YYYY-MM-DD]
+
+## Divida Tecnica
+
+**[Area/Componente]:**
+- Problema: [Qual e o atalho/workaround]
+- Arquivos: `[caminhos]`
+- Impacto: [O que quebra ou degrada]
+- Abordagem de correcao: [Como resolver]
+
+## Bugs Conhecidos
+
+**[Descricao do bug]:**
+- Sintomas: [O que acontece]
+- Arquivos: `[caminhos]`
+- Gatilho: [Como reproduzir]
+
+## Consideracoes de Seguranca
+
+**[Area]:**
+- Risco: [O que pode dar errado]
+- Arquivos: `[caminhos]`
+- Mitigacao atual: [O que existe]
+
+## Gargalos de Performance
+
+**[Operacao lenta]:**
+- Problema: [O que e lento]
+- Arquivos: `[caminhos]`
+- Causa: [Por que e lento]
+
+## Areas Frageis
+
+**[Componente/Modulo]:**
+- Arquivos: `[caminhos]`
+- Por que fragil: [O que faz quebrar facilmente]
+- Cobertura de testes: [Lacunas]
+
+## Lacunas de Cobertura de Teste
+
+**[Area nao testada]:**
+- O que nao e testado: [Funcionalidade especifica]
+- Arquivos: `[caminhos]`
+- Risco: [O que pode quebrar sem ser notado]
+- Prioridade: [Alta/Media/Baixa]
+```
+
+</templates>
+
+<forbidden_files>
+**NUNCA leia ou cite conteudo destes arquivos (mesmo que existam):**
+
+- `.env`, `.env.*`, `*.env` - Variaveis de ambiente com segredos
+- `credentials.*`, `secrets.*`, `*secret*`, `*credential*` - Arquivos de credenciais
+- `*.pem`, `*.key`, `*.p12`, `*.pfx`, `*.jks` - Certificados e chaves privadas
+- `id_rsa*`, `id_ed25519*`, `id_dsa*` - Chaves privadas SSH
+- `.npmrc`, `.pypirc`, `.netrc` - Tokens de auth de gerenciadores de pacote
+- `serviceAccountKey.json`, `*-credentials.json` - Credenciais de servicos cloud
+
+**Se encontrar estes arquivos:**
+- Note apenas a EXISTENCIA: "Arquivo `.env` presente - contem configuracao de ambiente"
+- NUNCA cite conteudo, mesmo parcialmente
+- NUNCA inclua valores como `API_KEY=...` ou `sk-...` em qualquer output
+
+**Por que importa:** Seu output e commitado no git. Segredos vazados = incidente de seguranca.
+</forbidden_files>
+
+<critical_rules>
+
+**ESCREVA DOCUMENTOS DIRETAMENTE.** Nao retorne descobertas ao orquestrador. O objetivo e reduzir transferencia de contexto.
+
+**SEMPRE INCLUA CAMINHOS DE ARQUIVO.** Toda descoberta precisa de caminho com backticks. Sem excecoes.
+
+**USE OS TEMPLATES.** Preencha a estrutura do template. Nao invente seu proprio formato.
+
+**SEJA MINUCIOSO.** Explore profundamente. Leia arquivos reais. Nao adivinhe. **Mas respeite <forbidden_files>.**
+
+**RETORNE APENAS CONFIRMACAO.** Sua resposta deve ter ~10 linhas max. Apenas confirme o que foi escrito.
+
+**NAO FACA COMMIT.** O orquestrador lida com operacoes git.
+
+</critical_rules>

package/bin/install.js

@@ -507,6 +507,49 @@ function uninstall(targetDir, runtime) {
     }
   }
 
+  // Remove UP hooks
+  const hooksDir = path.join(targetDir, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    for (const file of fs.readdirSync(hooksDir)) {
+      if (file.startsWith('up-') && file.endsWith('.js')) {
+        fs.unlinkSync(path.join(hooksDir, file));
+        removed++;
+      }
+    }
+    console.log(`  ${green}✓${reset} Removed UP hooks`);
+  }
+
+  // Clean settings.json references
+  if (runtime === 'claude') {
+    const settingsPath = path.join(targetDir, 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        let changed = false;
+
+        if (settings.statusLine && settings.statusLine.command && settings.statusLine.command.includes('up-statusline')) {
+          delete settings.statusLine;
+          changed = true;
+        }
+
+        if (settings.hooks && settings.hooks.PostToolUse) {
+          settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry => {
+            const hooks = entry.hooks || [];
+            return !hooks.some(h => h.command && h.command.includes('up-context-monitor'));
+          });
+          if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+          if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+          changed = true;
+        }
+
+        if (changed) {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+          console.log(`  ${green}✓${reset} Cleaned settings.json`);
+        }
+      } catch (e) {}
+    }
+  }
+
   if (removed === 0) {
     console.log(`  ${dim}Nothing to remove — UP is not installed here.${reset}`);
   } else {
@@ -600,12 +643,84 @@ function install(isGlobal, runtime) {
     }
   }
 
-  // 4. Write VERSION file
+  // 4. Install hooks (Claude Code only)
+  if (runtime === 'claude') {
+    const hooksSrc = path.join(packageRoot, 'hooks');
+    if (fs.existsSync(hooksSrc)) {
+      const hooksDest = path.join(targetDir, 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+
+      // Remove old UP hooks
+      if (fs.existsSync(hooksDest)) {
+        for (const file of fs.readdirSync(hooksDest)) {
+          if (file.startsWith('up-') && file.endsWith('.js')) {
+            fs.unlinkSync(path.join(hooksDest, file));
+          }
+        }
+      }
+
+      // Copy new UP hooks
+      let hookCount = 0;
+      for (const file of fs.readdirSync(hooksSrc)) {
+        if (file.endsWith('.js')) {
+          fs.copyFileSync(path.join(hooksSrc, file), path.join(hooksDest, file));
+          hookCount++;
+        }
+      }
+
+      if (hookCount > 0) {
+        console.log(`  ${green}✓${reset} Installed ${hookCount} hooks`);
+      }
+
+      // Configure statusLine and hooks in settings.json
+      const settingsPath = path.join(targetDir, 'settings.json');
+      let settings = {};
+      if (fs.existsSync(settingsPath)) {
+        try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (e) {}
+      }
+
+      const statuslineCmd = `node "${path.join(hooksDest, 'up-statusline.js')}"`;
+      const contextMonitorCmd = `node "${path.join(hooksDest, 'up-context-monitor.js')}"`;
+
+      // Set statusLine
+      settings.statusLine = { type: 'command', command: statuslineCmd };
+
+      // Set PostToolUse hook for context monitor
+      if (!settings.hooks) settings.hooks = {};
+      const postToolHooks = settings.hooks.PostToolUse || [];
+      // Remove old GSD/UP context monitor entries
+      const filtered = postToolHooks.filter(entry => {
+        const hooks = entry.hooks || [];
+        return !hooks.some(h => h.command && (h.command.includes('gsd-context-monitor') || h.command.includes('up-context-monitor')));
+      });
+      filtered.push({ hooks: [{ type: 'command', command: contextMonitorCmd }] });
+      settings.hooks.PostToolUse = filtered;
+
+      // Remove old GSD SessionStart hook if present
+      if (settings.hooks.SessionStart) {
+        settings.hooks.SessionStart = settings.hooks.SessionStart.filter(entry => {
+          const hooks = entry.hooks || [];
+          return !hooks.some(h => h.command && h.command.includes('gsd-'));
+        });
+        if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+      }
+
+      // Clean old GSD statusLine reference
+      if (settings.statusLine && settings.statusLine.command && settings.statusLine.command.includes('gsd-statusline')) {
+        settings.statusLine = { type: 'command', command: statuslineCmd };
+      }
+
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      console.log(`  ${green}✓${reset} Configured statusLine and context monitor`);
+    }
+  }
+
+  // 5. Write VERSION file
   const versionDest = path.join(upDest, 'VERSION');
   fs.writeFileSync(versionDest, VERSION);
   console.log(`  ${green}✓${reset} Wrote VERSION (${VERSION})`);
 
-  // 5. Write package.json for CommonJS mode (prevents ESM conflicts)
+  // 6. Write package.json for CommonJS mode (prevents ESM conflicts)
   if (runtime !== 'opencode') {
     const pkgDest = path.join(targetDir, 'package.json');
     if (!fs.existsSync(pkgDest)) {

package/bin/up-tools.cjs

@@ -3,7 +3,7 @@
 /**
  * UP Tools — CLI utility for UP workflow operations
  *
- * Simplified version of GSD Tools. Single file (+ core.cjs).
+ * UP Tools — Single file CLI (+ core.cjs).
  *
  * Usage: node up-tools.cjs <command> [args] [--raw] [--cwd <path>]
  *

package/commands/ajuda.md

@@ -28,6 +28,7 @@ Sistema de desenvolvimento orientado a fases para projetos de software.
 | Comando | Descricao | Uso |
 |---------|-----------|-----|
 | `/up:novo-projeto` | Inicializar novo projeto com coleta de contexto | `/up:novo-projeto` |
+| `/up:mapear-codigo` | Analisar codebase existente com agentes paralelos | `/up:mapear-codigo` |
 | `/up:retomar` | Restaurar contexto da sessao anterior | `/up:retomar` |
 
 ### Ciclo de Fase
@@ -87,6 +88,13 @@ Sistema de desenvolvimento orientado a fases para projetos de software.
 
 ## Fluxos de Trabalho Comuns
 
+### Projeto com Codigo Existente (brownfield)
+```
+/up:mapear-codigo
+/up:novo-projeto
+/up:discutir-fase 1
+```
+
 ### Novo Projeto (do zero)
 ```
 /up:novo-projeto

package/commands/mapear-codigo.md

@@ -0,0 +1,63 @@
+---
+name: up:mapear-codigo
+description: Analisar codebase existente com agentes mapeadores paralelos
+argument-hint: "[opcional: area especifica, ex: 'api' ou 'auth']"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - Task
+---
+
+<objective>
+Analyze existing codebase using parallel up-mapeador-codigo agents to produce structured codebase documents.
+
+Each mapper agent explores a focus area and **writes documents directly** to `.plano/codebase/`. The orchestrator only receives confirmations, keeping context usage minimal.
+
+Output: .plano/codebase/ folder with 7 structured documents about the codebase state.
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/mapear-codigo.md
+@~/.claude/up/references/ui-brand.md
+</execution_context>
+
+<context>
+Focus area: $ARGUMENTS (optional - if provided, tells agents to focus on specific subsystem)
+
+**Load project state if exists:**
+Check for .plano/STATE.md - loads context if project already initialized
+
+**This command can run:**
+- Before /up:novo-projeto (brownfield codebases) - creates codebase map first
+- After /up:novo-projeto (greenfield codebases) - updates codebase map as code evolves
+- Anytime to refresh codebase understanding
+</context>
+
+<when_to_use>
+**Use mapear-codigo for:**
+- Projetos brownfield antes da inicializacao (entender codigo existente primeiro)
+- Atualizar mapa do codebase apos mudancas significativas
+- Onboarding em codebase desconhecido
+- Antes de refatoracao grande (entender estado atual)
+
+**Skip mapear-codigo for:**
+- Projetos greenfield sem codigo ainda (nada para mapear)
+- Codebases triviais (<5 arquivos)
+</when_to_use>
+
+<process>
+1. Check if .plano/codebase/ already exists (offer to refresh or skip)
+2. Create .plano/codebase/ directory structure
+3. Spawn 4 parallel up-mapeador-codigo agents:
+   - Agent 1: tech focus -> writes STACK.md, INTEGRATIONS.md
+   - Agent 2: arch focus -> writes ARCHITECTURE.md, STRUCTURE.md
+   - Agent 3: quality focus -> writes CONVENTIONS.md, TESTING.md
+   - Agent 4: concerns focus -> writes CONCERNS.md
+4. Wait for agents to complete, collect confirmations (NOT document contents)
+5. Verify all 7 documents exist with line counts
+6. Commit codebase map
+7. Offer next steps (typically: /up:novo-projeto or /up:planejar-fase)
+</process>

package/hooks/up-context-monitor.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Context Monitor - PostToolUse hook
+// Reads context metrics from the statusline bridge file and injects
+// warnings when context usage is high.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const WARNING_THRESHOLD = 35;
+const CRITICAL_THRESHOLD = 25;
+const STALE_SECONDS = 60;
+const DEBOUNCE_CALLS = 5;
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const sessionId = data.session_id;
+
+    if (!sessionId) {
+      process.exit(0);
+    }
+
+    const tmpDir = os.tmpdir();
+    const metricsPath = path.join(tmpDir, `claude-ctx-${sessionId}.json`);
+
+    if (!fs.existsSync(metricsPath)) {
+      process.exit(0);
+    }
+
+    const metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+    const now = Math.floor(Date.now() / 1000);
+
+    if (metrics.timestamp && (now - metrics.timestamp) > STALE_SECONDS) {
+      process.exit(0);
+    }
+
+    const remaining = metrics.remaining_percentage;
+    const usedPct = metrics.used_pct;
+
+    if (remaining > WARNING_THRESHOLD) {
+      process.exit(0);
+    }
+
+    // Debounce
+    const warnPath = path.join(tmpDir, `claude-ctx-${sessionId}-warned.json`);
+    let warnData = { callsSinceWarn: 0, lastLevel: null };
+    let firstWarn = true;
+
+    if (fs.existsSync(warnPath)) {
+      try {
+        warnData = JSON.parse(fs.readFileSync(warnPath, 'utf8'));
+        firstWarn = false;
+      } catch (e) {}
+    }
+
+    warnData.callsSinceWarn = (warnData.callsSinceWarn || 0) + 1;
+
+    const isCritical = remaining <= CRITICAL_THRESHOLD;
+    const currentLevel = isCritical ? 'critical' : 'warning';
+
+    const severityEscalated = currentLevel === 'critical' && warnData.lastLevel === 'warning';
+    if (!firstWarn && warnData.callsSinceWarn < DEBOUNCE_CALLS && !severityEscalated) {
+      fs.writeFileSync(warnPath, JSON.stringify(warnData));
+      process.exit(0);
+    }
+
+    warnData.callsSinceWarn = 0;
+    warnData.lastLevel = currentLevel;
+    fs.writeFileSync(warnPath, JSON.stringify(warnData));
+
+    // Detect if UP is active (has .plano/STATE.md in working directory)
+    const cwd = data.cwd || process.cwd();
+    const isUpActive = fs.existsSync(path.join(cwd, '.plano', 'STATE.md'));
+
+    let message;
+    if (isCritical) {
+      message = isUpActive
+        ? `CONTEXT CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is nearly exhausted. Do NOT start new complex work or write handoff files -- ' +
+          'UP state is already tracked in STATE.md. Inform the user so they can run ' +
+          '/up:pausar at the next natural stopping point.'
+        : `CONTEXT CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is nearly exhausted. Inform the user that context is low and ask how they ' +
+          'want to proceed. Do NOT autonomously save state or write handoff files unless the user asks.';
+    } else {
+      message = isUpActive
+        ? `CONTEXT WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is getting limited. Avoid starting new complex work. If not between ' +
+          'defined plan steps, inform the user so they can prepare to pause.'
+        : `CONTEXT WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Be aware that context is getting limited. Avoid unnecessary exploration or ' +
+          'starting new complex work.';
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: message
+      }
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch (e) {
+    process.exit(0);
+  }
+});

package/hooks/up-statusline.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Claude Code Statusline - UP Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to usable context)
+    const AUTO_COMPACT_BUFFER_PCT = 16.5;
+    let ctx = '';
+    if (remaining != null) {
+      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
+
+      // Write context metrics to bridge file for the context-monitor hook
+      if (session) {
+        try {
+          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
+          const bridgeData = JSON.stringify({
+            session_id: session,
+            remaining_percentage: remaining,
+            used_pct: used,
+            timestamp: Math.floor(Date.now() / 1000)
+          });
+          fs.writeFileSync(bridgePath, bridgeData);
+        } catch (e) {}
+      }
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+      if (used < 50) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 65) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 80) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude');
+    const todosDir = path.join(claudeDir, 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`\x1b[2m${model}\x1b[0m \u2502 \x1b[1m${task}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`\x1b[2m${model}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"
@@ -11,7 +11,8 @@
     "commands",
     "workflows",
     "templates",
-    "references"
+    "references",
+    "hooks"
   ],
   "keywords": [
     "claude",

package/workflows/mapear-codigo.md

@@ -0,0 +1,258 @@
+<purpose>
+Orquestrar agentes mapeadores de codebase paralelos para analisar codebase e produzir documentos estruturados em .plano/codebase/
+
+Cada agente tem contexto fresco, explora uma area de foco especifica, e **escreve documentos diretamente**. O orquestrador recebe apenas confirmacao + contagem de linhas, depois escreve um resumo.
+
+Output: Pasta .plano/codebase/ com 7 documentos estruturados sobre o estado do codebase.
+</purpose>
+
+<philosophy>
+**Por que agentes mapeadores dedicados:**
+- Contexto fresco por dominio (sem contaminacao de tokens)
+- Agentes escrevem documentos diretamente (sem transferencia de contexto de volta ao orquestrador)
+- Orquestrador apenas resume o que foi criado (uso minimo de contexto)
+- Execucao mais rapida (agentes rodam simultaneamente)
+
+**Qualidade do documento acima de tamanho:**
+Inclua detalhe suficiente para ser util como referencia. Priorize exemplos praticos (especialmente padroes de codigo) sobre brevidade arbitraria.
+
+**Sempre inclua caminhos de arquivo:**
+Documentos sao material de referencia para Claude ao planejar/executar. Sempre inclua caminhos reais com backticks: `src/services/user.ts`.
+</philosophy>
+
+<process>
+
+<step name="check_existing">
+Verifique se .plano/codebase/ ja existe.
+
+```bash
+ls -la .plano/codebase/ 2>/dev/null
+```
+
+**Se existir:**
+
+```
+.plano/codebase/ ja existe com estes documentos:
+[Listar arquivos encontrados]
+
+O que fazer?
+1. Atualizar - Deletar existente e remapear codebase
+2. Pular - Usar mapa existente como esta
+```
+
+Aguardar resposta do usuario.
+
+Se "Atualizar": Deletar .plano/codebase/, continuar para create_structure
+Se "Pular": Encerrar workflow
+
+**Se nao existir:**
+Continuar para create_structure.
+</step>
+
+<step name="create_structure">
+Criar diretorio .plano/codebase/:
+
+```bash
+mkdir -p .plano/codebase
+```
+
+**Arquivos de saida esperados:**
+- STACK.md (do mapeador tech)
+- INTEGRATIONS.md (do mapeador tech)
+- ARCHITECTURE.md (do mapeador arch)
+- STRUCTURE.md (do mapeador arch)
+- CONVENTIONS.md (do mapeador quality)
+- TESTING.md (do mapeador quality)
+- CONCERNS.md (do mapeador concerns)
+
+Continuar para spawn_agents.
+</step>
+
+<step name="spawn_agents">
+Spawnar 4 agentes up-mapeador-codigo paralelos.
+
+Usar ferramenta Agent com `subagent_type="up-mapeador-codigo"` e `run_in_background=true` para execucao paralela.
+
+**CRITICO:** Use o agente dedicado `up-mapeador-codigo`, NAO `Explore`. O agente mapeador escreve documentos diretamente.
+
+**Agente 1: Foco Tech**
+
+```
+Agent(
+  subagent_type="up-mapeador-codigo",
+  run_in_background=true,
+  description="Mapear stack de tecnologia",
+  prompt="Foco: tech
+
+Analise este codebase para stack de tecnologia e integracoes externas.
+
+Escreva estes documentos em .plano/codebase/:
+- STACK.md - Linguagens, runtime, frameworks, dependencias, configuracao
+- INTEGRATIONS.md - APIs externas, bancos de dados, provedores de auth, webhooks
+
+Explore profundamente. Escreva documentos diretamente usando templates. Retorne apenas confirmacao."
+)
+```
+
+**Agente 2: Foco Arquitetura**
+
+```
+Agent(
+  subagent_type="up-mapeador-codigo",
+  run_in_background=true,
+  description="Mapear arquitetura do codebase",
+  prompt="Foco: arch
+
+Analise a arquitetura e estrutura de diretorios deste codebase.
+
+Escreva estes documentos em .plano/codebase/:
+- ARCHITECTURE.md - Padrao, camadas, fluxo de dados, abstracoes, entry points
+- STRUCTURE.md - Layout de diretorios, localizacoes chave, convencoes de nomeacao
+
+Explore profundamente. Escreva documentos diretamente usando templates. Retorne apenas confirmacao."
+)
+```
+
+**Agente 3: Foco Qualidade**
+
+```
+Agent(
+  subagent_type="up-mapeador-codigo",
+  run_in_background=true,
+  description="Mapear convencoes do codebase",
+  prompt="Foco: quality
+
+Analise este codebase para convencoes de codigo e padroes de teste.
+
+Escreva estes documentos em .plano/codebase/:
+- CONVENTIONS.md - Estilo de codigo, nomeacao, padroes, tratamento de erros
+- TESTING.md - Framework, estrutura, mocking, cobertura
+
+Explore profundamente. Escreva documentos diretamente usando templates. Retorne apenas confirmacao."
+)
+```
+
+**Agente 4: Foco Preocupacoes**
+
+```
+Agent(
+  subagent_type="up-mapeador-codigo",
+  run_in_background=true,
+  description="Mapear preocupacoes do codebase",
+  prompt="Foco: concerns
+
+Analise este codebase para divida tecnica, problemas conhecidos e areas de preocupacao.
+
+Escreva este documento em .plano/codebase/:
+- CONCERNS.md - Divida tecnica, bugs, seguranca, performance, areas frageis
+
+Explore profundamente. Escreva documento diretamente usando template. Retorne apenas confirmacao."
+)
+```
+
+Continuar para collect_confirmations.
+</step>
+
+<step name="collect_confirmations">
+Aguardar todos os 4 agentes completarem.
+
+Ler output de cada agente para coletar confirmacoes.
+
+**Formato de confirmacao esperado de cada agente:**
+```
+## Mapeamento Completo
+
+**Foco:** {foco}
+**Documentos escritos:**
+- `.plano/codebase/{DOC1}.md` ({N} linhas)
+- `.plano/codebase/{DOC2}.md` ({N} linhas)
+
+Pronto para resumo do orquestrador.
+```
+
+**O que voce recebe:** Apenas caminhos de arquivo e contagem de linhas. NAO conteudo dos documentos.
+
+Se algum agente falhou, note a falha e continue com documentos bem-sucedidos.
+
+Continuar para verify_output.
+</step>
+
+<step name="verify_output">
+Verificar se todos os documentos foram criados:
+
+```bash
+ls -la .plano/codebase/
+wc -l .plano/codebase/*.md
+```
+
+**Checklist de verificacao:**
+- Todos os 7 documentos existem
+- Nenhum documento vazio (cada um deve ter >20 linhas)
+
+Se documentos faltando ou vazios, note quais agentes podem ter falhado.
+
+Continuar para scan_for_secrets.
+</step>
+
+<step name="scan_for_secrets">
+**CHECAGEM DE SEGURANCA CRITICA:** Escanear arquivos de saida para segredos acidentalmente vazados antes de commitar.
+
+```bash
+grep -E '(sk-[a-zA-Z0-9]{20,}|sk_live_[a-zA-Z0-9]+|sk_test_[a-zA-Z0-9]+|ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9_-]+|AKIA[A-Z0-9]{16}|xox[baprs]-[a-zA-Z0-9-]+|-----BEGIN.*PRIVATE KEY|eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.)' .plano/codebase/*.md 2>/dev/null && SECRETS_FOUND=true || SECRETS_FOUND=false
+```
+
+**Se SECRETS_FOUND=true:**
+Alertar usuario e pausar antes do commit.
+
+**Se SECRETS_FOUND=false:**
+Continuar para commit.
+</step>
+
+<step name="commit_codebase_map">
+Commitar o mapa do codebase:
+
+```bash
+node "$HOME/.claude/up/bin/up-tools.cjs" commit "docs: mapear codebase existente" --files .plano/codebase/*.md
+```
+
+Continuar para offer_next.
+</step>
+
+<step name="offer_next">
+Apresentar resumo de conclusao e proximos passos.
+
+```bash
+wc -l .plano/codebase/*.md
+```
+
+**Formato de saida:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > MAPEAMENTO COMPLETO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Criado .plano/codebase/:
+- STACK.md ([N] linhas) - Tecnologias e dependencias
+- ARCHITECTURE.md ([N] linhas) - Design do sistema e padroes
+- STRUCTURE.md ([N] linhas) - Layout de diretorios e organizacao
+- CONVENTIONS.md ([N] linhas) - Estilo de codigo e padroes
+- TESTING.md ([N] linhas) - Estrutura e praticas de teste
+- INTEGRATIONS.md ([N] linhas) - Servicos externos e APIs
+- CONCERNS.md ([N] linhas) - Divida tecnica e problemas
+
+---
+
+Proximo Passo
+
+Inicializar projeto -- usar contexto do codebase para planejamento
+
+`/up:novo-projeto`
+
+---
+```
+
+Encerrar workflow.
+</step>
+
+</process>