up-cc 0.5.2 → 0.7.0

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/build.md

@@ -0,0 +1,99 @@
+---
+name: up:build
+description: Executar projeto previamente planejado por /up:plan. Requer PLAN-READY.md. Pode rodar em runtime diferente do que planejou.
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - AskUserQuestion
+  - mcp__plugin_playwright_playwright__*
+---
+<objective>
+Executar projeto que foi previamente planejado.
+
+Requer `.plano/PLAN-READY.md` no diretorio atual.
+
+Conduz:
+1. Validacao light do plano (artefatos existem, planos OK)
+2. CEO local confirma execucao
+3. Build de todas as fases (com supervisao completa)
+4. Quality Gate global
+5. Delivery Audit
+6. CEO apresenta resultado
+
+**Caso de uso principal:** executar projeto planejado em outro runtime.
+Exemplo: planejou em Claude Code (`/up:plan "X"`), agora roda em OpenCode (`/up-build`).
+
+**Re-plan local permitido (max 2):** se durante execucao o supervisor descobrir
+que o plano esta inviavel, o planejador LOCAL refaz a fase. Nao volta pro runtime
+que planejou originalmente.
+
+Diferenca de /up:modo-builder:
+- modo-builder: planeja + executa em sequencia
+- build: SO executa, le PLAN-READY.md
+
+Diferenca de /up:executar-fase:
+- executar-fase: executa UMA fase
+- build: executa o PROJETO INTEIRO ate delivery
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/build.md
+@~/.claude/up/workflows/governance.md
+@~/.claude/up/workflows/dcrv.md
+@~/.claude/up/workflows/builder-e2e.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Sem argumentos. O comando le tudo de `.plano/PLAN-READY.md`.
+</context>
+
+<process>
+**GATE 1 — Owner Profile LOCAL:**
+Verificar se `~/.claude/up/owner-profile.md` existe NESTE runtime.
+Se nao: rodar `/up:onboard` primeiro.
+
+**GATE 2 — PLAN-READY.md:**
+```bash
+if [ ! -f .plano/PLAN-READY.md ]; then
+  echo "ERRO: Este projeto nao foi planejado."
+  echo "Use /up:plan primeiro pra planejar."
+  echo "Ou /up:modo-builder pra planejar e executar de uma vez."
+  exit 1
+fi
+```
+
+**GATE 3 — Validacao Light:**
+Spot-check estrutura:
+- Artefatos arquiteturais existem (PROJECT, ROADMAP, REQUIREMENTS, SYSTEM-DESIGN)?
+- Todos planos listados em PLAN-READY.md existem no disco?
+- Frontmatter dos planos e valido?
+
+**Confiar no PLAN-READY.md.** NAO re-rodar planning-supervisor em tudo.
+
+Se algo falta: alertar e oferecer planejamento local OU abortar.
+
+**Sem model routing:** O runtime decide o modelo.
+
+**Execute the build workflow from @~/.claude/up/workflows/build.md end-to-end.**
+
+Estagios:
+1. Validacao light + CEO confirma
+2. Build (loop por fase com supervisao + DCRV + E2E + chief-engineer)
+3. Quality Gate global
+4. Delivery Audit
+5. Delivery (CEO apresenta)
+
+**Re-plan local permitido (max 2 por projeto):**
+Se execution-supervisor pedir REQUEST_REPLAN, o planejador LOCAL refaz a fase.
+Registrar em `.plano/governance/replans.log`.
+
+**A partir do CEO confirmar, ZERO interacao com usuario** (exceto alertas criticos).
+</process>

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/commands/plan.md

@@ -0,0 +1,91 @@
+---
+name: up:plan
+description: Planejamento completo de projeto. Gera PLAN-READY.md pronto pra ser executado por /up:build (mesmo runtime ou outro)
+argument-hint: "[descricao do projeto] [--execution-runtime=runtime] [--no-audit]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebFetch
+  - WebSearch
+  - AskUserQuestion
+  - mcp__context7__*
+---
+<objective>
+Planejar projeto completo. NAO executa nada, so planeja.
+
+Conduz:
+1. Intake (CEO entrevista o dono)
+2. Arquitetura completa (Product Analyst → System Designer → Arquiteto)
+3. Planejamento exaustivo de TODAS as fases (Sonnet-ready)
+4. Planning Audit (calcula confidence score)
+5. Gera PLAN-READY.md (arquivo-flag pra /up:build)
+
+Resultado: projeto pronto pra execucao em qualquer runtime via `/up:build`.
+
+**Caso de uso principal:** planejar em Claude Code (modelo capaz pra arquitetura)
+e executar em OpenCode/Gemini (mais barato pra rodar volume).
+
+Diferenca de /up:modo-builder:
+- modo-builder: planeja + executa em sequencia, mesmo runtime
+- plan: SO planeja, para apos PLAN-READY.md
+
+Diferenca de /up:planejar-fase:
+- planejar-fase: planeja UMA fase (em projeto ja inicializado)
+- plan: planeja TODO o projeto do zero (incluindo intake e arquitetura)
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/plan.md
+@~/.claude/up/workflows/onboarding.md
+@~/.claude/up/workflows/ceo-intake.md
+@~/.claude/up/templates/plan-ready.md
+@~/.claude/up/templates/audit-plan.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+**Flags:**
+- `--execution-runtime=<runtime>` — Informa qual runtime sera usado pra executar.
+  Valores: same | claude-code | opencode | gemini-cli | any
+  Default: same
+- `--no-audit` — Pula Planning Audit (nao recomendado em producao)
+
+O restante e o briefing em texto livre.
+
+Se briefing vazio: CEO pergunta interativamente.
+
+**Deteccao automatica de modo:**
+- Codigo existente → BROWNFIELD
+- Sem codigo → GREENFIELD
+</context>
+
+<process>
+**GATE OBRIGATORIO — Owner Profile:**
+Antes de qualquer coisa, verificar se `~/.claude/up/owner-profile.md` existe.
+Se NAO existir: rodar `/up:onboard` primeiro (workflow onboarding.md).
+Sem profile, o CEO nao pode conduzir intake.
+
+**Sem model routing:** O runtime decide o modelo. NAO especificar `model=` em nenhum spawn.
+
+**Sonnet-ready obrigatorio:** Todos planos devem ser gerados em nivel maximo de detalhe.
+
+**Execute the plan workflow from @~/.claude/up/workflows/plan.md end-to-end.**
+
+Estagios:
+1. Intake (CEO entrevista o dono) — interativo
+2. Arquitetura (greenfield: pesquisa + product/system/architect | brownfield: mapear + product/system/architect)
+3. Planejamento exaustivo (TODAS as fases, planning-supervisor revisa cada uma)
+4. Planning Audit (planning-auditor calcula confidence score)
+5. PLAN-READY.md gerado
+6. CEO apresenta resumo
+
+**A partir do estagio 2, ZERO interacao com usuario.** Toda decisao e tomada autonomamente pelo CEO/chiefs/supervisores.
+
+**NAO executar nada.** Para apos gerar PLAN-READY.md.
+</process>