up-cc 0.1.1 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"

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>