up-cc 2.0.2 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Spec-driven development for Claude Code, Gemini, OpenCode and OpenAI Codex. Brainstorm-first, GitHub-native, TDD por tipo.",
   "bin": {
     "up-cc": "up/bin/install.js"

package/up/CHANGELOG.md

@@ -4,6 +4,55 @@ Todas as mudancas relevantes do `up-cc` ficam documentadas aqui. O formato segue
 o espirito de [Keep a Changelog](https://keepachangelog.com/) e o versionamento
 e [SemVer](https://semver.org/). v2.0.0 e um **major** (breaking change).
 
+## 2.1.0
+
+> GitHub e a interacao humana viram **eixos separados**. Antes, `--solo` desligava o
+> GitHub (zero worktree/issue/PR) E pulava a cerimonia. Num run autonomo/loop isso fazia
+> o projeto inteiro ir pro `main` sem nenhum artefato GitHub, mesmo com remote conectado.
+> Agora `--solo` NAO desliga o GitHub: e so autonomia. Pra pular o GitHub use `--local`.
+
+### Mudado (atencao: semantica de `--solo`)
+
+- **`--solo` agora MANTEM o GitHub-nativo.** Solo virou "autonomo total": cria
+  worktree + branch + issue + PR e auto-mergeia, SEM menu e SEM gate visual (pra
+  loop/headless onde ninguem aprova). Nao desliga mais o GitHub.
+- **`--local` e o novo escape hatch sem GitHub** (o comportamento que `--solo` tinha
+  ate a 2.0.x): commit atomico na branch atual, zero worktree/issue/PR/rede. `/up:rapido`
+  segue como o atalho nomeado pro mesmo modo.
+- **`--auto`** continua igual: pula so o menu de fim de fase, mantem GitHub, e o gate
+  visual ainda roda se `require_visual_test=true`.
+
+### Adicionado
+
+- **Deteccao de GitHub por `gh` CLI OU MCP do GitHub.** O eixo GitHub liga sempre que
+  ha remote + (`gh` autenticado OU MCP do GitHub conectado). Transporte de issue/PR:
+  `gh` (CLI cria direto), `mcp` (o workflow cria via `mcp__...github__*` e grava de
+  volta), `none` (sem remote -> git local). Worktree/branch/push sao git local e
+  acontecem sempre, offline-ok.
+- **Subcomandos `github record-issue` / `github record-pr`** no `up-tools.cjs` pra
+  gravar no `git-map.json` artefatos criados fora do `.cjs` (ex: via MCP). `record-pr
+  --merged` fecha a fase e limpa worktree+branch.
+- **Flag `--local`** no `/up:build` e `start-phase`/`finish-phase` (`--mode local`).
+- **Config builder grava `github_native: true` explicito** (up-arquiteto, workflows/up),
+  deixando a intencao visivel em run autonomo (antes dependia do default implicito).
+- **Testes red-green** do `github.cjs` em `up/bin/lib/github.test.cjs` (10 casos; repo
+  git temp + remote bare local + seam `UP_FORCE_NO_GH`).
+
+### Corrigido
+
+- **Bug de doc em `workflows/up.md`** que dizia `--solo (default, commit na branch atual)`
+  e descrevia `--pr` como o fluxo GitHub (vocabulario v1). Era a unica fonte que podia
+  induzir um agente autonomo a escolher `--solo` e pular o GitHub. Reescrito pro v2.
+- **`--local` numa fase nao polui mais o `github_native` global** do `git-map.json`
+  (poderia degradar fases nao-local seguintes). `finish-phase auto` passou a consultar
+  o config, nao o flag global do mapa.
+
+### Migracao
+
+- Quem usava `--solo` pra **commit local sem GitHub** deve trocar para `--local`.
+- Quem quer **autonomo mantendo GitHub** (loop/headless): use `--solo` (sem gate visual)
+  ou `--auto` (com gate visual se `require_visual_test=true`).
+
 ## 2.0.0
 
 > Redesign completo do UP. **Breaking change.** Os comandos antigos somem (nao ha

package/up/agents/up-arquiteto.md

@@ -305,11 +305,14 @@ Modo builder ativo. Proxima acao: planejar fase 1.
   "granularity": "standard",
   "parallelization": true,
   "commit_docs": true,
-  "builder_mode": true
+  "builder_mode": true,
+  "github_native": true
 }
 ```
 
-Note: `builder_mode: true` sinaliza que o projeto foi criado em modo autonomo.
+Note: `builder_mode: true` sinaliza que o projeto foi criado em modo autonomo. `github_native: true`
+explicito deixa a intencao gravada no arquivo (o build usa true por default; gravar evita ambiguidade
+em run autonomo/loop). So mude pra `false` se o projeto e local sem GitHub.
 </state_and_config>
 
 <brownfield_mode>

package/up/bin/lib/core.cjs

@@ -114,8 +114,9 @@ function loadConfig(cwd) {
     auto_advance: false,
     instrumentation: { enabled: true },
     budget_ceiling: null,
-    // Fase 4: GitHub-native e o PADRAO. --solo no comando forca github_native=false
-    // so na execucao (o build.md le a flag e roteia para o modo solo, sem persistir).
+    // GitHub-native e o PADRAO. So --local (ou este flag = false) desliga. --solo NAO
+    // desliga: solo = autonomia (sem menu/gate visual), GitHub segue ligado. Transporte
+    // de issue/PR: gh CLI OU MCP do GitHub (worktree/branch sao git local, sempre rodam).
     github_native: true,
     merge_strategy: 'squash',
     // Fim de fase: se a fase tem UI, sobe dev server e exige aprovacao visual ANTES do merge.

package/up/bin/lib/github.cjs

@@ -34,8 +34,13 @@ function getRemoteUrl(cwd) {
   return res.exitCode === 0 ? res.stdout.trim() : null;
 }
 
-/** `gh` instalado E autenticado? */
+/**
+ * `gh` instalado E autenticado?
+ * Seam de teste: UP_FORCE_NO_GH=1 forca indisponivel; UP_FORCE_GH=1 forca disponivel.
+ */
 function ghAvailable(cwd) {
+  if (process.env.UP_FORCE_NO_GH === '1') return false;
+  if (process.env.UP_FORCE_GH === '1') return true;
   try {
     execSync('gh auth status', { cwd, stdio: 'pipe' });
     return true;
@@ -69,12 +74,34 @@ function execGh(cwd, args) {
   }
 }
 
-/** github-native ativo? (config.github_native default true) AND gh+remote disponiveis. */
-function githubMode(cwd, solo) {
-  if (solo) return false;
+/**
+ * EIXO A — queremos artefatos GitHub (worktree/branch sempre; issue/PR se remote)?
+ * Ligado a menos que: `--local`, config.github_native=false, ou sem remote origin.
+ * NAO depende de `gh`: gh-vs-MCP e o transporte (eixo separado), nao o liga/desliga.
+ */
+function gitWantsRemote(cwd, local) {
+  if (local) return false;
   const config = loadConfig(cwd);
   if (config.github_native === false) return false;
-  return ghAvailable(cwd) && gitHasRemote(cwd);
+  return gitHasRemote(cwd);
+}
+
+/**
+ * Transporte pra criar issue/PR remoto: 'gh' | 'mcp' | 'none'.
+ * - 'gh':  gh CLI disponivel -> github.cjs cria direto (deterministico).
+ * - 'mcp': remote existe mas sem gh -> o WORKFLOW (LLM) cria via MCP do GitHub,
+ *          porque um subprocesso Node nao chama tools MCP. github.cjs sinaliza e
+ *          grava de volta via recordIssue/recordPr.
+ * - 'none': sem remote (ou --local / config off) -> git local puro, sem issue/PR.
+ */
+function issueTransport(cwd, local) {
+  if (!gitWantsRemote(cwd, local)) return 'none';
+  return ghAvailable(cwd) ? 'gh' : 'mcp';
+}
+
+/** Compat: github-native "classico" = transporte gh disponivel. */
+function githubMode(cwd, local) {
+  return issueTransport(cwd, local) === 'gh';
 }
 
 // =====================================================================
@@ -189,24 +216,27 @@ function phaseKey(phase) {
 // =====================================================================
 
 /**
- * startPhase({cwd, phase, slug, solo})
- * - Cria branch up/fase-NN-slug e worktree FORA do repo.
- * - Se github_native e gh+remote disponiveis: cria gh issue.
- * - Com --solo: degrada (sem worktree, sem issue) — trabalha na branch atual.
- * - Sem gh/remote: cria worktree+branch local, issue=null (fail-open, nunca crasha).
- * - Escreve .plano/git-map.json. Retorna {branch, worktree, issue, issue_url, mode, warnings}.
+ * startPhase({cwd, phase, slug, local, solo})
+ * EIXO A (GitHub) e EIXO B (interacao) sao SEPARADOS:
+ * - `local=true` (flag --local / config off / /up:rapido): SEM worktree/issue, commit
+ *   na branch atual. E o unico jeito de desligar o GitHub aqui.
+ * - `solo` NAO desliga o GitHub: solo so afeta o gate visual e o merge (no build.md).
+ *   Por isso `solo` e aceito mas ignorado neste passo (compat).
+ * - Caso contrario: cria worktree+branch SEMPRE (git local, offline-ok). Issue conforme
+ *   o transporte: 'gh' cria direto; 'mcp' deixa pro workflow criar via MCP (retorna
+ *   `pending.issue` e mode 'github-mcp'); 'none' (sem remote) so git local.
+ * - Escreve .plano/git-map.json. Retorna {branch, worktree, issue, issue_url, mode, transport, warnings, pending?}.
  */
-function startPhase({ cwd, phase, slug, solo = false }) {
+function startPhase({ cwd, phase, slug, local = false, solo = false }) {
+  void solo; // solo nao desliga GitHub (eixo de interacao, tratado no build.md)
   const warnings = [];
   const key = phaseKey(phase);
   const branch = branchName(phase, slug);
-  const ghOn = githubMode(cwd, solo);
 
   const map = readGitMap(cwd);
-  if (solo) map.github_native = false;
 
-  // --- modo SOLO: nada de worktree/issue, trabalha na branch atual ---
-  if (solo) {
+  // --- LOCAL: nada de worktree/issue, trabalha na branch atual ---
+  if (local) {
     const cur = execGit(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
     const currentBranch = cur.exitCode === 0 ? cur.stdout.trim() : null;
     map.phases[key] = {
@@ -225,22 +255,21 @@ function startPhase({ cwd, phase, slug, solo = false }) {
       worktree: null,
       issue: null,
       issue_url: null,
-      mode: 'solo',
+      mode: 'local',
+      transport: 'none',
       warnings,
     };
   }
 
-  // --- modo GitHub-native ou git-local: criar worktree+branch ---
+  // --- worktree+branch SEMPRE (git local, independe de gh/MCP) ---
   const wt = worktreePath(cwd, phase, slug);
   shieldWorktreeDir(cwd);
 
-  // Worktree e branch existem? (idempotente / recovery)
   const existing = (map.phases[key] && map.phases[key].worktree) || null;
   let worktreeCreated = false;
 
   if (!fs.existsSync(wt)) {
     fs.mkdirSync(path.dirname(wt), { recursive: true });
-    // Branch ja existe? Anexa sem -b. Senao cria com -b.
     const branchExists = execGit(cwd, ['rev-parse', '--verify', '--quiet', branch]).exitCode === 0;
     const wtArgs = branchExists
       ? ['worktree', 'add', wt, branch]
@@ -248,7 +277,6 @@ function startPhase({ cwd, phase, slug, solo = false }) {
     const wtRes = execGit(cwd, wtArgs);
     if (wtRes.exitCode !== 0) {
       warnings.push('worktree_failed: ' + (wtRes.stderr || wtRes.stdout));
-      // FAIL-OPEN: cai pra branch local sem worktree
       const co = execGit(cwd, branchExists ? ['checkout', branch] : ['checkout', '-b', branch]);
       if (co.exitCode !== 0) warnings.push('branch_checkout_failed: ' + (co.stderr || co.stdout));
     } else {
@@ -259,13 +287,16 @@ function startPhase({ cwd, phase, slug, solo = false }) {
   }
   const worktree = worktreeCreated || existing ? wt : null;
 
-  // --- issue (so em github-native) ---
+  // --- issue: depende do transporte (gh | mcp | none) ---
+  const transport = issueTransport(cwd, local);
   let issue = null;
   let issueUrl = null;
-  if (ghOn) {
-    const title = `[fase ${padPhase(phase)}] ${slug || branch}`;
-    const body = buildIssueBody(cwd, phase, slug);
-    const res = execGh(cwd, ['issue', 'create', '--title', title, '--body', body]);
+  let pending = null;
+  const issueTitle = `[fase ${padPhase(phase)}] ${slug || branch}`;
+  const issueBody = buildIssueBody(cwd, phase, slug);
+
+  if (transport === 'gh') {
+    const res = execGh(cwd, ['issue', 'create', '--title', issueTitle, '--body', issueBody]);
     if (res.exitCode === 0) {
       issueUrl = res.stdout.trim().split('\n').pop().trim() || null;
       const m = issueUrl && issueUrl.match(/\/issues\/(\d+)/);
@@ -273,9 +304,13 @@ function startPhase({ cwd, phase, slug, solo = false }) {
     } else {
       warnings.push('issue_create_failed: ' + (res.stderr || res.stdout));
     }
-  } else if (!solo) {
-    if (!ghAvailable(cwd)) warnings.push('gh indisponivel ou nao autenticado: degradando para git local (sem issue/PR)');
-    else if (!gitHasRemote(cwd)) warnings.push('sem remote origin: degradando para git local (sem issue/PR)');
+  } else if (transport === 'mcp') {
+    // Node nao chama MCP: o workflow cria a issue via mcp__...github__issue_write
+    // e grava de volta com `up-tools github record-issue`. Worktree/branch ja existem.
+    pending = { issue: { title: issueTitle, body: issueBody } };
+    warnings.push('gh indisponivel: criar issue via MCP (github-mcp) e gravar com record-issue. worktree/branch ja prontos.');
+  } else {
+    warnings.push('sem remote origin: git local (sem issue/PR).');
   }
 
   map.phases[key] = {
@@ -290,14 +325,10 @@ function startPhase({ cwd, phase, slug, solo = false }) {
   };
   writeGitMap(cwd, map);
 
-  return {
-    branch,
-    worktree,
-    issue,
-    issue_url: issueUrl,
-    mode: ghOn ? 'github' : 'git-local',
-    warnings,
-  };
+  const mode = transport === 'gh' ? 'github' : transport === 'mcp' ? 'github-mcp' : 'git-local';
+  const ret = { branch, worktree, issue, issue_url: issueUrl, mode, transport, warnings };
+  if (pending) ret.pending = pending;
+  return ret;
 }
 
 /** Body da issue: goal + criterios do ROADMAP, se disponiveis. */
@@ -317,12 +348,34 @@ function buildIssueBody(cwd, phase, slug) {
 // finishPhase — solo | menu | auto/pr
 // =====================================================================
 
+/** Remove worktree + branch local (best-effort). Usado por finishPhase e recordPr. */
+function cleanupWorktreeBranch(cwd, worktree, branch, warnings) {
+  if (worktree && fs.existsSync(worktree)) {
+    const rm = execGit(cwd, ['worktree', 'remove', worktree]);
+    if (rm.exitCode !== 0) {
+      const rmF = execGit(cwd, ['worktree', 'remove', '--force', worktree]);
+      if (rmF.exitCode !== 0) warnings.push('worktree_remove_failed: ' + (rmF.stderr || rmF.stdout));
+    }
+    try { if (fs.existsSync(worktree)) fs.rmdirSync(worktree); } catch (e) { /* nao-vazio: ignora */ }
+    try {
+      const parent = path.dirname(worktree);
+      if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) fs.rmdirSync(parent);
+    } catch (e) { /* ignora */ }
+  }
+  if (branch) {
+    execGit(cwd, ['branch', '-D', branch]); // silencioso: gh/merge ja pode ter removido
+  }
+}
+
 /**
  * finishPhase({cwd, phase, mode, strategy})
- * - solo: nao faz nada (ja committado na branch atual). Marca status=done.
+ * - local (alias 'solo'): nao faz nada (ja committado na branch atual). status=done.
  * - menu: imprime as 4 opcoes pro orquestrador perguntar (nao age).
- * - auto (a.k.a. pr): gh pr create (body "Closes #<issue>") -> merge (squash default)
- *   -> cleanup worktree+branch. Sem remote: merge LOCAL da branch na base, cleanup.
+ * - auto (a.k.a. pr): conforme o transporte ('gh' | 'mcp' | 'none'):
+ *     'gh'   -> push + gh pr create (Closes #issue) + merge + cleanup.
+ *     'mcp'  -> push e PARA: retorna action 'needs-mcp-pr' + pr_payload pro workflow
+ *               criar/mergear o PR via MCP e fechar com `record-pr --merged` (que limpa).
+ *     'none' -> merge LOCAL fail-open + cleanup.
  * Atualiza git-map.json. Retorna estado da operacao.
  */
 function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
@@ -332,12 +385,12 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
   const entry = map.phases[key] || {};
   const mergeStrategy = strategy || map.merge_strategy || loadConfig(cwd).merge_strategy || 'squash';
 
-  // --- SOLO: nada a fazer, ja committado ---
-  if (mode === 'solo') {
+  // --- LOCAL / SOLO: nada a fazer, ja committado ---
+  if (mode === 'local' || mode === 'solo') {
     entry.status = 'done';
     map.phases[key] = entry;
     writeGitMap(cwd, map);
-    return { mode: 'solo', action: 'none', status: 'done', warnings };
+    return { mode, action: 'none', status: 'done', warnings };
   }
 
   // --- MENU: imprime as 4 opcoes, nao age ---
@@ -361,7 +414,10 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
   if (mode === 'auto' || mode === 'pr') {
     const branch = entry.branch || branchName(phase, '');
     const worktree = entry.worktree || null;
-    const ghOn = ghAvailable(cwd) && gitHasRemote(cwd) && map.github_native !== false;
+    // mode 'auto' ja significa "quero GitHub": consulta o config (intencao do projeto),
+    // nao o flag global do git-map (que uma fase --local anterior poderia ter mexido).
+    const wants = gitHasRemote(cwd) && loadConfig(cwd).github_native !== false;
+    const transport = wants ? (ghAvailable(cwd) ? 'gh' : 'mcp') : 'none';
 
     // Base de merge (default: branch ativa na main do repo)
     const baseRes = execGit(cwd, ['symbolic-ref', '--short', 'HEAD']);
@@ -370,16 +426,41 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
     let pr = entry.pr || null;
     let prUrl = entry.pr_url || null;
 
-    if (ghOn) {
-      // push da branch (necessario pro PR). Worktree ja tem a branch checada.
+    const issueRef = entry.issue ? `\n\nCloses #${entry.issue}` : '';
+    const prTitle = `Fase ${padPhase(phase)}` + (entry.branch ? `: ${entry.branch.replace(/^up\/fase-\d+-?/, '')}` : '');
+    const prBody = `Entrega da fase ${padPhase(phase)} (UP github-native).${issueRef}`;
+
+    // push da branch (necessario pro PR, gh OU MCP). Worktree tem a branch checada.
+    if (transport === 'gh' || transport === 'mcp') {
       const pushCwd = worktree && fs.existsSync(worktree) ? worktree : cwd;
       const push = execGit(pushCwd, ['push', '-u', 'origin', branch]);
       if (push.exitCode !== 0) warnings.push('push_failed: ' + (push.stderr || push.stdout));
+    }
 
-      // gh pr create (Closes #issue no body)
-      const issueRef = entry.issue ? `\n\nCloses #${entry.issue}` : '';
-      const prTitle = `Fase ${padPhase(phase)}` + (entry.branch ? `: ${entry.branch.replace(/^up\/fase-\d+-?/, '')}` : '');
-      const prBody = `Entrega da fase ${padPhase(phase)} (UP github-native).${issueRef}`;
+    // --- transporte MCP: push feito, PR fica pro workflow (LLM) via MCP ---
+    if (transport === 'mcp') {
+      map.phases[key] = entry; // status segue in_progress ate record-pr
+      writeGitMap(cwd, map);
+      return {
+        mode,
+        action: 'needs-mcp-pr',
+        transport: 'mcp',
+        pr_payload: {
+          base,
+          head: branch,
+          title: prTitle,
+          body: prBody,
+          issue: entry.issue || null,
+          strategy: mergeStrategy,
+          worktree,
+        },
+        branch,
+        status: entry.status || 'in_progress',
+        warnings,
+      };
+    }
+
+    if (transport === 'gh') {
       const create = execGh(cwd, ['pr', 'create', '--base', base, '--head', branch, '--title', prTitle, '--body', prBody]);
       if (create.exitCode === 0) {
         prUrl = create.stdout.trim().split('\n').pop().trim() || null;
@@ -389,7 +470,6 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
         warnings.push('pr_create_failed: ' + (create.stderr || create.stdout));
       }
 
-      // merge via gh
       const stratFlag = mergeStrategy === 'merge' ? '--merge' : mergeStrategy === 'rebase' ? '--rebase' : '--squash';
       const mergeTarget = pr ? String(pr) : branch;
       const merge = execGh(cwd, ['pr', 'merge', mergeTarget, stratFlag, '--delete-branch']);
@@ -401,7 +481,6 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
     } else {
       // FAIL-OPEN: merge LOCAL (sem remote/gh)
       warnings.push('sem gh/remote: merge local da branch ' + branch + ' em ' + base);
-      // Garante base checada no repo principal
       const co = execGit(cwd, ['checkout', base]);
       if (co.exitCode !== 0) warnings.push('checkout_base_failed: ' + (co.stderr || co.stdout));
       const stratArgs = mergeStrategy === 'squash'
@@ -421,35 +500,19 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
       }
     }
 
-    // cleanup: remove worktree e branch local
-    if (worktree && fs.existsSync(worktree)) {
-      const rm = execGit(cwd, ['worktree', 'remove', worktree]);
-      if (rm.exitCode !== 0) {
-        const rmF = execGit(cwd, ['worktree', 'remove', '--force', worktree]);
-        if (rmF.exitCode !== 0) warnings.push('worktree_remove_failed: ' + (rmF.stderr || rmF.stdout));
-      }
-      // best-effort: remove a casca vazia que git deixa, e o dir-pai .up-worktrees/<repo> se vazio
-      try { if (fs.existsSync(worktree)) fs.rmdirSync(worktree); } catch (e) { /* nao-vazio: ignora */ }
-      try {
-        const parent = path.dirname(worktree);
-        if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) fs.rmdirSync(parent);
-      } catch (e) { /* ignora */ }
-    }
-    // remove branch local (se ainda existir e nao for a branch ativa)
-    const delBranch = execGit(cwd, ['branch', '-D', branch]);
-    if (delBranch.exitCode !== 0 && !/not found|não encontrad/i.test(delBranch.stderr)) {
-      // silencioso: gh --delete-branch ja pode ter removido
-    }
+    cleanupWorktreeBranch(cwd, worktree, branch, warnings);
 
     entry.pr = pr;
     entry.pr_url = prUrl;
-    if (!entry.status || entry.status === 'in_progress') entry.status = ghOn ? 'merged' : entry.status;
+    entry.worktree = null;
+    if (!entry.status || entry.status === 'in_progress') entry.status = transport === 'gh' ? 'merged' : entry.status;
     map.phases[key] = entry;
     writeGitMap(cwd, map);
 
     return {
-      mode: mode,
+      mode,
       action: 'merged',
+      transport,
       pr,
       pr_url: prUrl,
       branch,
@@ -459,10 +522,47 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
     };
   }
 
-  warnings.push('modo desconhecido: ' + mode + ' (use solo|menu|auto)');
+  warnings.push('modo desconhecido: ' + mode + ' (use local|menu|auto)');
   return { mode, action: 'noop', warnings };
 }
 
+// =====================================================================
+// recordIssue / recordPr — gravam artefatos criados FORA (via MCP no workflow)
+// =====================================================================
+
+/** Grava no git-map a issue criada externamente (ex: via MCP). */
+function recordIssue({ cwd, phase, issue, url }) {
+  const key = phaseKey(phase);
+  const map = readGitMap(cwd);
+  const entry = map.phases[key] || {};
+  if (issue != null && issue !== '') entry.issue = parseInt(issue, 10);
+  if (url) entry.issue_url = url;
+  map.phases[key] = entry;
+  writeGitMap(cwd, map);
+  return { recorded: true, phase: key, issue: entry.issue ?? null, issue_url: entry.issue_url || null };
+}
+
+/**
+ * Grava no git-map o PR criado externamente (ex: via MCP).
+ * Com `merged=true`: marca status=merged e limpa worktree+branch local.
+ */
+function recordPr({ cwd, phase, pr, url, merged = false }) {
+  const warnings = [];
+  const key = phaseKey(phase);
+  const map = readGitMap(cwd);
+  const entry = map.phases[key] || {};
+  if (pr != null && pr !== '') entry.pr = parseInt(pr, 10);
+  if (url) entry.pr_url = url;
+  if (merged) {
+    entry.status = 'merged';
+    cleanupWorktreeBranch(cwd, entry.worktree, entry.branch, warnings);
+    entry.worktree = null;
+  }
+  map.phases[key] = entry;
+  writeGitMap(cwd, map);
+  return { recorded: true, phase: key, pr: entry.pr ?? null, pr_url: entry.pr_url || null, status: entry.status || null, merged: !!merged, warnings };
+}
+
 // =====================================================================
 // status — mostra git-map.json
 // =====================================================================
@@ -470,12 +570,16 @@ function finishPhase({ cwd, phase, mode = 'menu', strategy }) {
 /** status({cwd}) — retorna o git-map.json atual (ou defaults se nao existir). Nunca crasha. */
 function status({ cwd }) {
   const map = readGitMap(cwd);
+  const hasRemote = gitHasRemote(cwd);
+  const ghOk = ghAvailable(cwd);
   return {
     github_native: map.github_native,
     merge_strategy: map.merge_strategy,
-    gh_available: ghAvailable(cwd),
-    has_remote: gitHasRemote(cwd),
+    gh_available: ghOk,
+    has_remote: hasRemote,
     remote: getRemoteUrl(cwd),
+    // transporte efetivo pra issue/PR: 'gh' | 'mcp' | 'none' (assumindo nao-local)
+    transport: hasRemote && map.github_native !== false ? (ghOk ? 'gh' : 'mcp') : 'none',
     phases: map.phases,
   };
 }
@@ -483,13 +587,18 @@ function status({ cwd }) {
 module.exports = {
   startPhase,
   finishPhase,
+  recordIssue,
+  recordPr,
   status,
   // helpers expostos para teste/reuso
   branchName,
   worktreePath,
   gitHasRemote,
   ghAvailable,
+  gitWantsRemote,
+  issueTransport,
   githubMode,
+  cleanupWorktreeBranch,
   readGitMap,
   writeGitMap,
 };

package/up/bin/lib/github.test.cjs

@@ -0,0 +1,161 @@
+/**
+ * github.test.cjs — testes red-green do github.cjs (eixo GitHub vs interacao).
+ * Roda: node up/bin/lib/github.test.cjs
+ * Sem framework. Cria repos git temporarios. Usa remote bare local (push sem rede)
+ * e o seam UP_FORCE_NO_GH=1 pra simular "sem gh CLI, so MCP".
+ */
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const gh = require('./github.cjs');
+
+process.env.GIT_TERMINAL_PROMPT = '0';
+
+function sh(cmd, cwd) { execSync(cmd, { cwd, stdio: 'pipe' }); }
+
+/** Cria repo git temp. withRemote=true adiciona origin = bare repo local. */
+function mkRepo(withRemote) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'up-gh-'));
+  sh('git init -q', dir);
+  sh('git config user.email t@t.co', dir);
+  sh('git config user.name t', dir);
+  sh('git config commit.gpgsign false', dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), '# t\n');
+  sh('git add -A', dir);
+  sh('git commit -qm init', dir);
+  sh('git branch -M main', dir);
+  fs.mkdirSync(path.join(dir, '.plano'), { recursive: true });
+  let bare = null;
+  if (withRemote) {
+    bare = fs.mkdtempSync(path.join(os.tmpdir(), 'up-gh-bare-'));
+    sh('git init -q --bare', bare);
+    sh(`git remote add origin ${bare}`, dir);
+  }
+  return { dir, bare };
+}
+
+let pass = 0, fail = 0;
+function t(name, fn) {
+  try { fn(); console.log('  ok  -', name); pass++; }
+  catch (e) { console.error('  FAIL -', name, '\n     ', e.message); fail++; }
+}
+
+// 1. local=true -> sem worktree/issue, branch atual, mode local
+t('local: sem worktree/issue, branch atual', () => {
+  const { dir } = mkRepo(false);
+  const r = gh.startPhase({ cwd: dir, phase: 1, slug: 'x', local: true });
+  assert.strictEqual(r.worktree, null);
+  assert.strictEqual(r.issue, null);
+  assert.strictEqual(r.mode, 'local');
+  assert.strictEqual(r.transport, 'none');
+  assert.strictEqual(r.branch, 'main');
+});
+
+// 2. sem remote, nao-local -> worktree criado, git-local, sem issue
+t('sem remote: worktree criado, git-local', () => {
+  const { dir } = mkRepo(false);
+  const r = gh.startPhase({ cwd: dir, phase: 2, slug: 'feat' });
+  assert.ok(r.worktree && fs.existsSync(r.worktree), 'worktree deve existir');
+  assert.strictEqual(r.mode, 'git-local');
+  assert.strictEqual(r.transport, 'none');
+  assert.strictEqual(r.issue, null);
+  assert.strictEqual(r.branch, 'up/fase-02-feat');
+});
+
+// 3. remote + sem gh -> github-mcp, worktree criado, pending.issue, transport mcp
+t('remote sem gh: github-mcp pendente', () => {
+  const { dir } = mkRepo(true);
+  process.env.UP_FORCE_NO_GH = '1';
+  try {
+    const r = gh.startPhase({ cwd: dir, phase: 3, slug: 'mcp' });
+    assert.strictEqual(r.transport, 'mcp');
+    assert.strictEqual(r.mode, 'github-mcp');
+    assert.ok(r.worktree && fs.existsSync(r.worktree), 'worktree deve existir mesmo sem gh');
+    assert.strictEqual(r.issue, null);
+    assert.ok(r.pending && r.pending.issue && r.pending.issue.title, 'deve trazer pending.issue.title');
+  } finally { delete process.env.UP_FORCE_NO_GH; }
+});
+
+// 4. REGRESSAO do bug: solo NAO desliga github
+t('solo nao desliga github (vira github-mcp, nao local)', () => {
+  const { dir } = mkRepo(true);
+  process.env.UP_FORCE_NO_GH = '1';
+  try {
+    const r = gh.startPhase({ cwd: dir, phase: 4, slug: 's', solo: true });
+    assert.notStrictEqual(r.mode, 'local');
+    assert.ok(r.worktree && fs.existsSync(r.worktree), 'solo deve criar worktree');
+    assert.strictEqual(r.transport, 'mcp');
+  } finally { delete process.env.UP_FORCE_NO_GH; }
+});
+
+// 5. recordIssue grava no git-map
+t('recordIssue grava issue no git-map', () => {
+  const { dir } = mkRepo(true);
+  process.env.UP_FORCE_NO_GH = '1';
+  try {
+    gh.startPhase({ cwd: dir, phase: 5, slug: 'r' });
+    const r = gh.recordIssue({ cwd: dir, phase: 5, issue: 42, url: 'https://github.com/x/y/issues/42' });
+    assert.strictEqual(r.issue, 42);
+    const map = gh.readGitMap(dir);
+    assert.strictEqual(map.phases['5'].issue, 42);
+    assert.strictEqual(map.phases['5'].issue_url, 'https://github.com/x/y/issues/42');
+  } finally { delete process.env.UP_FORCE_NO_GH; }
+});
+
+// 6. issueTransport puro
+t('issueTransport: local->none; sem remote->none', () => {
+  const { dir } = mkRepo(false);
+  assert.strictEqual(gh.issueTransport(dir, true), 'none');
+  assert.strictEqual(gh.issueTransport(dir, false), 'none');
+});
+
+// 7. finish mode local -> noop, done
+t('finish local: noop status done', () => {
+  const { dir } = mkRepo(false);
+  gh.startPhase({ cwd: dir, phase: 7, slug: 'l', local: true });
+  const r = gh.finishPhase({ cwd: dir, phase: 7, mode: 'local' });
+  assert.strictEqual(r.status, 'done');
+});
+
+// 8. finish auto sem remote -> merge local fail-open
+t('finish auto sem remote: merge local', () => {
+  const { dir } = mkRepo(false);
+  const s = gh.startPhase({ cwd: dir, phase: 8, slug: 'm' });
+  fs.writeFileSync(path.join(s.worktree, 'f.txt'), 'x');
+  sh('git add -A', s.worktree);
+  sh('git commit -qm w', s.worktree);
+  const r = gh.finishPhase({ cwd: dir, phase: 8, mode: 'auto' });
+  assert.strictEqual(r.status, 'merged');
+});
+
+// 9. finish auto, remote sem gh -> needs-mcp-pr + payload (push pro bare local funciona)
+t('finish auto remote sem gh: sinaliza needs-mcp-pr', () => {
+  const { dir } = mkRepo(true);
+  const s = gh.startPhase({ cwd: dir, phase: 9, slug: 'p' });
+  fs.writeFileSync(path.join(s.worktree, 'f.txt'), 'x');
+  sh('git add -A', s.worktree);
+  sh('git commit -qm w', s.worktree);
+  process.env.UP_FORCE_NO_GH = '1';
+  try {
+    const r = gh.finishPhase({ cwd: dir, phase: 9, mode: 'auto' });
+    assert.strictEqual(r.action, 'needs-mcp-pr');
+    assert.ok(r.pr_payload && r.pr_payload.head, 'deve trazer pr_payload.head');
+    assert.strictEqual(r.pr_payload.head, 'up/fase-09-p');
+  } finally { delete process.env.UP_FORCE_NO_GH; }
+});
+
+// 10. recordPr --merged grava pr e limpa worktree
+t('recordPr merged: grava pr, status merged, limpa worktree', () => {
+  const { dir } = mkRepo(true);
+  const s = gh.startPhase({ cwd: dir, phase: 10, slug: 'pr' });
+  const wt = s.worktree;
+  const r = gh.recordPr({ cwd: dir, phase: 10, pr: 7, url: 'https://github.com/x/y/pull/7', merged: true });
+  assert.strictEqual(r.pr, 7);
+  assert.strictEqual(r.status, 'merged');
+  assert.ok(!fs.existsSync(wt), 'worktree deve ter sido removida');
+});
+
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail ? 1 : 0);

package/up/bin/up-tools.cjs

@@ -352,11 +352,14 @@ function main() {
       if (sub === 'start-phase') {
         const phase = getFlag('--phase');
         const slug = getFlag('--slug');
-        if (!phase) error('Usage: github start-phase --phase N --slug S [--solo]');
+        if (!phase) error('Usage: github start-phase --phase N --slug S [--local]');
+        // --local desliga GitHub (commit na branch atual). --solo NAO desliga mais
+        // (so afeta gate visual/merge no build.md); aceito por compat, ignorado aqui.
         const result = github.startPhase({
           cwd,
           phase,
           slug: slug || '',
+          local: hasFlag('--local'),
           solo: hasFlag('--solo'),
         });
         output(result, raw, JSON.stringify(result));
@@ -364,14 +367,28 @@ function main() {
         const phase = getFlag('--phase');
         const mode = getFlag('--mode') || 'menu';
         const strategy = getFlag('--strategy');
-        if (!phase) error('Usage: github finish-phase --phase N --mode menu|auto|solo [--strategy squash|merge|rebase]');
+        if (!phase) error('Usage: github finish-phase --phase N --mode menu|auto|local [--strategy squash|merge|rebase]');
         const result = github.finishPhase({ cwd, phase, mode, strategy });
         output(result, raw, JSON.stringify(result));
+      } else if (sub === 'record-issue') {
+        const phase = getFlag('--phase');
+        const issue = getFlag('--issue');
+        const url = getFlag('--url');
+        if (!phase || !issue) error('Usage: github record-issue --phase N --issue <num> [--url <url>]');
+        const result = github.recordIssue({ cwd, phase, issue, url });
+        output(result, raw, JSON.stringify(result));
+      } else if (sub === 'record-pr') {
+        const phase = getFlag('--phase');
+        const pr = getFlag('--pr');
+        const url = getFlag('--url');
+        if (!phase || !pr) error('Usage: github record-pr --phase N --pr <num> [--url <url>] [--merged]');
+        const result = github.recordPr({ cwd, phase, pr, url, merged: hasFlag('--merged') });
+        output(result, raw, JSON.stringify(result));
       } else if (sub === 'status') {
         const result = github.status({ cwd });
         output(result, raw, JSON.stringify(result));
       } else {
-        error('Unknown github subcommand. Available: start-phase, finish-phase, status');
+        error('Unknown github subcommand. Available: start-phase, finish-phase, record-issue, record-pr, status');
       }
       break;
     }

package/up/commands/build.md

@@ -1,7 +1,7 @@
 ---
 name: up:build
-description: Use quando o usuario quer EXECUTAR um projeto ja planejado (existe .plano/PLAN-READY.md). Default GitHub-nativo por fase (worktree, issue, PR, merge). Flag --solo pula a cerimonia (commit atomico na branch atual); --board espelha no Multica; --auto pula o menu de fim de fase.
-argument-hint: "[--solo] [--board] [--auto]"
+description: Use quando o usuario quer EXECUTAR um projeto ja planejado (existe .plano/PLAN-READY.md). Default GitHub-nativo por fase (worktree, issue, PR, merge) via gh OU MCP. Flag --solo = autonomo total mantendo GitHub (sem menu, sem gate visual); --auto pula so o menu; --local pula o GitHub (commit atomico na branch atual); --board espelha no Multica.
+argument-hint: "[--solo] [--auto] [--local] [--board]"
 allowed-tools:
   - Read
   - Write
@@ -40,11 +40,12 @@ Exemplo: planejou em Claude Code (`/up:plan "X"`), agora roda em OpenCode (`/up-
 <context>
 $ARGUMENTS
 
-**Flags:**
-- (sem flag) = **GitHub-nativo, o DEFAULT** (`config.github_native=true`): cada fase abre worktree + branch `up/fase-NN-slug` + issue, executa, sobe o dev server pra teste visual (se houver UI) e oferece o menu de fim de fase.
-- `--solo` - **ESCAPE HATCH**. Forca `github_native=false` so nesta execucao: commit atomico na branch ATUAL, zero worktree/issue/PR/board.
+**Flags** (GitHub e a interacao humana sao eixos SEPARADOS; as flags so mexem na interacao):
+- (sem flag) = **GitHub-nativo, o DEFAULT** (`config.github_native=true`): cada fase abre worktree + branch `up/fase-NN-slug` + issue (via `gh` OU MCP do GitHub), executa, sobe o dev server pra teste visual (se houver UI) e oferece o menu de fim de fase.
+- `--solo` - **autonomo total**. NAO desliga o GitHub: cria worktree/branch/issue/PR e auto-mergeia, SEM menu e SEM gate visual. Pra loop/headless.
+- `--auto` - pula so o menu de fim de fase (merge automatico). Mantem GitHub. O teste visual ainda roda se `require_visual_test=true`.
+- `--local` - **ESCAPE HATCH sem GitHub**. Commit atomico na branch ATUAL, zero worktree/issue/PR/board. (Mesmo que `/up:rapido`.) Unico jeito de pular o GitHub.
 - `--board` - espelha o progresso das fases no Multica (board opt-in, batched, fail-open).
-- `--auto` - pula o menu de fim de fase (merge automatico). O teste visual ainda roda se `require_visual_test=true`.
 
 O comando le o resto de `.plano/PLAN-READY.md`.
 </context>
@@ -75,23 +76,23 @@ Se algo falta: alertar e oferecer planejamento local OU abortar.
 
 **Sem model routing:** O runtime decide o modelo.
 
-**Parsear flags primeiro:** extrair `--solo`/`--board`/`--auto`. Sem flag = GitHub-nativo (default).
+**Parsear flags primeiro:** extrair `--solo`/`--auto`/`--local`/`--board`. Sem flag = GitHub-nativo (default).
 
 **Modo de orquestracao (resolver antes de comecar):**
-- DEFAULT (sem `--solo`): GitHub-nativo. Por fase: `up-tools.cjs github start-phase` (worktree + branch + issue, fail-open) -> executa as waves -> gate -> teste visual pre-merge (se UI) -> `github finish-phase` (PR -> merge squash -> cleanup) conforme o menu. `--board` adiciona `multica init/sync` (batched). `--auto` pula o menu.
-- `--solo`: executa local, commits atomicos na branch atual. Sem worktree/issue/PR/board.
+- DEFAULT (sem `--local`): GitHub-nativo. Por fase: `up-tools.cjs github start-phase` (worktree + branch + issue via gh OU MCP, fail-open) -> executa as waves -> gate -> teste visual pre-merge (se UI) -> `github finish-phase` (PR -> merge squash -> cleanup) conforme o menu. `--auto` pula o menu (mantem GitHub). `--solo` pula menu E gate visual (autonomo total, mantem GitHub). `--board` adiciona `multica init/sync` (batched).
+- `--local`: executa local, commits atomicos na branch atual. Sem worktree/issue/PR/board.
 
 **Execute the build workflow from @~/.claude/up/workflows/build.md end-to-end.**
 
 Pipeline por fase:
 1. Validacao light
-2. `github start-phase` (worktree + issue; pulado em `--solo`)
+2. `github start-phase` (worktree + issue via gh OU MCP; pulado so em `--local`)
 3. Execucao em WAVES PARALELAS: os planos da mesma wave rodam ao mesmo tempo (varios `up-executor`); waves em sequencia. Re-plan local se algum plano ficar inviavel.
 4. up-verificador emite VERIFICATION.md com evidencia fresca por tipo (TDD-por-tipo: red-green / visual / smoke)
 5. **GATE deterministico** `approvals.log` (governance.md, gate-only; exige `evidence=`)
 6. up-revisor (two-stage: spec-compliance cetico + code-quality) alimenta o gate
 7. **Teste visual pre-merge** (fase de UI e `require_visual_test=true`): sobe o dev server na worktree, "testar primeiro ou pode mergear?", loop de ajuste ate aprovar
-8. **Menu de fim de fase** (GitHub-nativo, fora `--auto`): merge local / abrir PR / deixa a branch / descarta. Em `--solo`, ja committou na branch atual
+8. **Menu de fim de fase** (GitHub-nativo, fora `--auto`/`--solo`): merge local / abrir PR / deixa a branch / descarta. Autonomo (`--solo`/`--auto`) auto-mergeia sem menu. Em `--local`, ja committou na branch atual
 9. Reassessment do roadmap antes da proxima fase
 
 **Re-plan local permitido (max 1 round por fase):**
@@ -102,9 +103,9 @@ Se ficar inviavel, o up-planejador LOCAL refaz a fase. Registrar em `.plano/gove
 
 <success_criteria>
 - [ ] PLAN-READY.md validado
-- [ ] Flags parseadas (default = GitHub-nativo; --solo = escape)
+- [ ] Flags parseadas (default = GitHub-nativo; --solo/--auto = autonomia mantendo GitHub; --local = escape sem GitHub)
 - [ ] Build rodou todas as fases; planos da mesma wave em paralelo
 - [ ] GATE approvals.log respeitado (deterministico, com evidence= por tipo)
-- [ ] Teste visual pre-merge em fase de UI (require_visual_test)
-- [ ] Fechamento por fase: menu (GitHub-nativo) ou commit na branch (--solo)
+- [ ] Teste visual pre-merge em fase de UI (require_visual_test; pulado em --solo)
+- [ ] Fechamento por fase: menu (GitHub-nativo), auto-merge (--solo/--auto) ou commit na branch (--local)
 </success_criteria>

package/up/skills/up-brainstorm/SKILL.md

@@ -38,6 +38,47 @@ Classifique a tarefa com o `classify-task` do `up-tools.cjs` (tiers: `simple` /
 | **Pequena** (1 subsistema, 1 escolha de design) | 1 pergunta via AskUserQuestion (a decisao-chave) + design em 3 frases. Aprova e segue. |
 | **Media / Grande** (multi-subsistema, toca schema/API/auth) | Brainstorm full. |
 
+O `classify-task` define o PISO (minimo garantido). O usuario sempre pode SUBIR ou DESCER manualmente (override abaixo). Nunca diminua a profundidade por conta propria; so o usuario rebaixa.
+
+## Override de profundidade (controle do usuario)
+
+O tier automatico e so o default. O usuario manda na profundidade:
+
+| Sinal do usuario | Efeito |
+|------------------|--------|
+| Palavras "a fundo", "detalhado", "explorar", "pensar junto", "completo", "caprichado" OU flag `--deep` | Sobe pra **full** (ou exploracao, se for ideia crua), ignora o score baixo. |
+| Palavras "rapido", "simples", "so faz", "sem perguntas" OU flag `--quick` | Desce pra **trivial** (0 perguntas), mesmo que o score ache complexo. O HARD-GATE continua: anuncia antes de agir. |
+| Nada declarado | Usa o tier do `classify-task` (piso automatico). |
+
+Pressa nunca remove o gate; muda so quantas perguntas.
+
+## Modo exploracao (ideia crua, acima do full)
+
+Quando o usuario tem so uma SEMENTE e quer DESCOBRIR o que e (nao validar um design ja pronto). Gatilhos: "tenho uma ideia", "to pensando em", "e se", "me ajuda a pensar", "queria explorar", `--deep` numa ideia vaga.
+
+Diferenca do full: o full valida um design que o usuario ja tem na cabeca; a exploracao ABRE o espaco antes de fechar.
+
+1. **Nao pule pra solucao.** Primeiro entenda o PORQUE: que problema/desejo move a ideia, pra quem, por que agora.
+2. **Abra alternativas radicais.** Ofereca 3-5 direcoes bem diferentes (nao variacoes da mesma), incluindo uma obvia, uma ousada e uma "e se fizesse o oposto".
+3. **Provoque com "e se".** Tensione premissas: "e se nao precisasse de X?", "e se o publico fosse outro?", "qual a versao 10x menor que ja entrega valor?".
+4. **Uma pergunta por vez**, multipla escolha quando der. Vai estreitando do amplo pro especifico.
+5. **Destile** a ideia num paragrafo claro: o que e, pra quem, por que, o diferencial. Confirme com o usuario.
+6. So ENTAO transicione pro design (full) ou direto pro `BRIEFING.md`, conforme o tamanho do que emergiu.
+
+A exploracao termina numa ideia destilada e aprovada, que vira BRIEFING. Continua valendo o estado terminal: codigo so depois de `/up:plan`.
+
+## Trilha NAO-codigo (documento, relatorio, analise, conteudo, plano de negocio)
+
+Nem todo trabalho e software. Se a tarefa e produzir um ARTEFATO que nao e codigo (documento, proposta, relatorio, analise, roteiro, estrategia, pesquisa), o fluxo muda:
+
+- **Brainstorm igual** (escala por tier + override + modo exploracao valem). A diferenca e o que vem depois.
+- **NAO ha `/up:plan` -> `/up:build` -> worktree/PR.** Sem fases de software, sem TDD-por-tipo, sem GitHub-nativo. Isso e cerimonia de codigo.
+- **Apos o design/escopo aprovado:** produza o artefato direto (escreva o documento/analise). Para conteudo do Jonathan (carrossel, aula, post), use as skills dedicadas (`carrossel-*`, `aula-generator`, etc) quando aplicaveis.
+- **Verificacao por adequacao, nao por teste:** a prova e "o artefato existe, cobre o que foi pedido, sem placeholder/TBD, e bate com o briefing". Aplica a Lei de Ferro adaptada: nao diga "pronto" sem reler o artefato e conferir contra o escopo combinado.
+- **Persistencia leve:** salve o artefato no local certo (vault, pasta do projeto) e registre 1 linha no STATE.md se houver `.plano/`. Sem roadmap.
+
+Como detectar: pedido fala em "documento, proposta, relatorio, analise, texto, roteiro, estrategia, plano, pesquisa" e NAO em codigo/app/feature/sistema. Na duvida, pergunte: "isso e pra virar codigo ou e um documento/analise?".
+
 ## Brainstorm full (media/grande)
 
 1. **Explore o contexto** (arquivos, docs, commits recentes).

package/up/skills/usando-up/SKILL.md

@@ -15,13 +15,17 @@ O UP ativa por contexto. Nao precisa decorar comando: a skill certa dispara pelo
 
 **Passo ZERO de todo trabalho:** invocar `up-brainstorm`. Profundidade escala por tamanho (trivial = 0 perguntas; grande = design por secao). Nada de implementar antes de design aprovado.
 
-**Fluxo obrigatorio para PROJETO ou FEATURE (nao-trivial):** brainstorm -> `/up:plan` (gera `.plano/PLAN-READY.md`) -> `/up:build` (executa). Depois do design aprovado voce NAO comeca a codar nem a criar fundacao/scaffold direto: registra os artefatos (BRIEFING/PROJECT) e PARA, entregando o handoff para `/up:plan`. Planejar e um passo separado e obrigatorio, nao opcional. Pular o plan so e permitido em tarefa pontual declarada via `/up:rapido`. Se nao tem `.plano/PLAN-READY.md`, voce ainda nao pode buildar.
+**Fluxo obrigatorio para PROJETO ou FEATURE de codigo (nao-trivial):** brainstorm -> `/up:plan` (gera `.plano/PLAN-READY.md`) -> `/up:build` (executa). Depois do design aprovado voce NAO comeca a codar nem a criar fundacao/scaffold direto: registra os artefatos (BRIEFING/PROJECT) e PARA, entregando o handoff para `/up:plan`. Planejar e um passo separado e obrigatorio, nao opcional. Pular o plan so e permitido em tarefa pontual declarada via `/up:rapido`. Se nao tem `.plano/PLAN-READY.md`, voce ainda nao pode buildar.
+
+**Tarefa NAO-codigo** (documento, relatorio, analise, conteudo, estrategia): brainstorma igual, mas NAO passa por `/up:plan`/`/up:build`/worktree. Apos o escopo aprovado, produz o artefato direto e verifica por adequacao (cobre o pedido, sem TBD), nao por teste. Detalhe na skill `up-brainstorm`.
+
+**Profundidade sob controle do usuario:** o tier automatico e so o piso. "A fundo/detalhado/explorar" ou `--deep` sobe pra brainstorm completo (ou modo exploracao pra ideia crua); "rapido/simples" ou `--quick` desce pra 0 perguntas. O usuario manda na profundidade; voce nunca a reduz sozinho.
 
 **Lei de Ferro:** evidencia fresca antes de afirmar pronto. Nunca diga "Pronto" ou "Perfeito" sem o comando de prova rodado NESTA mensagem. Detalhe em `up-verificar-antes-de-concluir`.
 
 **Prova por tipo:** logica/bugfix = teste red-green; UI/CSS = captura visual; glue/integracao = smoke-test. Veja `up-tdd`.
 
-**GitHub-nativo e o padrao em repo colaborativo** (worktree -> issue -> PR -> merge), menu de 4 opcoes no fim. Solo usa `--solo` (commit local) ou `/up:rapido` como escape, sem cerimonia.
+**GitHub-nativo e o padrao** (worktree -> issue -> PR -> merge), via `gh` OU MCP do GitHub, menu de 4 opcoes no fim. `--auto` pula o menu; `--solo` e autonomo total (mantem GitHub, sem menu nem gate visual). Pra pular o GitHub de propósito (commit local puro): `--local` no build ou `/up:rapido`. Atencao: `--solo` NAO desliga mais o GitHub.
 
 **Persistencia:** tudo vive em `.plano/` e sobrevive a `/clear`. Leia `.plano/STATE.md` antes de assumir contexto perdido.
 

package/up/workflows/build.md

@@ -52,27 +52,44 @@ O LLM tende a colapsar passos (mesmo agente executa + verifica). Isso e PROIBIDO
 e um `Agent()` SEPARADO. O enforcement e o GATE deterministico do `approvals.log`
 (ver `@~/.claude/up/workflows/governance.md`), nao uma piramide de supervisores.
 
-**GitHub-nativo e o DEFAULT (v2):**
-- **PADRAO (sem flag):** cada fase abre uma worktree + branch `up/fase-NN-slug` e (se houver `gh` + remote)
-  uma issue do GitHub; no fim da fase, se a fase tem UI, **sobe o dev server e PEDE aprovacao visual antes de
-  mergear** (3.8.0), depois fecha (merge local / PR / deixa / descarta). Isto e o caminho quente.
-  Controlado por `config.github_native=true` (default).
-- `--solo`: ESCAPE HATCH sem cerimonia. Forca `github_native=false` SO nesta execucao. Commit atomico na
-  branch ATUAL. Zero worktree, zero issue, zero PR, zero rede. (Mesmo comportamento de `/up:rapido`.)
+**GitHub-nativo e o DEFAULT (v2): DOIS EIXOS SEPARADOS:**
+
+O GitHub (worktree/branch/issue/PR) e a INTERACAO humana (menu/gate visual/merge) sao eixos
+independentes. As flags mexem so na interacao; o GitHub fica ligado sempre que da.
+
+- **Eixo GitHub:** LIGADO sempre que ha remote E (`gh` autenticado OU MCP do GitHub conectado).
+  Worktree+branch sao git local e SEMPRE acontecem (offline-ok). Issue/PR usam o transporte:
+  `gh` (CLI cria direto) ou `mcp` (o workflow cria via `mcp__...github__*` e grava com
+  `record-issue`/`record-pr`). DESLIGA so com `--local` ou `config.github_native=false`.
+- `--local`: ESCAPE HATCH sem GitHub. Commit atomico na branch ATUAL. Zero worktree/issue/PR/rede.
+  (Mesmo comportamento de `/up:rapido`.) **Este e o unico jeito de pular o GitHub no build.**
+- `--solo`: NAO desliga o GitHub. Solo = autonomo total: GitHub completo (branch/worktree/issue/PR
+  + auto-merge), SEM menu e SEM gate visual. Pra loop/headless onde ninguem aprova nada.
+- `--auto`: pula o MENU de fechamento (auto-merge), MAS o gate visual (3.8.0) ainda roda se
+  `require_visual_test=true`. Mantem GitHub ligado.
 - **Teste visual antes do merge (`require_visual_test`, default true):** fase de UI sobe dev server e exige
-  o dono aprovar na tela ANTES do merge (3.8.0). Projeto em PRODUCAO: deixe ligado (nada sobe sem voce ver).
-- `--auto`: pula o MENU de fechamento. Apos o GATE aprovar, `finish-phase --mode auto` (PR -> merge squash ->
-  cleanup). MAS o teste visual (3.8.0) ainda roda se `require_visual_test=true` (so `false` deixa o --auto
-  mergear UI sem aprovacao). So faz sentido com github_native ligado.
+  o dono aprovar na tela ANTES do merge (3.8.0). `--solo` pula sempre; `--auto` so pula com `require_visual_test=false`.
+  Projeto em PRODUCAO: deixe ligado e nao use `--solo` (nada sobe sem voce ver).
 - `--board`: espelha status no Multica (espelho de board OPT-IN, BATCHED no fim da onda/fase). NAO ha
   stream ao vivo no fluxo local: o board mostra so o status (`todo -> in_progress -> in_review -> done /
   blocked`), nunca cada tool_use. Chamadas via `up-tools.cjs multica {init|sync|board}` (que usa
   `multica.cjs`, deteccao `uname -s` Mac->`ssh server-ecoup`, FAIL-OPEN: se `multica` indisponivel, avisa
   e segue sem board, nunca crasha). So roda quando `--board` ligado.
 
-**FAIL-OPEN universal:** `start-phase`/`finish-phase` detectam `gh` + remote. Faltando qualquer um, degradam
-para git local (worktree local + merge local; issue/PR = null) com aviso, NUNCA crasham. `git worktree` e
-sempre local e funciona offline. Com `--solo` nao ha nem worktree (commit direto na branch atual).
+**Resumo das flags** (GitHub = artefatos; demais = interacao):
+
+| Flag | GitHub | Menu fim | Gate visual | Merge |
+|------|:---:|:---:|:---:|---|
+| (nenhum) | SIM | SIM (4 opcoes) | SIM | conforme menu |
+| `--auto` | SIM | NAO | SIM (a menos require_visual_test=false) | auto squash |
+| `--solo` | SIM | NAO | NAO (pula sempre) | auto squash |
+| `--local` | NAO | NAO | NAO | commit na branch atual |
+
+**FAIL-OPEN universal:** `start-phase`/`finish-phase` detectam remote + transporte (`gh`/`mcp`/`none`).
+Sem remote, degradam para git local (worktree local + merge local; issue/PR = null) com aviso, NUNCA
+crasham. `git worktree` e sempre local e funciona offline. Sem `gh` mas com MCP, o transporte e `mcp`:
+worktree/branch/push acontecem no `.cjs` e o workflow cria issue/PR via MCP. Com `--local` nao ha nem
+worktree (commit direto na branch atual).
 
 **Onde o estado vive:** `git-map.json` e canonico no working dir PRINCIPAL (`.plano/git-map.json`). O `.plano/`
 de cada fase viaja na branch da fase (worktree) e volta pra main no merge. STATE.md permanece a fonte humana
@@ -175,25 +192,31 @@ Projeto planejado em {runtime}.
 Resumo: {N} fases, {M} planos. Planning confidence: {X}/100.
 Pendencias conhecidas: {de PENDING.md}.
 
-Modo git: {GITHUB_MODE}   (GitHub-nativo e o default; --solo desliga; --auto pula o menu)
+Modo git: {GITHUB_MODE}   (GitHub-nativo e o default; --local desliga; --solo/--auto sao autonomia, nao desligam)
 ```
 
-Resolver `GITHUB_MODE` antes do banner:
+Resolver `GITHUB_MODE` antes do banner. `$LOCAL`/`$SOLO`/`$AUTO`/`$BOARD_FLAG` vem das flags da
+invocacao. **`--solo` NAO desliga o GitHub** (so `--local` desliga):
 
 ```bash
-# --solo forca github_native=false SO nesta execucao
-if [ "$SOLO" = "true" ]; then
+# So --local (ou config github_native=false) desliga o GitHub.
+if [ "$LOCAL" = "true" ]; then
   GITHUB_NATIVE=false
 else
   GITHUB_NATIVE=$(node "$HOME/.claude/up/bin/up-tools.cjs" config get github_native --raw 2>/dev/null)
   [ -z "$GITHUB_NATIVE" ] && GITHUB_NATIVE=true   # default TRUE
 fi
 
+# --solo e --auto sao AUTONOMIA (sem menu). --solo tambem pula o gate visual.
+AUTONOMO=false
+{ [ "$SOLO" = "true" ] || [ "$AUTO" = "true" ]; } && AUTONOMO=true
+
 if [ "$GITHUB_NATIVE" = "true" ]; then
   GITHUB_MODE="GitHub-nativo (worktree + issue + PR/menu por fase)"
-  [ "$AUTO" = "true" ] && GITHUB_MODE="GitHub-nativo --auto (PR + merge squash automatico)"
+  [ "$AUTO" = "true" ]  && GITHUB_MODE="GitHub-nativo --auto (PR + merge squash; gate visual ainda roda)"
+  [ "$SOLO" = "true" ]  && GITHUB_MODE="GitHub-nativo --solo (autonomo total: PR + merge, SEM gate visual)"
 else
-  GITHUB_MODE="--solo (commit atomico na branch atual, sem worktree/issue/PR)"
+  GITHUB_MODE="--local (commit atomico na branch atual, sem worktree/issue/PR)"
 fi
 
 # --board liga o espelho Multica (OPT-IN). So tem efeito se passado explicitamente.
@@ -231,27 +254,37 @@ Para cada fase em ROADMAP.md (em ordem):
 
 ### 3.0 Abrir a fase (GitHub-nativo - DEFAULT)
 
-A menos que `--solo` (ou `github_native=false`), abrir worktree + branch + issue ANTES de executar a fase.
+A menos que `--local` (ou `github_native=false`), abrir worktree + branch + issue ANTES de executar a fase.
 
 ```bash
 PHASE_SLUG=$(node "$HOME/.claude/up/bin/up-tools.cjs" slug "{phase_name}" --raw)
 
 if [ "$GITHUB_NATIVE" = "true" ]; then
-  # Cria worktree + branch up/fase-NN-slug; se gh+remote, cria issue. Escreve .plano/git-map.json.
-  # Fail-open: sem gh/remote -> worktree local, issue=null, aviso (nunca crasha).
+  # Cria worktree + branch up/fase-NN-slug SEMPRE (git local). Issue por transporte:
+  #   gh  -> issue criada aqui;  mcp -> retorna pending.issue (workflow cria via MCP);  none -> sem remote.
   START=$(node "$HOME/.claude/up/bin/up-tools.cjs" github start-phase \
     --phase {phase_number} --slug "$PHASE_SLUG" --raw)
   if [[ "$START" == @file:* ]]; then START=$(cat "${START#@file:}"); fi
-  WORKTREE=$(echo "$START" | grep -oE '"worktree"[^,}]*' | sed 's/.*: *"//;s/"//')
-  BRANCH=$(echo "$START"   | grep -oE '"branch"[^,}]*'   | sed 's/.*: *"//;s/"//')
-  ISSUE=$(echo "$START"    | grep -oE '"issue"[^,}]*'    | sed 's/.*: *//')
-  echo "Fase {phase_number}: branch=$BRANCH worktree=$WORKTREE issue=${ISSUE:-null}"
+  WORKTREE=$(echo "$START"  | grep -oE '"worktree"[^,}]*'  | sed 's/.*: *"//;s/"//')
+  BRANCH=$(echo "$START"    | grep -oE '"branch"[^,}]*'    | sed 's/.*: *"//;s/"//')
+  ISSUE=$(echo "$START"     | grep -oE '"issue"[^,}]*'     | sed 's/.*: *//')
+  TRANSPORT=$(echo "$START" | grep -oE '"transport"[^,}]*' | sed 's/.*: *"//;s/"//')
+  echo "Fase {phase_number}: branch=$BRANCH worktree=$WORKTREE issue=${ISSUE:-null} transport=$TRANSPORT"
 else
-  # --solo: sem worktree/issue. Trabalho acontece na branch atual.
-  WORKTREE="$(pwd)"; BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"; ISSUE=""
+  # --local: sem worktree/issue. Trabalho acontece na branch atual.
+  WORKTREE="$(pwd)"; BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"; ISSUE=""; TRANSPORT=none
 fi
 ```
 
+**Issue via MCP (quando `transport=mcp`):** sem `gh` mas com remote, `start-phase` ja criou worktree+branch
+e devolveu `pending.issue {title, body}` no JSON. Se voce (orquestrador) TEM as tools `mcp__...github__*`,
+crie a issue agora e grave o numero de volta:
+
+> Ao detectar `transport=mcp` no `$START`: extraia `pending.issue.title`/`pending.issue.body`, chame
+> `mcp__plugin_github_github__issue_write` (create) no repo do remote, pegue o numero retornado e rode
+> `node "$HOME/.claude/up/bin/up-tools.cjs" github record-issue --phase {phase_number} --issue <num> --url <url>`.
+> Se voce NAO tem MCP do GitHub: siga sem issue (worktree/branch ja existem; PR pode degradar pra merge local no fim).
+
 **Entrar na worktree (so se github_native):** o trabalho da fase (executor, commits) acontece
 DENTRO de `$WORKTREE`. Preferir a tool nativa do harness **EnterWorktree** apontando para `$WORKTREE`; se
 indisponivel, a worktree ja foi criada por `start-phase` (basta usar `--cwd "$WORKTREE"` nos comandos
@@ -259,7 +292,7 @@ indisponivel, a worktree ja foi criada por `start-phase` (basta usar `--cwd "$WO
 `git-map.json` permanece canonico no working dir principal. Ao terminar a fase usar **ExitWorktree** (ou
 voltar `cd` para o repo principal) antes de atualizar `git-map.json` na main.
 
-> Em `--solo`, IGNORAR EnterWorktree/ExitWorktree: tudo na branch atual.
+> Em `--local`, IGNORAR EnterWorktree/ExitWorktree: tudo na branch atual. Em `--solo` HA worktree (solo nao desliga GitHub).
 
 **Multica: marcar a fase em execucao (so se `--board`, 1 chamada na ENTRADA da fase).**
 Uma transicao por fase (nao por microtransicao): status `in_progress` + metadata `gh_issue`/`branch`.
@@ -281,7 +314,7 @@ NAO existe mais "1 plano por fase" (era a regressao do `head -1`): descobrimos T
 agrupamento por wave do disco.
 
 Os planos vivem DENTRO de `$WORKTREE` (a `.plano/` da fase viaja na branch da fase). Por isso TODA chamada
-de descoberta usa `--cwd "$WORKTREE"` (em `--solo`, `$WORKTREE` = repo principal, entao funciona igual).
+de descoberta usa `--cwd "$WORKTREE"` (em `--local`, `$WORKTREE` = repo principal, entao funciona igual).
 
 ```bash
 # (a) Metadados da fase + flag de paralelizacao (config). Trata @file: (saida > 50KB).
@@ -635,7 +668,7 @@ fi
 
 So apos o GATE aprovar (APPROVE ou forced approval registrado).
 
-**Caso `--solo` (github_native=false):** nada a fazer aqui. Tudo ja foi committado atomicamente na branch
+**Caso `--local` (github_native=false):** nada a fazer aqui. Tudo ja foi committado atomicamente na branch
 atual. Seguir direto para 3.9. (Sem worktree, sem teste-visual-gate, sem merge.)
 
 #### 3.8.0 Checkpoint de teste visual (PRE-MERGE) - so GitHub-nativo
@@ -649,9 +682,10 @@ REQUIRE_VISUAL=$(node "$HOME/.claude/up/bin/up-tools.cjs" config get require_vis
 HAS_DEV=$(node -e "try{const s=require('./package.json').scripts||{};process.stdout.write((s.dev||s.start||s.serve)?'1':'')}catch(e){}" 2>/dev/null)
 ```
 
-**Aplica o gate quando:** (HAS_UI ou HAS_DEV) E NAO (`--auto` E REQUIRE_VISUAL=false).
-Ou seja: por padrao SEMPRE pede aprovacao visual antes do merge em fase de UI. Para PULAR (CI/yolo):
-`--auto` + setar `require_visual_test=false` no config. Para projeto em PRODUCAO: deixe o default (true).
+**Aplica o gate quando:** (HAS_UI ou HAS_DEV) E NAO `--solo` E NAO (`--auto` E REQUIRE_VISUAL=false).
+Ou seja: por padrao SEMPRE pede aprovacao visual antes do merge em fase de UI. `--solo` pula SEMPRE
+(autonomo total). Pra pular sem solo (CI/yolo): `--auto` + `require_visual_test=false`. Projeto em
+PRODUCAO: deixe o default (true) e nao use `--solo`.
 
 Se aplica:
 
@@ -706,32 +740,44 @@ pkill -f "npm run dev" 2>/dev/null || true; pkill -f "npm start" 2>/dev/null ||
 A escolha do checkpoint define a acao de fechamento (3.8.1): "Pode mergear"/"Aprovado" -> MERGE;
 "Deixa a branch" -> nao mergeia; "Descarta" -> remove sem merge.
 
-**Fase SEM UI** (infra/schema/backend puro) ou `--auto` com `require_visual_test=false`: pula 3.8.0.
+**Fase SEM UI** (infra/schema/backend puro), `--solo`, ou `--auto` com `require_visual_test=false`: pula 3.8.0.
 Nesse caso, GitHub-nativo interativo ainda apresenta o mesmo AskUserQuestion de 4 opcoes (sem o passo do
-dev server) pra o dono decidir merge/PR/deixa/descarta. `--auto` com fase sem UI fecha direto (sem perguntar).
+dev server) pra o dono decidir merge/PR/deixa/descarta. **Autonomo (`--solo`/`--auto`)** fecha direto sem
+menu: `ESCOLHA=mergear`.
 
 #### 3.8.1 Merge e avancar
 
 Sair da worktree (**ExitWorktree** ou `cd` de volta ao repo principal) para que `finish-phase` opere e
-atualize `git-map.json` na main. Mapear a escolha de 3.8.0 para `finish-phase`
-(`--mode menu|auto|solo`):
+atualize `git-map.json` na main. **Autonomo (`--solo`/`--auto`):** sem menu, `ESCOLHA=mergear`.
+Mapear a escolha de 3.8.0 para `finish-phase` (`--mode menu|auto|local`):
 
 ```bash
+[ "$AUTONOMO" = "true" ] && [ -z "$ESCOLHA" ] && ESCOLHA=mergear
 case "$ESCOLHA" in
-  # Pode mergear / Aprovado: finish-phase --mode auto faz gh pr create (Closes #N) -> merge squash -> cleanup.
-  # FAIL-OPEN: sem gh/remote, --mode auto degrada para merge LOCAL da branch na base + cleanup (issue/PR=null).
-  mergear|aprovado) node "$HOME/.claude/up/bin/up-tools.cjs" github finish-phase --phase {phase_number} --mode auto --strategy squash ;;
+  # Pode mergear / Aprovado: finish-phase --mode auto. Transporte gh: pr create (Closes #N) -> merge -> cleanup.
+  # Transporte mcp (sem gh): faz push e retorna action 'needs-mcp-pr' (ver abaixo). none: merge LOCAL + cleanup.
+  mergear|aprovado) FIN=$(node "$HOME/.claude/up/bin/up-tools.cjs" github finish-phase --phase {phase_number} --mode auto --strategy squash --raw) ;;
   # Deixa a branch: nao mergeia; worktree+branch vivos. menu so atualiza git-map.json (status=in_review).
-  deixa)            node "$HOME/.claude/up/bin/up-tools.cjs" github finish-phase --phase {phase_number} --mode menu ;;
+  deixa)            FIN=$(node "$HOME/.claude/up/bin/up-tools.cjs" github finish-phase --phase {phase_number} --mode menu --raw) ;;
   # Descarta: orquestrador remove worktree + branch (sem merge); reflete em git-map.json via status=cancelled.
-  descarta)         echo "Descartando fase {phase_number}: remover worktree + branch (sem merge)." ;;
+  descarta)         echo "Descartando fase {phase_number}: remover worktree + branch (sem merge)." ; FIN="" ;;
 esac
 ```
 
-`finish-phase --mode auto` faz: gh pr create (body com `Closes #<issue>` quando ha issue) -> merge (squash
-default, ou `--strategy merge|rebase`) -> cleanup worktree+branch, e atualiza `git-map.json`. FAIL-OPEN: sem
-gh/remote, faz merge LOCAL da branch da fase na base e remove a worktree (issue/PR = null). `--mode solo` nao
-faz nada (usado quando ja esta tudo committado na branch atual); em `--solo` o fluxo nem chega aqui.
+**PR via MCP (quando `FIN` traz `"action":"needs-mcp-pr"`):** sem `gh`, o `finish-phase` ja deu `git push` da
+branch e devolveu `pr_payload {base, head, title, body, issue, strategy}`. Se voce TEM `mcp__...github__*`:
+
+> Chame `mcp__plugin_github_github__create_pull_request` (base/head/title/body do `pr_payload`), depois
+> `mcp__plugin_github_github__merge_pull_request` (merge_method=squash). Pegue o numero do PR e rode:
+> `node "$HOME/.claude/up/bin/up-tools.cjs" github record-pr --phase {phase_number} --pr <num> --url <url> --merged`
+> (`--merged` grava o PR, marca a fase merged e limpa worktree+branch). Se NAO tem MCP: rode
+> `github finish-phase --phase {phase_number} --mode local` como degradacao (a branch ja foi pushada; faca o
+> merge no GitHub manualmente depois) OU avise o dono.
+
+`finish-phase --mode auto` (transporte gh) faz: gh pr create (body com `Closes #<issue>`) -> merge (squash
+default, ou `--strategy merge|rebase`) -> cleanup worktree+branch, atualiza `git-map.json`. Sem remote (none),
+faz merge LOCAL da branch na base e remove a worktree (issue/PR=null). `--mode local` nao faz nada (usado em
+`--local`, ja committado na branch atual); em `--local` o fluxo nem chega aqui (tratado em 3.8).
 
 **Multica: sync BATCHED no FIM da fase/onda (so se `--board`).**
 Uma unica chamada que reflete TODAS as transicoes acumuladas da fase de uma vez (nao por microtransicao):
@@ -759,7 +805,7 @@ if [ "$BOARD" = "true" ]; then
 fi
 ```
 
-> Em `--solo` o fluxo nem chega aqui (sem `--board`): nenhuma chamada Multica.
+> Em `--local` o fluxo nem chega aqui (sem `--board`): nenhuma chamada Multica.
 
 ### 3.9 Reassessment de roadmap (pos-fase, inline, ~30s)
 
@@ -845,8 +891,9 @@ final_confidence: [do up-revisor de delivery]
 - [ ] E2E + DCRV rodaram por fase (delegado a dcrv.md)
 - [ ] up-revisor emitiu veredito por fase e LOGOU em approvals.log COM campo evidence=<tipo>:<resultado>
 - [ ] GATE de fase deterministico passou (APPROVE + evidence do tipo certo, ou forced approval com debito)
-- [ ] GitHub-nativo (default): worktree+branch+issue por fase via `github start-phase`; menu 4 opcoes /
-      `github finish-phase` no fim. `--solo` degrada para commit na branch atual (sem worktree/issue/PR)
+- [ ] GitHub-nativo (default): worktree+branch+issue por fase via `github start-phase` (transporte gh OU
+      MCP); menu 4 opcoes / `github finish-phase` no fim. `--solo`/`--auto` mantem GitHub (autonomia, nao
+      desliga). `--local` degrada para commit na branch atual (sem worktree/issue/PR)
 - [ ] Execucao sempre via up-executor (roteia por contexto: frontend/backend/database/misto); SEM agentes
       specialist separados (Onda 2 do corte)
 - [ ] `--board`: Multica init no inicio (project+pai), sync `in_progress` na entrada da fase, sync BATCHED

package/up/workflows/rapido.md

@@ -4,7 +4,7 @@ Executar tarefas pequenas e ad-hoc com garantias UP (commits atomicos, rastreame
 **ESCAPE HATCH PURO (sem cerimonia GitHub).** Diferente de `/up:build` (GitHub-nativo por DEFAULT:
 worktree -> branch `up/fase-NN` -> issue -> PR -> menu), o modo rapido NUNCA cria worktree, NUNCA cria
 issue do GitHub, NUNCA abre PR e NAO toca em `.plano/git-map.json`. Todo o trabalho e committado
-atomicamente na branch ATUAL (mesmo semantica do `--solo` do build). E o caminho quente para
+atomicamente na branch ATUAL (mesma semantica do `--local` do build). E o caminho quente para
 "so faz e commita". Quem quer worktree/issue/PR usa `/up:build`.
 </purpose>
 

package/up/workflows/up.md

@@ -290,9 +290,12 @@ Escrever inline (sem CEO):
 **`.plano/config.json`** — defaults (perguntar so na complex):
 
 ```json
-{ "mode": "yolo", "granularity": "standard", "parallelization": true, "commit_docs": true }
+{ "mode": "yolo", "granularity": "standard", "parallelization": true, "commit_docs": true, "github_native": true }
 ```
 
+`github_native: true` explicito torna a intencao visivel no arquivo (o build ja usa true por default, mas
+deixar gravado evita ambiguidade em run autonomo). So vira `false` se o projeto e local sem GitHub.
+
 Commits atomicos:
 
 ```bash
@@ -345,9 +348,10 @@ Apos estruturar, o `/up` NAO planeja nem executa fases sozinho. Ele entrega o ha
 ---
 ```
 
-> `/up:build` aceita `--solo` (default, commit na branch atual), `--pr` (worktree+issue+PR),
-> `--board` (espelho de status no Multica, batched, fail-open) e `--auto` (merge se verde). Para ver o
-> board depois: `/up estado board` (abre a URL no Multica). Aqui so roteamos pro /up:plan.
+> `/up:build` e **GitHub-nativo por padrao** (worktree + issue + PR por fase, via `gh` OU MCP do GitHub).
+> Flags: `--auto` (pula o menu, mantem GitHub), `--solo` (autonomo total: GitHub + auto-merge, sem menu
+> nem gate visual), `--local` (escape sem GitHub: commit na branch atual), `--board` (espelho de status no
+> Multica, batched, fail-open). Para ver o board depois: `/up estado board`. Aqui so roteamos pro /up:plan.
 
 ## Passo 4: CLONE (URL recebida)
 
@@ -394,6 +398,7 @@ escreve o PRD pronto pro planejamento.
 
 ```json
 { "mode": "yolo", "granularity": "standard", "parallelization": true, "commit_docs": true,
+  "github_native": true,
   "builder_type": "clone", "clone_source": "{URL}", "clone_mode": "{exact|improve|inspiration}",
   "clone_data": ".plano/clone/" }
 ```