up-cc 0.6.0 → 0.7.0

package/README.md

@@ -35,6 +35,8 @@ Sem UP, voce pede algo ao assistente e torce pra dar certo. Com UP:
 - **Detecta projetos existentes** e adapta o fluxo automaticamente (brownfield)
 - **Modo builder** constroi projetos inteiros autonomamente (briefing → sistema pronto + testado)
 - **UX tester** navega o sistema como usuario real e implementa melhorias automaticamente
+- **Tiered context** (v0.7.0+) reduz consumo de tokens em ~25% via injecao de contexto compacto e slices por fase
+- **Instrumentation** (v0.7.0+) mede custo real por agente: `/up:custos`
 
 ## Instalacao
 

package/agents/up-architecture-supervisor.md

@@ -13,11 +13,15 @@ Supervisiona: `up-product-analyst`, `up-system-designer`, `up-arquiteto`, `up-re
 Apos cada agente arquitetural completar, voce revisa o output contra criterios objetivos.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. `$HOME/.claude/up/references/engineering-principles.md`
-3. `.plano/BRIEFING.md`
-4. `.plano/OWNER.md`
-5. Artefato em avaliacao (PROJECT.md, ROADMAP.md, SYSTEM-DESIGN.md, REQUIREMENTS.md, ou DESIGN-TOKENS.md)
+
+Governance rules e engineering principles vem injetados no prompt do workflow em forma comprimida (~700 tokens vs 4.4k). NAO carregue os arquivos full por padrao.
+
+Leitura obrigatoria do disco:
+1. `.plano/BRIEFING.md`
+2. `.plano/OWNER.md`
+3. Artefato em avaliacao (PROJECT.md, ROADMAP.md, SYSTEM-DESIGN.md, REQUIREMENTS.md, ou DESIGN-TOKENS.md)
+
+Leitura sob demanda: `references/governance-rules.md` ou `references/engineering-principles.md` se precisar de detalhe.
 </role>
 
 <criteria>

package/agents/up-arquiteto.md

@@ -362,6 +362,49 @@ Para cada decisao necessaria:
 **GREENFIELD:** Agrupar requisitos em fases, definir criterios de sucesso.
 **BROWNFIELD:** Adicionar novas fases apos as existentes, mapeando novos requisitos.
 
+### Passo 7.5: Gerar Slices por Fase (TIERED CONTEXT — v0.7.0)
+
+**OBRIGATORIO** apos gerar ROADMAP.md e REQUIREMENTS.md.
+
+Para CADA fase do ROADMAP, criar dois arquivos slice em `.plano/fases/{NN}/`:
+
+**1. `PHASE.md`** — slice do ROADMAP contendo APENAS esta fase
+```markdown
+# Fase {NN}: {Nome}
+
+**Objetivo:** {objetivo da fase}
+**Requisitos cobertos:** REQ-X, REQ-Y, REQ-Z
+**Criterios de sucesso:**
+- [ ] {criterio 1}
+- [ ] {criterio 2}
+
+**Dependencias:** Fases {anteriores}
+**Estimativa:** {planos esperados}
+```
+
+**2. `REQUIREMENTS-SLICE.md`** — slice do REQUIREMENTS contendo APENAS REQs desta fase
+```markdown
+# Requisitos da Fase {NN}
+
+> Slice gerado automaticamente. Versao completa em `.plano/REQUIREMENTS.md`.
+
+## REQ-X: {titulo}
+{descricao + criterios}
+
+## REQ-Y: {titulo}
+{descricao + criterios}
+```
+
+**Por que:** Agentes (planejador, executor, supervisores) carregam apenas a slice da fase atual em vez do REQUIREMENTS/ROADMAP inteiros. Reducao de ~70% no contexto carregado por invocacao.
+
+**Comando para criar:**
+```bash
+mkdir -p .plano/fases/{NN}
+# Escrever PHASE.md e REQUIREMENTS-SLICE.md
+```
+
+**Atualizacao em brownfield:** Se a slice ja existe, atualizar com novos REQs adicionados.
+
 ### Passo 8: Gerar/Atualizar STATE.md + config.json
 
 ### Passo 9: Inicializar Git (se necessario)
@@ -410,6 +453,8 @@ node "$HOME/.claude/up/bin/up-tools.cjs" commit "docs: estruturar feature (modo
 - .plano/ROADMAP.md
 - .plano/STATE.md
 - .plano/config.json
+- .plano/fases/{NN}/PHASE.md (slice do ROADMAP por fase, v0.7.0+)
+- .plano/fases/{NN}/REQUIREMENTS-SLICE.md (slice do REQUIREMENTS por fase, v0.7.0+)
 
 ### Metricas
 - Requisitos: [N] (novos) [+ M existentes preservados, se brownfield]

package/agents/up-audit-supervisor.md

@@ -13,9 +13,19 @@ Supervisiona: `up-auditor-ux`, `up-auditor-performance`, `up-auditor-modernidade
 Garante que auditorias sao completas, criterios corretos, sugestoes acionaveis.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. Relatorio do auditor em avaliacao
-3. References correspondentes (audit-ux.md, audit-performance.md, audit-modernidade.md, production-requirements.md)
+
+Governance rules vem injetado no prompt do workflow em forma comprimida. NAO carregue full por padrao.
+
+Leitura obrigatoria do disco:
+1. Relatorio do auditor em avaliacao
+
+Leitura sob demanda (so se for necessario validar coverage real do auditor):
+- `references/audit-ux.md` (1544 linhas)
+- `references/audit-performance.md` (478 linhas)
+- `references/audit-modernidade.md` (1617 linhas)
+- `references/production-requirements.md`
+
+Estas references SAO grandes — so carregue se precisar fazer cross-check rigoroso. Para validacao normal, basta o relatorio do auditor.
 </role>
 
 <criteria>

package/agents/up-backend-specialist.md

@@ -18,11 +18,18 @@ Voce faz TUDO que o up-executor faz PLUS:
 - Queries otimizadas (sem N+1)
 
 **CRITICO: Engineering Principles**
-Antes de executar qualquer tarefa, carregue e internalize:
-```bash
-cat $HOME/.claude/up/references/engineering-principles.md
-```
-Estes 6 principios governam TODA decisao de implementacao. Em especial: Principio 2 (implementacao correta, nao rapida — queries parametrizadas, validacao real), Principio 3 (conectado ponta a ponta — endpoint funciona ate o frontend), Principio 5 (dados reais desde o primeiro momento). Violar um principio e pior que atrasar uma tarefa.
+
+Os 6 principios sao injetados em forma comprimida no prompt do workflow (~400 tokens vs 2.5k completos):
+1. **Implementacao real** — zero placeholder, zero stub, zero retorno estatico
+2. **Correto, nao rapido** — sem `any`, validacao com lib, queries parametrizadas
+3. **Conectado ponta a ponta** — endpoint → frontend chama → DB persiste
+4. **Consistencia** — seguir patterns existentes do codebase
+5. **Dados reais** — banco com seed desde o primeiro endpoint
+6. **Custo futuro** — escolher solucao que escala
+
+Em especial pra backend: Principio 2 (queries parametrizadas, validacao real), Principio 3 (endpoint funciona ate o frontend), Principio 5 (dados reais desde o primeiro momento).
+
+**Sob demanda apenas:** Se precisa de exemplo detalhado, use Read em `$HOME/.claude/up/references/engineering-principles.md`. Default: NAO carregue.
 
 **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.

package/agents/up-code-reviewer.md

@@ -20,7 +20,9 @@ Se o prompt contem um bloco `<files_to_read>`, voce DEVE usar a ferramenta `Read
 
 ## 1. Production Requirements Compliance
 
-Carregar `$HOME/.claude/up/references/production-requirements.md` e verificar:
+NAO carregue o arquivo full por padrao. Os requisitos abaixo sao a versao essencial — use direto. Se precisar do ID completo de um requisito ou descricao detalhada, ai sim use Read em `$HOME/.claude/up/references/production-requirements.md`.
+
+Verifique:
 
 - [ ] Loading states em TODA operacao assincrona (UIST-01)
 - [ ] Error boundaries no layout raiz e por feature (ERR-01, ERR-02)
@@ -85,7 +87,9 @@ Para cada violacao: anotar arquivo, linha, requisito violado, e sugestao de fix.
 
 ## 7. Engineering Principles Compliance
 
-Carregar `$HOME/.claude/up/references/engineering-principles.md` e verificar:
+Os 6 principios estao listados abaixo direto. NAO carregue o arquivo full por padrao — so se precisar de exemplo detalhado de algum principio especifico (`Read references/engineering-principles.md`).
+
+Verifique:
 
 **Principio 1 — Implementacao real:**
 - [ ] Nenhum handler vazio: `onClick={() => {}}`

package/agents/up-database-specialist.md

@@ -17,11 +17,18 @@ Voce faz TUDO que o up-executor faz PLUS:
 - Queries otimizadas
 
 **CRITICO: Engineering Principles**
-Antes de executar qualquer tarefa, carregue e internalize:
-```bash
-cat $HOME/.claude/up/references/engineering-principles.md
-```
-Estes 6 principios governam TODA decisao de implementacao. Em especial: Principio 2 (schema correto desde o inicio — tipos adequados, constraints, NOT NULL), Principio 5 (seed data real, nao placeholder), Principio 6 (indices e otimizacoes pensando em 10x crescimento). Violar um principio e pior que atrasar uma tarefa.
+
+Os 6 principios sao injetados em forma comprimida no prompt do workflow (~400 tokens vs 2.5k completos):
+1. **Implementacao real** — schema completo, sem placeholder
+2. **Correto, nao rapido** — tipos adequados, constraints, NOT NULL onde faz sentido
+3. **Conectado ponta a ponta** — migration rodada, seed funciona, queries usadas
+4. **Consistencia** — seguir convencoes existentes do schema
+5. **Dados reais** — seed realista, nao apenas placeholders
+6. **Custo futuro** — indices, particionamento, pensando em 10x crescimento
+
+Em especial pra database: Principio 2 (schema correto), Principio 5 (seed real), Principio 6 (otimizacoes desde o inicio).
+
+**Sob demanda apenas:** Use Read em `$HOME/.claude/up/references/engineering-principles.md` se precisar de exemplo. Default: NAO carregue.
 
 **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.

package/agents/up-execution-supervisor.md

@@ -19,13 +19,25 @@ Apos cada execucao, voce revisa o codigo produzido contra:
 Decide APPROVE | REQUEST_CHANGES | ESCALATE.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. `$HOME/.claude/up/references/engineering-principles.md`
-3. `$HOME/.claude/up/references/production-requirements.md`
-4. `$HOME/.claude/up/references/rework-limits.md`
-5. PLAN.md da fase (o que deveria ter sido feito)
-6. SUMMARY.md da execucao (o que o executor diz que fez)
-7. Os arquivos modificados na fase (git diff)
+
+Voce recebe versoes COMPRIMIDAS (~700 tokens vs ~7700 tokens) das references no proprio prompt do workflow:
+- Governance rules (decisoes APPROVE/REQUEST_CHANGES/ESCALATE)
+- Engineering principles (6 principios)
+- Rework limits (max 3 ciclos)
+- Production requirements (categorias UIST/ERR/PERF/FORM/RESP/META/A11Y/SEC/POLISH)
+
+Voce DEVE ler do disco apenas:
+1. PLAN.md da fase (o que deveria ter sido feito)
+2. SUMMARY.md da execucao (o que o executor diz que fez)
+3. Os arquivos modificados na fase (`git diff` ou Read direto)
+
+**Leitura sob demanda (so se decisao precisa de detalhe):**
+- `$HOME/.claude/up/references/engineering-principles.md` — exemplos completos dos 6 principios
+- `$HOME/.claude/up/references/governance-rules.md` — hierarquia completa, poderes por nivel
+- `$HOME/.claude/up/references/rework-limits.md` — fluxos de ciclo completos
+- `$HOME/.claude/up/references/production-requirements.md` — IDs e descricao de cada um dos 71 requisitos
+
+Default: NAO carregue references full. Use as versoes comprimidas injetadas no prompt.
 </role>
 
 <criteria>

package/agents/up-executor.md

@@ -11,11 +11,18 @@ Voce e um executor de planos UP. Executa arquivos PLAN.md atomicamente, criando
 Seu trabalho: Executar o plano completamente, fazer commit de cada tarefa, criar SUMMARY.md, atualizar STATE.md.
 
 **CRITICO: Engineering Principles**
-Antes de executar qualquer tarefa, carregue e internalize:
-```bash
-cat $HOME/.claude/up/references/engineering-principles.md
-```
-Estes 6 principios governam TODA decisao de implementacao. Em caso de duvida entre a abordagem rapida e a correta, SEMPRE escolha a correta. Violar um principio e pior que atrasar uma tarefa.
+
+Os 6 principios sao injetados em forma comprimida no prompt do workflow (~400 tokens vs 2.5k completos):
+1. **Implementacao real, nao simulacao** — zero placeholder, zero stub
+2. **Correto, nao rapido** — sempre a versao certa, nunca o atalho
+3. **Conectado ponta a ponta** — usuario consegue usar de verdade
+4. **Consistencia sobre criatividade** — seguir patterns existentes
+5. **Dados reais** desde o primeiro momento
+6. **Custo futuro** — escolher a solucao que escala
+
+Em caso de duvida entre rapido e correto, SEMPRE escolha o correto.
+
+**Sob demanda apenas:** Se precisa de exemplo detalhado, use Read em `$HOME/.claude/up/references/engineering-principles.md`. Default: NAO carregue.
 
 **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.

package/agents/up-frontend-specialist.md

@@ -17,11 +17,18 @@ Voce faz TUDO que o up-executor faz (commits atomicos, SUMMARY.md, state updates
 - Performance (lazy loading, memo, code splitting)
 
 **CRITICO: Engineering Principles**
-Antes de executar qualquer tarefa, carregue e internalize:
-```bash
-cat $HOME/.claude/up/references/engineering-principles.md
-```
-Estes 6 principios governam TODA decisao de implementacao. Em especial: Principio 1 (implementacao real, nao placeholder), Principio 4 (consistencia com design system), Principio 5 (dados reais, nao mock). Violar um principio e pior que atrasar uma tarefa.
+
+Os 6 principios sao injetados em forma comprimida no prompt do workflow (~400 tokens vs 2.5k completos):
+1. **Implementacao real** — zero placeholder, zero `onClick={() => {}}`, zero stub
+2. **Correto, nao rapido** — sem `any`, validacao com lib, queries parametrizadas
+3. **Conectado ponta a ponta** — componente → rota → API → DB com dados fluindo
+4. **Consistencia** — `grep` por pattern existente antes de inventar novo
+5. **Dados reais** — banco com seed, nao hardcode
+6. **Custo futuro** — escolher solucao que escala
+
+Em especial pra frontend: Principio 1 (real), Principio 4 (consistencia com design system), Principio 5 (dados reais, nao mock).
+
+**Sob demanda apenas:** Se precisa de exemplo detalhado de algum principio, use Read em `$HOME/.claude/up/references/engineering-principles.md`. Default: NAO carregue.
 
 **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.

package/agents/up-operations-supervisor.md

@@ -13,9 +13,13 @@ Supervisiona: `up-devops-agent`, `up-technical-writer`.
 Garante que o projeto tem tudo que precisa pra ir pra producao: Dockerfile, CI/CD, env vars, docs.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. `$HOME/.claude/up/references/production-requirements.md`
-3. Arquivos gerados pelo agente (Dockerfile, CI/CD, README, etc.)
+
+Governance rules + production requirements vem injetados no prompt do workflow em forma comprimida (~550 tokens vs 3.2k). NAO carregue os arquivos full por padrao.
+
+Leitura obrigatoria do disco:
+1. Arquivos gerados pelo agente (Dockerfile, CI/CD, README, etc.)
+
+Leitura sob demanda: `references/production-requirements.md` se precisar de IDs especificos da categoria SEC ou DEPLOY.
 </role>
 
 <criteria>

package/agents/up-planning-supervisor.md

@@ -18,13 +18,18 @@ Voce NAO cria planos. Voce AVALIA planos contra criterios objetivos.
 Voce e **critico por design**. Seu trabalho NAO e aprovar rapido — e garantir que o plano e bom o suficiente pro executor implementar sem precisar inferir.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. `$HOME/.claude/up/references/engineering-principles.md`
-3. `$HOME/.claude/up/references/rework-limits.md`
-4. `.plano/REQUIREMENTS.md`
-5. `.plano/SYSTEM-DESIGN.md`
-6. `.plano/CHECKLIST.md`
-7. O(s) PLAN.md em analise (passados no prompt)
+
+Versoes COMPRIMIDAS de governance/engineering/rework sao injetadas no proprio prompt do workflow (~700 tokens vs 7700). NAO carregue os arquivos full por padrao.
+
+Leitura obrigatoria do disco:
+1. O(s) PLAN.md em analise (passados no prompt)
+2. `.plano/CHECKLIST.md` (estado dos planos)
+3. Apenas a SECAO relevante de REQUIREMENTS/SYSTEM-DESIGN — use `.plano/fases/{N}/REQUIREMENTS-SLICE.md` se existir, senao Read seletivo
+
+Leitura sob demanda (so se decisao precisa de detalhe):
+- `references/engineering-principles.md` — exemplos completos
+- `references/governance-rules.md` — hierarquia detalhada
+- `references/rework-limits.md` — fluxos por ciclo
 </role>
 
 <criteria>

package/agents/up-product-supervisor.md

@@ -13,10 +13,15 @@ Supervisiona: `up-product-analyst`, `up-pesquisador-projeto`, `up-pesquisador-me
 Garante que pesquisas sao rigorosas e relevantes pro briefing.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. `.plano/BRIEFING.md`
-3. `.plano/OWNER.md`
-4. Outputs do agente em avaliacao
+
+Governance rules vem injetado no prompt do workflow em forma comprimida (~250 tokens vs 1.9k). NAO carregue o arquivo full por padrao.
+
+Leitura obrigatoria do disco:
+1. `.plano/BRIEFING.md`
+2. `.plano/OWNER.md`
+3. Outputs do agente em avaliacao
+
+Leitura sob demanda: `references/governance-rules.md` se precisar de hierarquia detalhada.
 </role>
 
 <criteria>

package/agents/up-quality-supervisor.md

@@ -13,12 +13,17 @@ Supervisiona: `up-visual-critic`, `up-exhaustive-tester`, `up-api-tester`, `up-q
 Seu trabalho: consolidar os relatorios dos detectores, validar severidade das issues, e aprovar ou pedir re-deteccao.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. VISUAL-REPORT.md
-3. EXHAUSTIVE-REPORT.md
-4. API-REPORT.md
-5. QA-REPORT.md (se rodou)
-6. `.plano/DESIGN-TOKENS.md`
+
+Governance rules vem injetado no prompt do workflow em forma comprimida. NAO carregue o arquivo full por padrao.
+
+Leitura obrigatoria do disco:
+1. VISUAL-REPORT.md
+2. EXHAUSTIVE-REPORT.md
+3. API-REPORT.md
+4. QA-REPORT.md (se rodou)
+5. `.plano/DESIGN-TOKENS.md`
+
+Leitura sob demanda: `references/governance-rules.md` se precisar de detalhe.
 </role>
 
 <criteria>

package/agents/up-verification-supervisor.md

@@ -13,12 +13,17 @@ Supervisiona: `up-verificador`, `up-blind-validator`.
 Seu trabalho NAO e verificar o codigo — e verificar se a VERIFICACAO foi feita corretamente.
 
 **CRITICO: Leitura Inicial Obrigatoria**
-1. `$HOME/.claude/up/references/governance-rules.md`
-2. VERIFICATION.md (output do verificador)
-3. BLIND-VALIDATION.md (se rodou)
-4. E2E-RESULTS.md (se rodou)
-5. DCRV reports (se rodaram)
-6. REQUIREMENTS.md (para cross-check)
+
+Governance rules vem injetado no prompt do workflow em forma comprimida. NAO carregue o arquivo full por padrao.
+
+Leitura obrigatoria do disco:
+1. VERIFICATION.md (output do verificador)
+2. BLIND-VALIDATION.md (se rodou)
+3. E2E-RESULTS.md (se rodou)
+4. DCRV reports (se rodaram)
+5. REQUIREMENTS.md — preferir slice da fase: `.plano/fases/{N}/REQUIREMENTS-SLICE.md` se existir
+
+Leitura sob demanda: `references/governance-rules.md` se precisar de detalhe.
 </role>
 
 <criteria>

package/bin/up-instrument.cjs

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+/**
+ * UP Instrumentation — measures token usage per UP agent
+ *
+ * Reads Claude Code session.jsonl + subagent jsonls and produces a token cost
+ * report grouped by agent. Used to identify the heaviest agents (so we know
+ * where to apply tiered context optimizations) and to give users visibility
+ * into the cost of a build.
+ *
+ * Usage:
+ *   node up-instrument.cjs report                # current project, current session
+ *   node up-instrument.cjs report --all-sessions # current project, all sessions
+ *   node up-instrument.cjs report --json         # JSON output
+ *   node up-instrument.cjs watch                 # write .plano/INSTRUMENTATION.md continuously
+ *
+ * Opt-in via /up:configurar (instrumentation.enabled = true).
+ * Default: off.
+ *
+ * NOTE: Only works with Claude Code runtime (reads ~/.claude/projects).
+ *       OpenCode and Gemini CLI use different log formats — falls back gracefully.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
+
+// Convert /home/projects/up-cc → -home-projects-up-cc
+function projectKey(cwd) {
+  return cwd.replace(/^\//, '').replace(/\//g, '-').replace(/^/, '-');
+}
+
+function listSessions(projectDir) {
+  if (!fs.existsSync(projectDir)) return [];
+  return fs
+    .readdirSync(projectDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => path.join(projectDir, d.name));
+}
+
+function listJsonls(sessionDir) {
+  const files = [];
+  const walk = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith('.jsonl')) files.push(full);
+    }
+  };
+  walk(sessionDir);
+  return files;
+}
+
+function parseJsonl(file) {
+  const events = [];
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return events;
+  }
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      // skip malformed
+    }
+  }
+  return events;
+}
+
+// Build canonical list of UP agent names from agents/ directory.
+// This gives us ground truth and avoids false matches like "up-hover" or "up-load".
+function loadUpAgentNames() {
+  const candidates = [
+    path.join(__dirname, '..', 'agents'),
+    path.join(__dirname, '..', 'up', 'agents'),
+    path.join(HOME, '.claude', 'up', 'agents'),
+    path.join(HOME, '.claude', 'agents'),
+  ];
+  const names = new Set();
+  for (const dir of candidates) {
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) {
+      if (f.startsWith('up-') && f.endsWith('.md')) {
+        names.add(f.replace(/\.md$/, ''));
+      }
+    }
+  }
+  return names;
+}
+
+const KNOWN_UP_AGENTS = loadUpAgentNames();
+
+// Extract agent name from a subagent jsonl path or first event.
+// Subagent files live in <session>/subagents/agent-<id>.jsonl.
+function detectAgentName(events, file) {
+  // Strategy 1: scan events for known UP agent names in content
+  for (const ev of events.slice(0, 5)) {
+    const c = ev?.message?.content;
+    let text = '';
+    if (typeof c === 'string') text = c;
+    else if (Array.isArray(c)) {
+      text = c
+        .map((item) => (typeof item === 'string' ? item : item?.text || ''))
+        .join(' ');
+    }
+    if (!text) continue;
+
+    // Match against canonical UP agent names
+    for (const name of KNOWN_UP_AGENTS) {
+      if (text.includes(name)) return name;
+    }
+
+    // Match "Voce e o {something}" pattern from UP role definitions
+    const roleMatch = text.match(/Voce e o ([A-Z][a-zA-Z ]+?)( UP|\.|,|\n)/);
+    if (roleMatch) {
+      const role = roleMatch[1].trim().toLowerCase().replace(/\s+/g, '-');
+      const candidate = `up-${role}`;
+      if (KNOWN_UP_AGENTS.has(candidate)) return candidate;
+    }
+  }
+
+  // Strategy 2: top-level fields
+  for (const ev of events.slice(0, 3)) {
+    if (ev?.subagent_type && ev.subagent_type.startsWith('up-')) {
+      return ev.subagent_type;
+    }
+    if (ev?.slug && ev.slug.startsWith('up-') && KNOWN_UP_AGENTS.has(ev.slug)) {
+      return ev.slug;
+    }
+  }
+
+  // Strategy 3: file id fallback (grouped under "non-up" so we don't pollute UP stats)
+  const m = file.match(/agent-([a-z0-9]+)\.jsonl$/);
+  return m ? `non-up-agent` : 'unknown';
+}
+
+function aggregateUsage(events) {
+  let input = 0;
+  let cacheCreation = 0;
+  let cacheRead = 0;
+  let output = 0;
+  let calls = 0;
+  for (const ev of events) {
+    const u = ev?.message?.usage || ev?.usage;
+    if (!u) continue;
+    input += u.input_tokens || 0;
+    cacheCreation += u.cache_creation_input_tokens || 0;
+    cacheRead += u.cache_read_input_tokens || 0;
+    output += u.output_tokens || 0;
+    calls += 1;
+  }
+  return { input, cacheCreation, cacheRead, output, calls };
+}
+
+// Opus 4.6 1M pricing (rough): input $15/M, output $75/M, cache write $18.75/M, cache read $1.50/M
+function estimateCost(usage) {
+  const PRICE = {
+    input: 15 / 1_000_000,
+    cacheCreation: 18.75 / 1_000_000,
+    cacheRead: 1.5 / 1_000_000,
+    output: 75 / 1_000_000,
+  };
+  return (
+    usage.input * PRICE.input +
+    usage.cacheCreation * PRICE.cacheCreation +
+    usage.cacheRead * PRICE.cacheRead +
+    usage.output * PRICE.output
+  );
+}
+
+function formatNumber(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(2) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + 'k';
+  return String(n);
+}
+
+function buildReport(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const projectDir = path.join(CLAUDE_PROJECTS, projectKey(cwd));
+  const sessions = listSessions(projectDir);
+  if (sessions.length === 0) {
+    return { error: 'no_sessions', message: `No Claude Code sessions found for ${cwd}. Are you running in Claude Code runtime?` };
+  }
+
+  const targetSessions = opts.allSessions ? sessions : [sessions[sessions.length - 1]];
+  const byAgent = new Map();
+  const filesScanned = [];
+
+  for (const sessionDir of targetSessions) {
+    const subagentDir = path.join(sessionDir, 'subagents');
+    const files = listJsonls(subagentDir);
+    for (const file of files) {
+      filesScanned.push(file);
+      const events = parseJsonl(file);
+      const name = detectAgentName(events, file);
+      const usage = aggregateUsage(events);
+      const prev = byAgent.get(name) || { input: 0, cacheCreation: 0, cacheRead: 0, output: 0, calls: 0, invocations: 0 };
+      prev.input += usage.input;
+      prev.cacheCreation += usage.cacheCreation;
+      prev.cacheRead += usage.cacheRead;
+      prev.output += usage.output;
+      prev.calls += usage.calls;
+      prev.invocations += 1;
+      byAgent.set(name, prev);
+    }
+  }
+
+  const rows = [];
+  let totalCost = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  for (const [agent, u] of byAgent.entries()) {
+    const cost = estimateCost(u);
+    totalCost += cost;
+    totalInput += u.input + u.cacheCreation + u.cacheRead;
+    totalOutput += u.output;
+    rows.push({
+      agent,
+      invocations: u.invocations,
+      input: u.input + u.cacheCreation + u.cacheRead,
+      output: u.output,
+      cost,
+      avgPerInvoc: u.invocations > 0 ? (u.input + u.cacheCreation + u.cacheRead) / u.invocations : 0,
+    });
+  }
+  rows.sort((a, b) => b.cost - a.cost);
+
+  return {
+    cwd,
+    sessions: targetSessions.length,
+    files_scanned: filesScanned.length,
+    total_input_tokens: totalInput,
+    total_output_tokens: totalOutput,
+    total_cost_usd: totalCost,
+    agents: rows,
+  };
+}
+
+function renderMarkdown(report) {
+  if (report.error) return `# Instrumentation\n\n${report.message}\n`;
+  const lines = [];
+  lines.push('# Token Instrumentation');
+  lines.push('');
+  lines.push(`Project: \`${report.cwd}\``);
+  lines.push(`Sessions analyzed: ${report.sessions}`);
+  lines.push(`Subagent files scanned: ${report.files_scanned}`);
+  lines.push('');
+  lines.push('## Totals');
+  lines.push(`- Input tokens: **${formatNumber(report.total_input_tokens)}**`);
+  lines.push(`- Output tokens: **${formatNumber(report.total_output_tokens)}**`);
+  lines.push(`- Estimated cost (Opus 4.6 pricing): **$${report.total_cost_usd.toFixed(2)}**`);
+  lines.push('');
+  lines.push('## Top agents by cost');
+  lines.push('');
+  lines.push('| Agent | Invocations | Input | Avg/invoc | Output | Cost |');
+  lines.push('|---|---:|---:|---:|---:|---:|');
+  for (const row of report.agents.slice(0, 20)) {
+    lines.push(
+      `| ${row.agent} | ${row.invocations} | ${formatNumber(row.input)} | ${formatNumber(row.avgPerInvoc)} | ${formatNumber(row.output)} | $${row.cost.toFixed(2)} |`
+    );
+  }
+  lines.push('');
+  lines.push(`> Generated by \`up-instrument\` at ${new Date().toISOString()}`);
+  lines.push('> Pricing assumes Claude Opus 4.6 1M context. Real cost may vary.');
+  return lines.join('\n') + '\n';
+}
+
+function renderTable(report) {
+  if (report.error) return report.message;
+  const lines = [];
+  lines.push(`Project: ${report.cwd}`);
+  lines.push(`Sessions: ${report.sessions}  Files: ${report.files_scanned}`);
+  lines.push(`Total: ${formatNumber(report.total_input_tokens)} in / ${formatNumber(report.total_output_tokens)} out / $${report.total_cost_usd.toFixed(2)}`);
+  lines.push('');
+  lines.push('Top agents:');
+  for (const row of report.agents.slice(0, 15)) {
+    const pad = (s, n) => String(s).padEnd(n);
+    lines.push(`  ${pad(row.agent, 30)} ${pad(row.invocations + 'x', 6)} ${pad(formatNumber(row.input), 8)} avg ${pad(formatNumber(row.avgPerInvoc), 8)} $${row.cost.toFixed(2)}`);
+  }
+  return lines.join('\n');
+}
+
+// CLI
+const args = process.argv.slice(2);
+const cmd = args[0] || 'report';
+const opts = {
+  allSessions: args.includes('--all-sessions'),
+  json: args.includes('--json'),
+  cwd: process.cwd(),
+};
+
+if (cmd === 'report') {
+  const report = buildReport(opts);
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(renderTable(report));
+  }
+} else if (cmd === 'write') {
+  const report = buildReport(opts);
+  const planoDir = path.join(opts.cwd, '.plano');
+  if (!fs.existsSync(planoDir)) {
+    console.error('No .plano directory found in current cwd. Run from a UP project root.');
+    process.exit(1);
+  }
+  const outFile = path.join(planoDir, 'INSTRUMENTATION.md');
+  fs.writeFileSync(outFile, renderMarkdown(report));
+  console.log(`Wrote ${outFile}`);
+} else if (cmd === '--help' || cmd === 'help') {
+  console.log(`up-instrument — token usage measurement for UP agents
+
+Commands:
+  report                Print top agents by cost (default, current session)
+  report --all-sessions Same but across all sessions for current project
+  report --json         JSON output
+  write                 Write .plano/INSTRUMENTATION.md (current session)
+  write --all-sessions  Write report across all sessions
+
+Notes:
+  - Only works with Claude Code (reads ~/.claude/projects/<key>/subagents/*.jsonl)
+  - OpenCode and Gemini CLI use different log formats and are not supported yet
+  - Pricing assumes Claude Opus 4.6 1M context — real cost may vary`);
+} else {
+  console.error(`Unknown command: ${cmd}. Try 'help'.`);
+  process.exit(1);
+}

package/commands/custos.md

@@ -0,0 +1,67 @@
+---
+name: up:custos
+description: Mostra estimativa de custo em tokens dos agentes UP usados no projeto atual (Claude Code only)
+allowed-tools:
+  - Bash
+  - Read
+---
+
+<objective>
+Reportar custo estimado de tokens consumidos por agentes UP no projeto atual.
+Usa `bin/up-instrument.cjs` para parsear `~/.claude/projects/<key>/subagents/*.jsonl`
+e agregar uso por agente.
+</objective>
+
+<process>
+
+## 1. Detectar runtime
+
+```bash
+if [ ! -d "$HOME/.claude/projects" ]; then
+  echo "Instrumentation requer Claude Code runtime."
+  echo "OpenCode e Gemini CLI usam formatos de log diferentes (nao suportado ainda)."
+  exit 0
+fi
+```
+
+## 2. Rodar relatorio
+
+```bash
+# Default: sessao mais recente
+node "$HOME/.claude/up/bin/up-instrument.cjs" report
+
+# Se quiser todas as sessoes do projeto:
+# node "$HOME/.claude/up/bin/up-instrument.cjs" report --all-sessions
+
+# Se quiser JSON:
+# node "$HOME/.claude/up/bin/up-instrument.cjs" report --json
+```
+
+## 3. Salvar em .plano/INSTRUMENTATION.md (opcional)
+
+Se a flag `--save` foi passada OU se .plano/ existe:
+
+```bash
+if [ -d ".plano" ]; then
+  node "$HOME/.claude/up/bin/up-instrument.cjs" write
+  echo ""
+  echo "Relatorio salvo em .plano/INSTRUMENTATION.md"
+fi
+```
+
+## 4. Apresentar interpretacao
+
+Apos mostrar a tabela, comentar:
+
+- **Top 3 agentes mais caros** — onde focar otimizacao
+- **Total estimado** — em USD assumindo Opus 4.6 pricing
+- **Comparacao com outras sessoes** se historico disponivel
+
+</process>
+
+<notes>
+- Pricing assume Opus 4.6 1M context: input $15/M, output $75/M, cache write $18.75/M, cache read $1.50/M
+- Custos reais podem variar conforme modelo selecionado no /model
+- Apenas funciona em Claude Code — OpenCode e Gemini CLI nao expoe usage por subagent ainda
+- Detecta agentes UP cruzando contra a lista canonica em `agents/up-*.md`
+</notes>

package/package.json

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

package/references/engineering-principles-compressed.md

@@ -0,0 +1,26 @@
+# Engineering Principles (compressed)
+
+> Versao compactada para injecao inline em prompts. ~400 tokens vs 2.5k da versao completa.
+> Versao completa em `engineering-principles.md` — Read sob demanda se precisar de exemplos detalhados.
+
+## 6 Principios
+
+1. **Implementacao real, nao simulacao** — Zero `onClick={() => {}}`, zero placeholder, zero API que retorna `{ok: true}` estatico, zero `useState([])` sem setter, zero imports nao usados. Se nao pode implementar agora: declare explicitamente como debito tecnico.
+
+2. **Correto, nao rapido** — Tipagem explicita (sem `any`). Validacao com lib (zod/yup). Queries parametrizadas. `===` nao `==`. `crypto.randomUUID()` nao `Math.random()`. `structuredClone` nao `Object.assign` raso.
+
+3. **Conectado de ponta a ponta** — Componente → rota navegavel. API → frontend chama + trata response. Schema → migration rodada. Validacao → form aplica + feedback visivel. "Arquivo existe" ≠ "funciona". Usuario consegue usar no browser.
+
+4. **Consistencia sobre criatividade** — Antes de implementar: `grep` por pattern similar no codebase. Se React Query existe, use `useQuery`. Se Button component existe, use `<Button>`. Se Tailwind, use classes. Nao invente patterns paralelos.
+
+5. **Dados reais desde o primeiro momento** — Banco real com seed > API real > mock temporario removido > hardcoded (PROIBIDO). Se banco existe, conecte desde o primeiro componente. Mock so em testes automatizados.
+
+6. **Cada decisao tem custo futuro** — Sem tipagem = bugs silenciosos. Sem pagination = trava com 10k items. Sem error handling = crash cego. Sem indices = queries lentas. Custo de fazer certo e linear, refatorar e exponencial.
+
+## Aplicacao
+
+- Antes de cada tarefa: reler mentalmente os 6
+- Durante: checar cada decisao contra a lista
+- Antes de commit: self-review rapido
+- No SUMMARY: documentar violacoes como debito tecnico
+- Para exemplos detalhados: `Read references/engineering-principles.md`

package/references/governance-rules-compressed.md

@@ -0,0 +1,31 @@
+# Governance Rules (compressed)
+
+> Versao compactada para injecao inline. ~250 tokens vs 1.9k da versao completa.
+> Versao completa em `governance-rules.md` — Read sob demanda para hierarquia detalhada.
+
+## Hierarquia
+DONO → CEO → 5 Chiefs → 8 Supervisores → 36 Operacionais
+
+## Decisoes do Supervisor (apos cada operacional)
+- **APPROVE** — criterios atendidos, sem issues criticas, evidencia clara
+- **REQUEST_CHANGES** — 1+ criterio falhou, feedback especifico e acionavel
+- **ESCALATE** — fora do escopo, decisao arquitetural ou conflito → chief
+
+## Decisoes do Chief (apos area completa)
+- APPROVE | REQUEST_CHANGES (volta pro supervisor) | ESCALATE pro CEO
+
+## Decisoes do CEO (antes de delivery)
+- APPROVE_DELIVERY | ALERTA_DONO | REWORK (volta pro chief)
+
+## Anti-patterns (NUNCA aprovar se)
+- Trabalho nao foi de fato verificado ("parece ok")
+- Evidencia faltando ou ambigua
+- SUMMARY claim sem backing no codigo
+- Rework cycle no max sem melhoria
+- Stub/placeholder em vez de implementacao real
+- Falta de wiring (componente criado mas nao conectado)
+
+## Logging obrigatorio
+Toda decisao em `.plano/governance/approvals.log | reworks.log | escalations.log`.
+
+Para detalhes de poderes especificos por nivel: `Read references/governance-rules.md`

package/references/production-requirements-compressed.md

@@ -0,0 +1,23 @@
+# Production Requirements (compressed)
+
+> Versao compactada para injecao inline. ~300 tokens vs 1.3k da versao completa.
+> Versao completa em `production-requirements.md` — Read sob demanda para checklist completo (60+ itens).
+
+## Categorias e contagem (cada item tem ID)
+- **UIST** (8) — UI States: loading/error/empty/success, disabled, optimistic, confirm destrutivo
+- **ERR** (8) — Error handling: boundaries, try/catch, sessao expirada, 404, offline, server-side validation
+- **PERF** (9) — Performance: lazy loading, code split, debounce, pagination, cache, memo, prefetch
+- **FORM** (8) — Forms: inline validation, mensagens especificas, autofocus, tab order, defaults, mascaras
+- **RESP** (7) — Responsividade: 375px funcional, touch 44x44, hamburger mobile, modais fullscreen
+- **META** (7) — Meta/SEO: title unico, og tags, favicon, manifest, canonical, robots
+- **A11Y** (9) — Acessibilidade: alt, labels, focus visible, keyboard, aria, contraste 4.5:1, landmarks
+- **SEC** (8) — Seguranca: rotas protegidas, CSRF, XSS, rate limit, headers, UUID, env vars, RLS
+- **POLISH** (7) — Visual: hover, transicoes 150-300ms, escala espacamento, design tokens, dark mode
+
+## Total: 71 requisitos de producao em 9 categorias
+
+Quando precisar de IDs especificos ou descricao detalhada de um item:
+`Read references/production-requirements.md` e procure pela categoria.
+
+Arquiteto/system-designer injetam estes requisitos automaticamente no REQUIREMENTS.md.
+Supervisores validam contra eles antes de approval.

package/references/rework-limits-compressed.md

@@ -0,0 +1,22 @@
+# Rework Limits (compressed)
+
+> Versao compactada para injecao inline. ~150 tokens vs 2k da versao completa.
+> Versao completa em `rework-limits.md` — Read sob demanda para fluxos detalhados.
+
+## Limites por nivel
+| Nivel | Max Ciclos | Apos limite |
+|---|---|---|
+| Operacional ← Supervisor | **3** | Forca approval, marca como debito tecnico |
+| Supervisor ← Chief | **2** | Escalacao pro CEO |
+| Chief ← CEO | **1** | CEO decide: aceitar ou alertar dono |
+
+## Quando forcar aprovacao (apos max ciclos)
+- Melhoria entre ciclos < 10% (diminishing returns)
+- Issue nao pode ser resolvida sem info externa
+- Acao: registrar em `governance/technical-debt.log`, marcar item como `completed_with_debt`
+
+## Rework rate saudavel: 15-30%
+- < 5% = supervisor mal calibrado, aprovando sem criterio
+- > 40% = prompt vago ou criterios muito rigidos
+
+Para fluxos completos por ciclo: `Read references/rework-limits.md`

package/workflows/build.md

@@ -181,12 +181,47 @@ Agent(
   prompt=f"""
     Executar Plano da Fase {phase_number}.
     
+    <engineering_principles_compressed>
+    1. Implementacao real, nao simulacao (zero placeholder, zero stub)
+    2. Correto, nao rapido (sem `any`, validacao com lib, queries parametrizadas)
+    3. Conectado ponta a ponta (componente → API → DB com dados fluindo)
+    4. Consistencia (grep por pattern existente antes de inventar)
+    5. Dados reais desde o primeiro momento (sem hardcode)
+    6. Cada decisao tem custo futuro (escolher solucao escalavel)
+    
+    Em duvida entre rapido e correto: sempre o correto.
+    Sob demanda: Read references/engineering-principles.md para exemplos.
+    </engineering_principles_compressed>
+    
+    <production_requirements_compressed>
+    Categorias a respeitar (71 requisitos no total):
+    - UIST (UI States): loading/error/empty/success em TODA operacao async
+    - ERR (Error handling): boundaries, try/catch, sessao expirada, 404
+    - PERF: lazy loading, code split, debounce, pagination > 20 items, cache
+    - FORM: validacao inline, mensagens especificas, autofocus, mascaras
+    - RESP: 375px funcional, touch 44x44, hamburger mobile
+    - A11Y: alt, labels, focus visible, keyboard, contraste 4.5:1
+    - SEC: rotas protegidas, CSRF, XSS, rate limit, env vars, RLS
+    - POLISH: hover, transicoes 150-300ms, design tokens
+    
+    Sob demanda: Read references/production-requirements.md para IDs especificos.
+    </production_requirements_compressed>
+    
     <files_to_read>
+    TIER 1 — Sempre:
     - {PLAN}
-    - .plano/PROJECT.md
-    - .plano/SYSTEM-DESIGN.md
-    - $HOME/.claude/up/references/engineering-principles.md
-    - $HOME/.claude/up/references/production-requirements.md
+    - .plano/STATE.md
+    - ./CLAUDE.md (se existir)
+    
+    TIER 2 — Se a slice da fase existe (v0.7.0+):
+    - .plano/fases/{phase_number}/PHASE.md (objetivo da fase)
+    - .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (REQs APENAS desta fase)
+    - .plano/DESIGN-TOKENS.md (se for frontend e existir)
+    
+    TIER 3 — Sob demanda apenas:
+    - .plano/PROJECT.md (so se precisar visao geral)
+    - .plano/SYSTEM-DESIGN.md (so se decisao de arquitetura aparecer)
+    - .plano/REQUIREMENTS.md (so se a slice nao tiver info suficiente)
     </files_to_read>
     
     Implementar todas as tarefas. Commitar atomicamente.
@@ -203,10 +238,33 @@ Agent(
   prompt=f"""
     Revisar execucao da Fase {phase_number}.
     
+    <governance_compressed>
+    DECISOES: APPROVE | REQUEST_CHANGES | REQUEST_REPLAN | ESCALATE
+    REWORK: max 3 ciclos antes de forcar approval com debito
+    NUNCA APROVAR: trabalho nao verificado, evidencia ambigua, claim sem backing,
+                   stub/placeholder, falta de wiring
+    </governance_compressed>
+    
+    <engineering_principles_compressed>
+    1. Implementacao real (zero placeholder)
+    2. Correto, nao rapido
+    3. Conectado ponta a ponta
+    4. Consistencia (seguir patterns existentes)
+    5. Dados reais
+    6. Custo futuro
+    </engineering_principles_compressed>
+    
     <files_to_read>
     - {PLAN}
     - {PHASE_DIR}/*-SUMMARY.md
-    - git diff
+    - git diff (use Bash)
+    - .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (se existir)
+    
+    Sob demanda apenas:
+    - $HOME/.claude/up/references/engineering-principles.md (exemplos)
+    - $HOME/.claude/up/references/governance-rules.md (hierarquia)
+    - $HOME/.claude/up/references/rework-limits.md (fluxos)
+    - $HOME/.claude/up/references/production-requirements.md (IDs especificos)
     </files_to_read>
     
     Decisao: APPROVE | REQUEST_CHANGES | REQUEST_REPLAN | ESCALATE

package/workflows/governance.md

@@ -32,17 +32,39 @@ Spawnar o supervisor:
 ```python
 Agent(
   subagent_type="up-{supervisor_name}",
-  model="opus",
   prompt="""
     Revisar output de {operacional_name} para {context}.
     
+    <governance_compressed>
+    DECISOES:
+    - APPROVE — criterios atendidos, sem issues criticas, evidencia clara
+    - REQUEST_CHANGES — 1+ criterio falhou, feedback especifico e acionavel
+    - ESCALATE — fora do escopo, decisao arquitetural ou conflito → chief
+    
+    REWORK LIMITS:
+    - Operacional ← Supervisor: max 3 ciclos, depois forca approval com debito tecnico
+    - Supervisor ← Chief: max 2 ciclos, depois escala pro CEO
+    
+    NUNCA APROVAR SE:
+    - Trabalho nao foi de fato verificado ("parece ok")
+    - Evidencia faltando ou ambigua
+    - SUMMARY claim sem backing no codigo
+    - Stub/placeholder em vez de implementacao real
+    - Falta de wiring (componente criado mas nao conectado)
+    
+    LOG OBRIGATORIO: .plano/governance/approvals.log
+    </governance_compressed>
+    
     <files_to_read>
-    - $HOME/.claude/up/references/governance-rules.md
-    - $HOME/.claude/up/references/rework-limits.md
     - [arquivos do output do operacional]
-    - [arquivos de contexto]
+    - [arquivos de contexto da fase — preferir slices em .plano/fases/{N}/]
     </files_to_read>
     
+    Versoes COMPLETAS (so se decisao precisa de detalhe):
+    - Read $HOME/.claude/up/references/governance-rules.md
+    - Read $HOME/.claude/up/references/rework-limits.md
+    - Read $HOME/.claude/up/references/engineering-principles.md
+    
     Avaliar contra criterios objetivos.
     Retornar: APPROVE | REQUEST_CHANGES | ESCALATE
   """

package/workflows/plan.md

@@ -155,12 +155,24 @@ Agent(
     Sonnet-ready: SEMPRE (default v0.6.0+)
     
     <files_to_read>
+    TIER 1 — Sempre:
     - .plano/STATE.md
-    - .plano/ROADMAP.md
-    - .plano/REQUIREMENTS.md
-    - .plano/SYSTEM-DESIGN.md
-    - .plano/PROJECT.md
-    - .plano/codebase/* (se brownfield)
+    - .plano/fases/{phase_number}/PHASE.md (slice do ROADMAP — v0.7.0+)
+    - .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (REQs APENAS desta fase — v0.7.0+)
+    
+    TIER 2 — Se brownfield apenas:
+    - .plano/codebase/CONVENTIONS.md
+    - .plano/codebase/CONCERNS.md
+    - .plano/codebase/ARCHITECTURE.md
+    
+    TIER 3 — Sob demanda apenas:
+    - .plano/SYSTEM-DESIGN.md (so se decisao arquitetural especifica)
+    - .plano/PROJECT.md (so se precisar visao geral)
+    - .plano/ROADMAP.md (so se precisar entender fases adjacentes)
+    - .plano/REQUIREMENTS.md (so se a slice nao tiver info suficiente)
+    
+    FALLBACK: Se as slices nao existem (projeto pre-v0.7.0), carregar
+    .plano/ROADMAP.md e .plano/REQUIREMENTS.md completos.
     </files_to_read>
     
     REQs da fase: {phase_req_ids}

package/workflows/planejar-fase.md

@@ -94,17 +94,35 @@ Task(
 **Pesquisa inline:** {RESEARCH_INLINE}
 
 <files_to_read>
-- {state_path} (Estado do Projeto)
-- {roadmap_path} (Roteiro)
-- {requirements_path} (Requisitos)
-- {context_path} (DECISOES DO USUARIO de /up:discutir-fase)
-- {research_path} (Pesquisa Tecnica - se existir)
-- {verification_path} (Lacunas de Verificacao - se --gaps)
-- .plano/codebase/CONVENTIONS.md (Convencoes do codebase - se existir, BROWNFIELD)
-- .plano/codebase/CONCERNS.md (Divida tecnica - se existir, BROWNFIELD)
-- .plano/codebase/ARCHITECTURE.md (Arquitetura existente - se existir, BROWNFIELD)
+TIER 1 — Sempre obrigatorio:
+- {state_path} (Estado do Projeto, ~2k tokens)
+- .plano/fases/{phase_number}/PHASE.md (slice do ROADMAP da fase atual, ~500 tokens — v0.7.0+)
+- .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (REQs APENAS desta fase, ~1.5k tokens — v0.7.0+)
+
+TIER 2 — Condicional:
+- {context_path} (DECISOES DO USUARIO de /up:discutir-fase, se existir)
+- {research_path} (Pesquisa Tecnica, se existir)
+- {verification_path} (Lacunas de Verificacao, se --gaps)
+- .plano/codebase/CONVENTIONS.md (BROWNFIELD apenas)
+- .plano/codebase/CONCERNS.md (BROWNFIELD apenas)
+- .plano/codebase/ARCHITECTURE.md (BROWNFIELD apenas)
+
+TIER 3 — Sob demanda (NAO carregue por padrao):
+- {roadmap_path} (ROADMAP completo) — so se precisar entender fases adjacentes
+- {requirements_path} (REQUIREMENTS completo) — so se a slice nao tiver info suficiente
+- {project_path} (PROJECT.md) — so se precisar visao geral
+
+**FALLBACK:** Se as slices `.plano/fases/{phase_number}/` nao existem (projeto pre-v0.7.0), carregue {roadmap_path} e {requirements_path} completos como antes.
 </files_to_read>
 
+**Engineering Principles (compressed) — sempre injetado:**
+1. Implementacao real, nao simulacao (zero placeholder)
+2. Correto, nao rapido (sem `any`, validacao com lib)
+3. Conectado ponta a ponta (componente → API → DB funcionando)
+4. Consistencia sobre criatividade (grep antes de inventar)
+5. Dados reais desde o primeiro momento (sem hardcode)
+6. Cada decisao tem custo futuro (escolher solucao escalavel)
+
 **IDs de requisitos da fase (cada ID DEVE aparecer no campo `requirements` de um plano):** {phase_req_ids}
 
 **Instrucoes do projeto:** Ler ./CLAUDE.md se existir