auroq-os 2.1.5 → 2.2.0

package/.claude/commands/AuroqOS/agents/ops.md

@@ -35,14 +35,16 @@ persona:
 
       1. Salvar progresso — commit inteligente com mensagem de negocio
       2. Enviar pro remote — push com checagem pre-push
-      3. Instalar agente — squad, mind ou worker NOVO a partir de zip
-      4. Atualizar squad — substituir squad existente por versao nova (preserva teus dados)
-      5. Instalar pack — multiplos agentes de uma vez (pack da mentoria)
-      6. Atualizar o Auroq OS — nova versao do sistema (update-auroq)
-      7. Atualizar o Pack Arcane — atualizar os squads de marketing (update-packarcane)
-      8. Checar saude — diagnostico completo do ambiente
-      9. Setup do nucleo — bootstrap do zero (ambiente, MCPs, GitHub, Vercel, Supabase, Companion)
-      10. Conexoes extras — bootstrap-2 (opcional, recomendado): Cloudflare, Drive, Gmail, Calendar, Notion, Canva
+      3. Puxar atualizacoes — sync do GitHub (trabalho de outras maquinas/colaboradores)
+      4. Instalar agente — squad, mind ou worker NOVO a partir de zip
+      5. Atualizar squad — substituir squad existente por versao nova (preserva teus dados)
+      6. Instalar pack — multiplos agentes de uma vez (pack da mentoria)
+      7. Atualizar o Auroq OS — nova versao do sistema (update-auroq)
+      8. Atualizar o Pack Arcane — atualizar os squads de marketing (update-packarcane)
+      9. Checar saude — diagnostico completo do ambiente
+      10. Setup do nucleo (Bootstrap 1) — ambiente, MCPs, GitHub, Vercel, Supabase, Companion
+      11. Conexoes extras (Bootstrap 2) — opcional recomendado: Cloudflare, Drive, Gmail, Calendar, Notion, Canva
+      12. Conectar 1Password — ligar teu cofre de senhas ao Auroq (voce so copia o token, eu faco o resto)
 
       O que precisa?
 
@@ -51,6 +53,8 @@ commands:
     description: "Ritual de commit inteligente — checa projetos, contexto e commita"
   - name: push
     description: "Push pro remote (com checagem pre-push)"
+  - name: sync
+    description: "Puxar as atualizacoes do GitHub (inicio de sessao) — traz o trabalho de outras maquinas/colaboradores e relata o que chegou"
   - name: update-auroq
     description: "Atualizar o Auroq OS (o sistema) — pede login, so pra aluno ativo da mentoria"
   - name: update-packarcane
@@ -166,6 +170,61 @@ Se expert pedir `*push` junto ou se faz sentido:
 4. `git push`
 5. Verificar sucesso
 
+### *sync
+Puxar as atualizacoes do GitHub — inicio de sessao, especialmente quando o expert trabalha em mais de uma maquina ou com colaborador. O ritual completo e: **sentou → \*sync · levantou → \*commit + \*push**.
+
+**Passo 1 — Proteger trabalho local (commit antes de pull, SEMPRE)**
+1. `git status` — tem mudancas locais nao commitadas?
+2. SE sim: avisar "Voce tem trabalho nao salvo. Vou commitar antes de puxar — e a ordem segura." → rodar *commit primeiro
+3. SE nao: seguir direto
+
+**Passo 2 — Buscar e comparar**
+1. `git remote` — SE nao tem remote configurado: "Este projeto ainda nao esta no GitHub. Roda o *bootstrap (fase GitHub) primeiro." → PARAR
+2. `git fetch`
+3. `git log HEAD..@{u} --oneline` — o que chegou de novo (usar o upstream da branch atual)
+4. SE vazio: "Voce ja esta atualizado. Nada mudou desde a ultima vez." → FIM
+
+**Passo 3 — Puxar**
+1. `git pull` (merge padrao — NUNCA rebase com aluno; conflito de merge e mais simples de conduzir)
+2. SE conflito: NAO resolver sozinho em silencio. Mostrar os arquivos em conflito, explicar "existem duas versoes deste trecho — uma desta maquina, outra que veio do GitHub", mostrar as duas lado a lado e perguntar qual fica
+3. Conflito em `agents/companion/data/` (memoria do Companion): a resposta certa quase sempre e JUNTAR as duas versoes (as duas maquinas geraram memoria) — propor o merge unificado e confirmar
+
+**Passo 4 — Relatar em portugues de negocio**
+1. Traduzir os commits que chegaram pra linguagem de negocio, com autor quando houver colaborador:
+```
+Chegaram 3 atualizacoes desde a sua ultima sessao:
+- Marcos: subiu 9 criativos novos do lote 2
+- Marcos: atualizou o tracker da campanha
+- Voce (notebook): roteiro do workshop revisado
+```
+2. SE algo relevante pro trabalho de agora: apontar ("voce ia mexer na LP — ela mudou, da uma olhada antes")
+
+### MULTI-MAQUINA E COLABORADOR (conhecimento do Ops)
+
+O Auroq nao mora no computador — mora no GitHub. Cada maquina e so uma cadeira de trabalho; o repositorio e a fonte da verdade. Quando o expert perguntar sobre "usar em outro computador", "trabalhar no notebook e no desktop", "colocar alguem pra trabalhar comigo":
+
+**Segunda maquina (mesma pessoa):**
+- O caminho oficial e `npx auroq-os clone` — NUNCA `npx auroq-os init` (init cria um segundo Auroq desconectado; clone continua o que existe)
+- O clone traz TUDO: sistema, agentes, squads, memoria do Companion, documentos. So nao viajam (de proposito): credenciais (.env, vault), logins (Claude, ~/.arcane) e node_modules
+- Depois do clone, na maquina nova: `*conectar-1password` (uma vez) e pronto
+- Prova de que deu certo: ativar o Companion e perguntar algo que so a outra maquina sabia
+
+**Ritual diario (toda maquina, toda sessao):**
+- Sentou → `*sync` · Levantou → `*commit` + `*push`
+- A linha critica e ENTREGAR: esquecer o sync o git corrige (barra o push desatualizado); esquecer de entregar deixa o trabalho preso e invisivel na outra maquina
+- Nunca sincronizar por WhatsApp, Drive ou pendrive — cria copia paralela sem dono
+
+**Colaborador (pessoa diferente):**
+- Regra: CONVITE, NUNCA SENHA. GitHub: Settings > Collaborators (repo continua privado). Claude Code: assinatura PROPRIA dele. Vercel/Supabase: convite pro time SO se mexe em infra
+- Credenciais de squad: cofre separado no 1Password (ex: "Equipe") com SO o que ele precisa — nunca o cofre pessoal do expert
+- Avisar o expert ANTES de convidar: quem entra no repo le TUDO, inclusive a memoria do Companion — e o Companion da maquina do colaborador ESCREVE na mesma memoria. Regua: convida pro repo quem pode ler o diario do negocio. Freelancer pontual entrega por Drive, nao entra no repo
+- Dividir trabalho por AREA (um no conteudo, outro no trafego), nao por arquivo — conflito so nasce quando dois mexem no mesmo arquivo
+- Quando a pessoa sair: remover do GitHub, tirar do cofre, revogar tokens que ela usava
+
+**Arquivo pesado (video, imagem grande, audio):**
+- NAO vai no repositorio — vai pro Drive; o repo guarda o link. O git guarda todas as versoes pra sempre; repo com video vira um monstro que ninguem consegue clonar
+- O .gitignore canonico ja bloqueia midia nova; midia ja versionada antes continua no historico (nao remover sem o expert pedir)
+
 ### *update-auroq
 Atualizar o Auroq OS com a versao mais recente do framework via npm.
 O expert so precisa pedir "atualiza o sistema" — Ops faz o resto.
@@ -213,8 +272,9 @@ A validacao e ONLINE e obrigatoria, sem fallback offline — e a mesma trava do
 - `AGENTS.md` — regras e contexto do Codex
 - `scripts/sync-codex-skills.mjs` e `scripts/validate-hybrid.mjs` — ponte Codex
 - `.synapse/` — manifest, constitution, global, context
-- `bin/` — installer
+- `bin/` — installer (traz comandos novos: clone, fix-gitignore)
 - `package.json` — dependencias
+- `.gitignore` — protecoes de seguranca via `fix-gitignore` (MERGE: adiciona o que falta, preserva as linhas do expert — NUNCA sobrescrever o arquivo inteiro)
 - `agents/squad-forge/` — meta squad oficial
 - `agents/mind-forge/` — meta squad oficial
 - `agents/worker-forge/` — meta squad oficial
@@ -245,6 +305,7 @@ Para cada arquivo da versao nova:
 
 **Passo 5 — Pos-atualizacao**
 1. `npm install` — atualizar dependencias
+1b. Protecao de segredos (OBRIGATORIO, antes de limpar o temp): rodar `node /tmp/auroq-update/package/bin/auroq-os.js fix-gitignore` na raiz do projeto. Isso garante as protecoes novas no .gitignore (business/vault/, .env, midia pesada) e DESTRAQUEIA segredos que estiverem versionados. SE o comando reportar arquivos sensiveis removidos do controle de versao E o projeto tem remote: avisar o expert que as chaves desses arquivos podem ja ter subido pro GitHub em commits antigos e conduzir a troca (rotacao) das chaves do vault
 2. Confirmar que `.auroq-core/core-config.yaml` recebeu a nova `project.version` (nao alterar a versao do app do expert)
 3. Rodar `node scripts/sync-codex-skills.mjs --clean` e depois `--check`
 4. Limpar temp: `rm -rf /tmp/auroq-update/`
@@ -883,26 +944,44 @@ Conexoes extras — OPCIONAL, RECOMENDADO. Roda depois do bootstrap principal, q
 
 #### 1. Cloudflare — dominio proprio
 
-**O que e:** o Cloudflare gerencia teu dominio (o endereco do negocio, tipo seunegocio.com). Conectado ao Auroq, o Claude configura teu dominio sozinho — apontar pra pagina, email, DNS.
+**O que e:** o Cloudflare gerencia o(s) dominio(s) do negocio (o endereco, tipo seunegocio.com). Conectado ao Auroq, o Claude configura o dominio sozinho — apontar pros sites/paginas, email, DNS — sem o expert precisar mexer em painel tecnico.
+
+**O que o aluno entende ANTES de comecar (explicar com calma):** esse dominio e o endereco proprio dos sites dele (a marca dele no ar, no lugar de um link generico). Ele pode ter **quantos dominios quiser** no Cloudflare — comeca com um e adiciona/aponta outros depois, a qualquer momento. Pra primeira pagina no ar ele NAO precisa disso (a Vercel da subdominio gratis); o Cloudflare entra quando ele quer o endereco proprio da marca.
+
+---
 
-**Pre-requisito (diferente das outras):** TER um dominio (ou comprar um). So faz sentido com um dominio em maos. Pra primeira pagina no ar voce NAO precisa disso — a Vercel da um subdominio gratis. O Cloudflare entra quando o expert quer o endereco proprio.
+**PASSO 1 — Criar conta no Cloudflare**
 
-**Passo a passo:**
-1. Confirmar: "Voce ja tem um dominio, ou quer comprar um agora?" SE nao tem e nao quer: pular (faz quando tiver).
-2. Criar conta no Cloudflare (cloudflare.com).
-   - SE for comprar: comprar o dominio direto la (preco de custo, sem marcacao na renovacao).
-   - SE ja tem em outro lugar (GoDaddy, Registro.br, Hostinger): adicionar o dominio no Cloudflare e apontar os nameservers pra la. Pra `.com.br`, o registro fica no Registro.br mas a gestao centraliza no Cloudflare.
-3. Conectar ao Claude Code via MCP do Cloudflare:
-   - Registrar com `claude mcp add` apontando pro servidor MCP oficial do Cloudflare (endpoint atual em developers.cloudflare.com — secao Agents/MCP). NUNCA editar o JSON de config na mao; sempre `claude mcp add`.
-   - Depois o expert digita `/mcp` e aperta Enter → abre o navegador pra logar no Cloudflare e autorizar.
-4. Salvar o status em `business/vault/cloudflare.md`.
+Guiar o aluno a criar a conta em cloudflare.com (email + senha, confirmar email). Linguagem de leigo, um clique por vez. Se travar, pedir print da tela.
+
+**PASSO 2 — Colocar um dominio na conta (dois caminhos)**
+
+Perguntar primeiro: **"Voce ja tem um dominio que importa pra voce, ou prefere comprar um novo agora?"**
+
+**Caminho A — Ja tem um dominio (apontar pra Cloudflare):**
+- Esse caminho e GUIADO VIA UI, com o aluno **tirando print da tela e mandando aqui no Claude Code**. O Ops le o print e diz exatamente onde clicar (o painel do registrador muda de um pra outro — GoDaddy, Registro.br, Hostinger — entao guiar pela imagem, nao de cabeca).
+- Fluxo: no Cloudflare, "Add a site" → digitar o dominio → Cloudflare mostra **2 nameservers** → o aluno entra no painel ONDE o dominio foi comprado (o registrador) e **troca os nameservers** pelos do Cloudflare → volta no Cloudflare e confirma. A propagacao pode levar de minutos a algumas horas.
+- **IMPORTANTE — o Ops nao clica por ele aqui.** O painel do registrador e FORA do MCP. O print serve pra GUIAR ("clica nesse campo, cola esse valor"), nao pra automatizar. Depois que o dominio cai na Cloudflare, o MCP assume o resto.
+
+**Caminho B — Comprar um dominio novo (RECOMENDADO, mais rapido):**
+- Comprar o dominio **direto no Cloudflare** (Registrar) — preco de custo, sem marcacao na renovacao, e ja nasce conectado (PULA o passo dos nameservers). Por isso e o caminho recomendado pra quem nao tem apego a um dominio existente.
+- Explicar que esse e o dominio que vai ser usado **pros sites dele** — e que ele pode comprar mais de um aqui mesmo, ou apontar outros que ele tenha (Caminho A) depois.
+- **LIMITE QUE PRECISA SER DITO:** o Cloudflare Registrar vende `.com`, `.net`, `.io`, `.co`, etc. — mas **NAO vende `.com.br` (nem ccTLD brasileiro)**. Se o aluno quer especificamente um `.com.br`, ele compra no Registro.br e cai no Caminho A (apontar). Confirmar a disponibilidade do TLD na hora antes de prometer.
+
+> Se o aluno nao tem dominio e nao quer comprar agora: pular o Cloudflare (faz quando tiver). Nao bloqueia nada.
+
+**PASSO 3 — Conectar ao Claude Code via MCP oficial do Cloudflare**
+- Registrar com `claude mcp add` apontando pro servidor MCP **oficial** do Cloudflare (endpoint atual em developers.cloudflare.com — secao Agents/MCP). NUNCA editar o JSON de config na mao; sempre `claude mcp add`.
+- Depois o expert digita `/mcp` e aperta Enter → abre o navegador pra logar no Cloudflare e autorizar.
+
+**PASSO 4 — Salvar o status** em `business/vault/cloudflare.md` (conta criada, dominio(s) na conta, MCP conectado).
 
 **GATE DE VERIFICACAO (BLOCKING):**
 1. `claude mcp list` mostra o cloudflare
-2. O Claude consegue listar as zonas/dominios da conta (teste real)
+2. O Claude consegue listar as zonas/dominios da conta (teste real) — e o(s) dominio(s) esperado(s) aparecem
 → SE falhar: re-autenticar via `/mcp`; se persistir, conferir o endpoint do MCP nas docs do Cloudflare.
 
-→ Check: "Cloudflare conectado" ou "Pulado (sem dominio ainda)"
+→ Check: "Cloudflare conectado ({N} dominio(s) na conta)" ou "Pulado (sem dominio ainda)"
 
 ---
 
@@ -1000,6 +1079,22 @@ Conecta o cofre 1Password ao Auroq. O expert NAO abre terminal e NAO digita coma
 - NUNCA pedir pro expert colar o token na conversa. Se ele colar por conta propria, avisar que aquele token foi exposto e deve ser revogado e gerado de novo no painel do 1Password.
 - NUNCA imprimir, ecoar ou ler o valor do token em nenhum comando (`echo`, `cat`, `pbpaste` solto, etc.). O comando `conectar-1password` do CLI ja le a area de transferencia internamente sem expor nada.
 
+**Greeting (primeira fala ao acionar — mostrar SEMPRE, depois seguir pro passo 1):**
+
+```
+=== CONECTAR 1PASSWORD ===
+
+Vou ligar teu cofre 1Password ao Auroq. O que isso faz: conecto o
+1Password CLI (instalo se faltar), valido a conexao com seguranca e
+deixo o sistema guardando tuas senhas e tokens no cofre — voce nunca
+mais cola segredo no chat nem em arquivo solto.
+
+Voce nao abre terminal nem digita comando. Sua unica tarefa e copiar
+um codigo. Eu faco o resto.
+
+Deixa eu ver como teu cofre esta agora.
+```
+
 **Fluxo:**
 
 1. **Checar se ja esta conectado** (sem expor segredos):
@@ -1631,11 +1726,15 @@ CONFIGURACAO:
   *yolo         Trocar modo de permissao (auto/manual)
 
 GITHUB:
+  *sync         Puxar atualizacoes do GitHub (inicio de sessao)
   *pr           Criar Pull Request
   *status       Status do git + projetos
 
 DICA: *commit e o comando mais importante. Use no final de cada sessao.
 "Commit e o botao salvar do sistema."
+
+RITUAL MULTI-MAQUINA: Sentou → *sync · Levantou → *commit + *push
+Segunda maquina ou colaborador? O caminho e "npx auroq-os clone" (nunca init).
 ```
 
 ### *session

package/README.md

@@ -42,7 +42,9 @@ $companion
 
 | Comando | O que faz |
 |---------|-----------|
-| `auroq-os init` | Instala o Auroq OS (exige login na primeira vez) |
+| `auroq-os init` | Instala o Auroq OS do zero — primeira maquina (exige login na primeira vez) |
+| `auroq-os clone` | Continua o SEU negocio em outra maquina (ou na maquina de um colaborador) — baixa tudo do GitHub, ja instalado |
+| `auroq-os fix-gitignore` | Garante as protecoes de segredo no .gitignore (vault, .env, midia) e destraqueia segredos versionados |
 | `auroq-os login` | Forca novo login (substitui credencial atual) |
 | `auroq-os logout` | Encerra sessao local (remove `~/.arcane/credentials.json`) |
 | `auroq-os whoami` | Mostra usuario autenticado e status de acesso |
@@ -54,6 +56,24 @@ Dentro do projeto instalado, os mesmos checks ficam disponiveis como
 `npm run auroq:validate`. O instalador adiciona esses scripts sem sobrescrever
 os comandos existentes do seu negocio.
 
+### Segunda maquina (ou colaborador)
+
+O Auroq nao mora no computador — mora no GitHub. Pra trabalhar em outra maquina,
+**nao instale de novo**: clone o que ja existe.
+
+```bash
+# na maquina nova (Claude Code instalado e logado)
+npx auroq-os clone          # lista seus repos do GitHub e baixa o negocio inteiro
+cd meu-negocio
+claude
+/AuroqOS:agents:ops
+*conectar-1password         # reconectar o cofre (uma vez so nesta maquina)
+```
+
+Ritual diario em toda maquina: **sentou → `*sync` · levantou → `*commit` + `*push`**.
+Colaborador usa conta propria de tudo (GitHub via convite, assinatura Claude propria,
+cofre 1Password com escopo) — nunca a senha do dono.
+
 ## Estrutura
 
 ```

package/bin/auroq-os.js

@@ -14,9 +14,11 @@
 
 const path = require('path');
 const fs = require('fs-extra');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const auth = require('../lib/auth');
 
+const PKG_VERSION = require('../package.json').version;
+
 // ─── CORES ───────────────────────────────────────────────
 const PURPLE = '\x1b[38;2;120;80;200m';
 const GOLD = '\x1b[38;2;245;158;11m';
@@ -32,7 +34,7 @@ function showBanner() {
 
 ${PURPLE}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
 
-${PURPLE}${BOLD}       ▄▀█ █  █ █▀█ █▀█ █▀█${RESET}  ${DIM}OS v1.0${RESET}
+${PURPLE}${BOLD}       ▄▀█ █  █ █▀█ █▀█ █▀█${RESET}  ${DIM}OS v${PKG_VERSION}${RESET}
 ${PURPLE}${BOLD}       █▀█ █▄▄█ █▀▄ █▄█ ▀▀█${RESET}
 
 ${DIM}       Sistema Operacional de IA para Experts${RESET}
@@ -53,6 +55,131 @@ function error(msg) { console.log(`  ${PURPLE}✗${RESET} ${msg}`); }
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
+// Pergunta sim/nao no terminal. Funciona em TTY e com stdin encadeado (pipe).
+// Se o stdin estiver fechado (automatos/CI), question() nunca resolve — por isso
+// a corrida com o evento 'close': EOF vira resposta vazia, ou seja, "nao".
+async function askYesNo(question) {
+  const readline = require('node:readline/promises');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const closed = new Promise(resolve => rl.once('close', () => resolve('')));
+    const answer = String(await Promise.race([rl.question(question), closed])).trim().toLowerCase();
+    return answer === 's' || answer === 'sim' || answer === 'y' || answer === 'yes';
+  } catch {
+    return false;
+  } finally {
+    rl.close();
+  }
+}
+
+// ─── PROTECAO DE SEGREDOS (gitignore canonico) ───────────
+// Gerado por codigo, nao copiado de arquivo: o tarball do npm nem sempre
+// preserva .gitignore, e o merge preserva as linhas proprias do expert.
+const GITIGNORE_PROTECTIONS = [
+  ['Segredos — NUNCA sobem pro GitHub', ['.env', '.env.local', '.env.*.local', '.npmrc', 'business/vault/', '*.key', '*.pem']],
+  ['Runtime — se recria sozinho em cada maquina', ['node_modules/', '.auroq/', '.synapse/sessions/', '.tmp/', '*.tmp', '*.log']],
+  ['Skills do Codex — geradas por maquina', ['.agents/skills/']],
+  ['Sistema operacional', ['.DS_Store', 'Thumbs.db']],
+  ['Midia pesada — fica no Drive, nao no repo', ['*.png', '*.jpeg', '*.jpg', '*.mp4', '*.mov', '*.mp3', '*.wav']],
+];
+
+async function ensureGitignore(targetDir) {
+  const giPath = path.join(targetDir, '.gitignore');
+  const existing = (await fs.pathExists(giPath)) ? await fs.readFile(giPath, 'utf8') : '';
+  const have = new Set(existing.split('\n').map(l => l.trim()).filter(Boolean));
+  const missingBlocks = [];
+  for (const [comment, lines] of GITIGNORE_PROTECTIONS) {
+    const missing = lines.filter(l => !have.has(l));
+    if (missing.length) missingBlocks.push(`# ${comment}\n${missing.join('\n')}`);
+  }
+  if (!missingBlocks.length) return [];
+  const base = existing.trim().length ? existing.replace(/\s*$/, '\n\n') : '';
+  const header = '# ── Protecoes do Auroq OS (adicionadas automaticamente) ──\n';
+  await fs.writeFile(giPath, base + header + missingBlocks.join('\n\n') + '\n');
+  return missingBlocks.flatMap(b => b.split('\n').filter(l => l && !l.startsWith('#')));
+}
+
+// Tira do controle de versao segredos que ja foram rastreados (ficam no disco).
+async function untrackSecrets(targetDir) {
+  if (!(await fs.pathExists(path.join(targetDir, '.git')))) return [];
+  let tracked = [];
+  try {
+    const out = execFileSync('git', ['ls-files', '--', 'business/vault', '.env', '.env.local', '*.key', '*.pem', '.npmrc'], { cwd: targetDir, encoding: 'utf8' });
+    tracked = out.split('\n').map(s => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+  if (!tracked.length) return [];
+  try {
+    execFileSync('git', ['rm', '-r', '--cached', '--quiet', '--', ...tracked], { cwd: targetDir, stdio: 'pipe' });
+  } catch {
+    return [];
+  }
+  return tracked;
+}
+
+async function applySecretProtections(targetDir) {
+  const added = await ensureGitignore(targetDir);
+  if (added.length) {
+    success(`Protecoes adicionadas ao .gitignore (${added.length} regras: vault, .env, runtime, midia)`);
+  } else {
+    success('.gitignore ja protege segredos e runtime');
+  }
+  const untracked = await untrackSecrets(targetDir);
+  if (untracked.length) {
+    warn(`${untracked.length} arquivo(s) sensivel(is) removido(s) do controle de versao (continuam no seu disco):`);
+    for (const f of untracked.slice(0, 8)) log(`${DIM}    - ${f}${RESET}`);
+    if (untracked.length > 8) log(`${DIM}    ... e mais ${untracked.length - 8}${RESET}`);
+    warn('No proximo commit isso vira permanente.');
+    let hasRemote = false;
+    try { hasRemote = execFileSync('git', ['remote'], { cwd: targetDir, encoding: 'utf8' }).trim().length > 0; } catch { /* sem git */ }
+    if (hasRemote) {
+      warn(`${GOLD}IMPORTANTE: esses arquivos podem ja ter subido pro GitHub em commits antigos.${RESET}`);
+      warn(`${GOLD}Troque as chaves que estavam neles — peca ajuda ao Ops: "minhas chaves do vault${RESET}`);
+      warn(`${GOLD}podem ter vazado no git, me ajuda a trocar e limpar".${RESET}`);
+    }
+  }
+  return { added, untracked };
+}
+
+// ─── HEALTH CHECK (compartilhado por init e clone) ───────
+const HEALTH_CHECKS = [
+  ['.auroq-core/constitution.md', 'Constitution'],
+  ['.claude/CLAUDE.md', 'CLAUDE.md'],
+  ['.claude/hooks/synapse-engine.cjs', 'Synapse Hook'],
+  ['agents/companion/agents/companion.md', 'Companion'],
+  ['agents/organizer/agents/organizer.md', 'Organizer'],
+  ['.claude/commands/AuroqOS/agents/ops.md', 'Ops'],
+  ['agents/squad-forge/agents/forge-chief.md', 'Squad Forge'],
+  ['agents/mind-forge/agents/forge-chief.md', 'Mind Forge'],
+  ['agents/worker-forge/agents/worker-chief.md', 'Worker Forge'],
+  ['agents/clone-forge/agents/clone-forge-chief.md', 'Clone Forge'],
+  ['agents/etlmaker/agents/etl-chief.md', 'ETLmaker'],
+  ['business/cockpit.md', 'Cockpit'],
+  ['.synapse/manifest', 'Synapse Manifest'],
+  ['AGENTS.md', 'Codex AGENTS.md'],
+  ['.agents/skills/companion/SKILL.md', 'Codex Companion'],
+  ['.agents/skills/ops/SKILL.md', 'Codex Ops'],
+  ['scripts/validate-hybrid.mjs', 'Validador hibrido'],
+];
+
+async function runHealthChecks(targetDir) {
+  let passed = 0;
+  for (const [file, label] of HEALTH_CHECKS) {
+    if (await fs.pathExists(path.join(targetDir, file))) {
+      passed++;
+    } else {
+      warn(`${label} nao encontrado`);
+    }
+  }
+  if (passed === HEALTH_CHECKS.length) {
+    success(`${passed}/${HEALTH_CHECKS.length} verificacoes OK`);
+  } else {
+    warn(`${passed}/${HEALTH_CHECKS.length} verificacoes OK — rode *bootstrap pra corrigir`);
+  }
+  return { passed, total: HEALTH_CHECKS.length };
+}
+
 // ─── INSTALACAO ──────────────────────────────────────────
 async function init() {
   showBanner();
@@ -78,6 +205,27 @@ async function init() {
     process.exit(1);
   }
 
+  // ─── GUARDRAIL: segunda maquina usa clone, nao init
+  // So pergunta em instalacao NOVA (pasta sem .auroq-core) — update/reinstall pula direto.
+  const isNewInstall = !(await fs.pathExists(path.join(targetDir, '.auroq-core')));
+  if (isNewInstall && process.env.AUROQ_INIT_MODE !== 'novo') {
+    const jaUsa = await askYesNo(`  Voce JA usa o Auroq OS em outra maquina e quer continuar o MESMO negocio aqui? ${DIM}(s/N)${RESET} `);
+    if (jaUsa) {
+      log('');
+      log(`${BOLD}Entao o caminho certo NAO e instalar do zero — e clonar o que ja existe.${RESET}`);
+      log('');
+      log('O seu negocio ja vive no GitHub (o Ops fez isso no Bootstrap 1).');
+      log('Instalar do zero aqui criaria um segundo Auroq desconectado do primeiro.');
+      log('');
+      log(`Rode: ${CYAN}npx auroq-os clone${RESET}`);
+      log('');
+      log(`${DIM}Ele baixa o seu negocio inteiro do GitHub — sistema, memoria e documentos —${RESET}`);
+      log(`${DIM}e deixa tudo pronto. Depois e so reconectar o cofre com *conectar-1password.${RESET}`);
+      log('');
+      process.exit(0);
+    }
+  }
+
   log(`${DIM}Instalando em: ${targetDir}${RESET}\n`);
 
   // ─── Fase 1: Verificar pre-requisitos
@@ -256,7 +404,8 @@ async function init() {
     'docs/knowledge/expert-business/publico-alvo.md',
 
     // Root
-    '.gitignore',
+    // (.gitignore NAO entra aqui: e gerado por codigo em applySecretProtections —
+    //  o tarball do npm nem sempre o preserva, e a copia cega apagaria linhas do expert)
     '.env.example',
     'README.md',
 
@@ -456,43 +605,15 @@ async function init() {
     success('Git ja inicializado');
   }
 
+  // Protecoes de segredo: .gitignore canonico + destraquear o que nao pode viajar.
+  // Roda em toda instalacao E em todo update (o update reexecuta o init) — e assim
+  // que alunos com instalacao antiga sao migrados automaticamente.
+  step('Protegendo segredos...');
+  await applySecretProtections(targetDir);
+
   // ─── Fase 7: Health check rapido
   step('Verificando integridade...');
-
-  const checks = [
-    ['.auroq-core/constitution.md', 'Constitution'],
-    ['.claude/CLAUDE.md', 'CLAUDE.md'],
-    ['.claude/hooks/synapse-engine.cjs', 'Synapse Hook'],
-    ['agents/companion/agents/companion.md', 'Companion'],
-    ['agents/organizer/agents/organizer.md', 'Organizer'],
-    ['.claude/commands/AuroqOS/agents/ops.md', 'Ops'],
-    ['agents/squad-forge/agents/forge-chief.md', 'Squad Forge'],
-    ['agents/mind-forge/agents/forge-chief.md', 'Mind Forge'],
-    ['agents/worker-forge/agents/worker-chief.md', 'Worker Forge'],
-    ['agents/clone-forge/agents/clone-forge-chief.md', 'Clone Forge'],
-    ['agents/etlmaker/agents/etl-chief.md', 'ETLmaker'],
-    ['business/cockpit.md', 'Cockpit'],
-    ['.synapse/manifest', 'Synapse Manifest'],
-    ['AGENTS.md', 'Codex AGENTS.md'],
-    ['.agents/skills/companion/SKILL.md', 'Codex Companion'],
-    ['.agents/skills/ops/SKILL.md', 'Codex Ops'],
-    ['scripts/validate-hybrid.mjs', 'Validador hibrido'],
-  ];
-
-  let passed = 0;
-  for (const [file, label] of checks) {
-    if (await fs.pathExists(path.join(targetDir, file))) {
-      passed++;
-    } else {
-      warn(`${label} nao encontrado`);
-    }
-  }
-
-  if (passed === checks.length) {
-    success(`${passed}/${checks.length} verificacoes OK`);
-  } else {
-    warn(`${passed}/${checks.length} verificacoes OK — rode *bootstrap pra corrigir`);
-  }
+  await runHealthChecks(targetDir);
 
   // ─── Resultado final
   console.log(`
@@ -527,11 +648,182 @@ ${DIM}  Meta Squads (criadores de agentes):${RESET}
 ${DIM}  Claude Code e Codex sao runtimes oficiais. Escolha um por sessao; ambos usam os mesmos agentes e arquivos.${RESET}
 
 ${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
-${DIM}  Auroq OS v2.1.0 — Sistema Operacional de IA para Experts${RESET}
+${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RESET}
 ${DIM}  "Tu aumentaste o meu poder como do boi selvagem." — Sl 92:10${RESET}
 `);
 }
 
+// ─── CLONE (segunda maquina / colaborador) ───────────────
+// O Auroq nao mora no computador — mora no GitHub. Clonar JA E a instalacao:
+// o sistema vem inteiro no clone. Este comando so completa o que nao viaja
+// (dependencias, skills do Codex) e confere a integridade.
+async function clone(repoArg) {
+  showBanner();
+  await sleep(300);
+
+  const cwd = process.cwd();
+
+  if (await fs.pathExists(path.join(cwd, '.auroq-core'))) {
+    error('Voce ja esta DENTRO de um projeto Auroq.');
+    error('Va pra pasta onde quer criar a copia (ex: cd ~/Documents) e rode de novo.');
+    process.exit(1);
+  }
+
+  log(`${DIM}Clonando o seu negocio para: ${cwd}${RESET}\n`);
+
+  // ─── Fase 1: Pre-requisitos
+  step('Verificando pre-requisitos...');
+  try {
+    execSync('git --version', { encoding: 'utf8', stdio: 'pipe' });
+    success('Git instalado');
+  } catch {
+    error('Git nao encontrado. Instale git primeiro.');
+    process.exit(1);
+  }
+
+  // ─── Fase 1b: Gate de acesso (mesmo do init)
+  step('Verificando acesso...');
+  const testAuthBypass = process.env.NODE_ENV === 'test' && process.env.AUROQ_SKIP_AUTH === '1';
+  if (testAuthBypass) {
+    success('Gate de acesso ignorado em ambiente de teste');
+  } else {
+    try {
+      await auth.getValidSession();
+    } catch (e) {
+      error(`Falha na autenticacao: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // ─── Fase 2: Resolver o repositorio
+  let repoRef = repoArg;
+  if (!repoRef) {
+    step('Localizando o seu negocio no GitHub...');
+    try {
+      execSync('gh --version', { encoding: 'utf8', stdio: 'pipe' });
+    } catch {
+      error('GitHub CLI (gh) nao encontrado e nenhum repositorio informado.');
+      error('');
+      error('Duas opcoes:');
+      error(`  1. Instale o gh (https://cli.github.com) e rode de novo: ${CYAN}npx auroq-os clone${RESET}`);
+      error(`  2. Ou informe o endereco direto: ${CYAN}npx auroq-os clone https://github.com/SEU-USUARIO/SEU-REPO.git${RESET}`);
+      process.exit(1);
+    }
+    try {
+      execSync('gh auth status', { encoding: 'utf8', stdio: 'pipe' });
+      success('GitHub conectado');
+    } catch {
+      warn('GitHub nao conectado nesta maquina — abrindo o login...');
+      try {
+        execSync('gh auth login', { stdio: 'inherit' });
+      } catch {
+        error('Login no GitHub falhou. Rode "gh auth login" e tente de novo.');
+        process.exit(1);
+      }
+    }
+    let repos = [];
+    try {
+      const out = execSync('gh repo list --json nameWithOwner,updatedAt --limit 30', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      repos = JSON.parse(out);
+    } catch { /* lista vazia tratada abaixo */ }
+    if (!repos.length) {
+      error('Nenhum repositorio encontrado na sua conta do GitHub.');
+      error(`Informe o endereco direto: ${CYAN}npx auroq-os clone https://github.com/SEU-USUARIO/SEU-REPO.git${RESET}`);
+      process.exit(1);
+    }
+    const prompts = require('prompts');
+    const resp = await prompts({
+      type: 'select',
+      name: 'repo',
+      message: 'Qual repositorio e o seu negocio?',
+      choices: repos.map(r => ({ title: r.nameWithOwner, value: r.nameWithOwner })),
+    }, { onCancel: () => { error('Cancelado.'); process.exit(1); } });
+    repoRef = resp.repo;
+  }
+
+  // ─── Fase 3: Clonar
+  step(`Baixando o negocio inteiro (${repoRef})...`);
+  const destName = path.basename(String(repoRef).replace(/[\\/]+$/, '')).replace(/\.git$/, '');
+  const destDir = path.join(cwd, destName);
+  if (await fs.pathExists(destDir)) {
+    error(`A pasta "${destName}" ja existe aqui. Entre nela (cd ${destName}) ou rode em outro lugar.`);
+    process.exit(1);
+  }
+  const isOwnerRepo = /^[\w.-]+\/[\w.-]+$/.test(String(repoRef));
+  try {
+    if (isOwnerRepo) {
+      execFileSync('gh', ['repo', 'clone', String(repoRef)], { cwd, stdio: 'inherit' });
+    } else {
+      execFileSync('git', ['clone', String(repoRef), destName], { cwd, stdio: 'inherit' });
+    }
+    success('Negocio baixado do GitHub');
+  } catch {
+    error('Falha ao clonar. Confira o endereco e o seu acesso ao repositorio.');
+    process.exit(1);
+  }
+
+  // ─── Fase 4: Reconhecer o projeto
+  if (await fs.pathExists(path.join(destDir, '.auroq-core'))) {
+    success('Projeto Auroq reconhecido — o sistema veio inteiro no clone');
+  } else {
+    warn('Este repositorio nao parece um projeto Auroq (.auroq-core ausente).');
+    warn('Se for o repo errado, apague a pasta e rode de novo com o repo certo.');
+  }
+
+  // ─── Fase 5: Protecoes de segredo
+  step('Protegendo segredos...');
+  await applySecretProtections(destDir);
+
+  // ─── Fase 6: Dependencias (nao viajam no git — de proposito)
+  step('Instalando dependencias...');
+  try {
+    execSync('npm install --silent', { cwd: destDir, stdio: 'pipe' });
+    success('Dependencias instaladas');
+  } catch {
+    warn('npm install falhou — entre na pasta e rode "npm install" manualmente');
+  }
+
+  // ─── Fase 7: Skills do Codex (geradas por maquina)
+  if (await fs.pathExists(path.join(destDir, 'scripts', 'sync-codex-skills.mjs'))) {
+    step('Configurando Codex CLI...');
+    try {
+      execSync('node scripts/sync-codex-skills.mjs --clean', { cwd: destDir, stdio: 'pipe' });
+      success('Skills locais do Codex regeneradas');
+    } catch {
+      warn('Sync de skills do Codex falhou — rode "npx auroq-os sync-codex" depois');
+    }
+  }
+
+  // ─── Fase 8: Health check
+  step('Verificando integridade...');
+  await runHealthChecks(destDir);
+
+  // ─── Resultado final
+  console.log(`
+${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
+
+${GREEN}${BOLD}  Negocio clonado com sucesso. Esta maquina esta pronta.${RESET}
+
+${DIM}  Uma vez so, nesta maquina:${RESET}
+
+    ${CYAN}cd ${destName}${RESET}
+    ${CYAN}claude${RESET} ${DIM}ou${RESET} ${CYAN}codex${RESET}
+    ${CYAN}/AuroqOS:agents:ops${RESET}
+    ${CYAN}*conectar-1password${RESET}   ${DIM}— reconectar o cofre de senhas${RESET}
+    ${DIM}(se pedir login do sistema: ${RESET}${CYAN}npx auroq-os login${RESET}${DIM})${RESET}
+
+${DIM}  Ritual de todo dia, em toda maquina:${RESET}
+
+    ${GOLD}Sentou${RESET}    → ${CYAN}*sync${RESET}              ${DIM}— puxa o que mudou nas outras maquinas${RESET}
+    ${GOLD}Levantou${RESET}  → ${CYAN}*commit${RESET} + ${CYAN}*push${RESET}   ${DIM}— entrega o seu trabalho pro GitHub${RESET}
+
+${DIM}  Nunca levante da maquina com trabalho nao entregue.${RESET}
+
+${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
+${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RESET}
+`);
+}
+
 // ─── CLI ─────────────────────────────────────────────────
 const command = process.argv[2];
 
@@ -540,6 +832,19 @@ if (command === 'init' || command === 'install') {
     error(`Falha na instalacao: ${err.message}`);
     process.exit(1);
   });
+} else if (command === 'clone') {
+  clone(process.argv[3]).catch(err => {
+    error(`Falha ao clonar: ${err.message}`);
+    process.exit(1);
+  });
+} else if (command === 'fix-gitignore') {
+  (async () => {
+    step('Protegendo segredos...');
+    await applySecretProtections(process.cwd());
+  })().catch(err => {
+    error(`Falha: ${err.message}`);
+    process.exit(1);
+  });
 } else if (command === 'login') {
   auth.interactiveLogin().catch(err => {
     error(`Falha no login: ${err.message}`);
@@ -594,7 +899,9 @@ if (command === 'init' || command === 'install') {
 } else {
   showBanner();
   log(`${BOLD}Comandos disponiveis:${RESET}`);
-  log(`  ${CYAN}init${RESET}     Instalar Auroq OS no diretorio atual`);
+  log(`  ${CYAN}init${RESET}     Instalar Auroq OS no diretorio atual (primeira maquina)`);
+  log(`  ${CYAN}clone${RESET}    Continuar o seu negocio NESTA maquina (segunda maquina / colaborador)`);
+  log(`  ${CYAN}fix-gitignore${RESET}  Garantir protecoes de segredo no .gitignore (vault, .env)`);
   log(`  ${CYAN}login${RESET}    Autenticar com email + senha da Mentoria Arcane`);
   log(`  ${CYAN}logout${RESET}   Encerrar sessao local`);
   log(`  ${CYAN}whoami${RESET}   Mostrar usuario autenticado`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auroq-os",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "Auroq OS — Sistema Operacional de IA para Experts",
   "bin": {
     "auroq-os": "bin/auroq-os.js"