auroq-os 2.1.2 → 2.1.4

package/.auroq-core/core-config.yaml

@@ -1,7 +1,7 @@
 project:
   name: "Auroq OS"
   type: greenfield
-  version: 2.1.2
+  version: 2.1.3
   installedAt: '2026-03-16'
 
 ide:

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

@@ -63,6 +63,8 @@ commands:
     description: "Setup do nucleo (Bootstrap 1) — ambiente, MCPs, GitHub, Vercel, Supabase, Companion"
   - name: bootstrap-2
     description: "Conexoes extras (Bootstrap 2, opcional recomendado) — valida o cofre e conecta Cloudflare, Drive, Gmail, Calendar, Notion e Canva"
+  - name: conectar-1password
+    description: "Conectar o cofre 1Password ao Auroq — o expert so copia o token (Ctrl+C), o Ops roda o resto"
   - name: yolo
     description: "Trocar modo de permissao do Claude Code (auto/acceptEdits/default)"
   - name: install
@@ -199,6 +201,8 @@ A validacao e ONLINE e obrigatoria, sem fallback offline — e a mesma trava do
 
 **Passo 4 — Aplicar atualizacao (framework only)**
 
+> **FONTE DA LISTA (OBRIGATORIO):** a lista ATUALIZA abaixo e a da versao INSTALADA — ela pode nao conhecer arquivos que a versao nova introduziu. ANTES de aplicar, abra o ops.md NOVO em `/tmp/auroq-update/package/.claude/commands/AuroqOS/agents/ops.md`, secao `*update-auroq`, e siga a lista ATUALIZA DE LA (mantendo as protecoes de NAO ATUALIZA de la tambem). SE nao conseguir ler o arquivo novo, fallback deterministico: rodar `node /tmp/auroq-update/package/bin/auroq-os.js init` na raiz do projeto (sobrescreve framework, preserva dados do expert) — mas AVISE antes se o `.claude/CLAUDE.md` foi personalizado, pois o init sobrescreve ele.
+
 **ATUALIZA (L1/L2/L3 — framework):**
 - `.auroq-core/` — constitution, config, synapse engine, development docs, dna operacional
 - `.claude/commands/AuroqOS/` — agentes core (ops.md)
@@ -853,8 +857,9 @@ Conexoes extras — OPCIONAL, RECOMENDADO. Roda depois do bootstrap principal, q
    - `OP_SERVICE_ACCOUNT_TOKEN` esta definido, mostrando somente `configurado` ou `ausente` — NUNCA imprimir o valor
    - uma leitura de item de teste no vault funciona, quando existir
 3. SE a verificacao passar: definir o modo desta execucao como **`1password`**. Toda nova credencial sensivel deve ser salva no vault `Claude`; em `business/vault/`, guardar apenas metadados/status e referencias `op://...`, nunca o valor.
-4. SE nao configurou ou a verificacao falhar, explicar as duas opcoes e pedir uma escolha explicita:
-   - **Voltar ao Step anterior e configurar o 1Password (RECOMENDADO):** parar o Bootstrap 2 sem marcar conexoes como concluidas. Quando o aluno voltar, repetir este pre-gate.
+4. SE nao configurou ou a verificacao falhar, explicar as opcoes e pedir uma escolha explicita:
+   - **Conectar agora pelo Ops (RECOMENDADO se ele ja tem o token):** rodar `*conectar-1password` — o expert so copia o token e o Ops faz o resto. Ao terminar, repetir este pre-gate.
+   - **Voltar ao Step anterior da plataforma:** se ele ainda nao criou a conta/token do 1Password. Parar o Bootstrap 2 sem marcar conexoes como concluidas. Quando o aluno voltar, repetir este pre-gate.
    - **Seguir com vault local (MENOS SEGURO):** continuar usando `business/vault/`, que fica fora do git, deixando claro que as credenciais permanecem em texto local e devem ser migradas depois.
 5. Registrar somente a escolha e o estado em `business/vault/credential-storage.md`: `mode: 1password` ou `mode: local`, data e verificacoes realizadas. NUNCA registrar token, senha ou chave nesse arquivo quando o modo for 1Password.
 
@@ -987,6 +992,44 @@ O fluxo e sempre o mesmo:
 Se o expert quiser conectar outros servicos que aparecem nas Integrations do claude.ai no futuro, o fluxo e esse mesmo.
 
 
+### *conectar-1password
+
+Conecta o cofre 1Password ao Auroq. O expert NAO abre terminal e NAO digita comando — ele so copia o token e o Ops roda tudo. Aciona por linguagem natural ("conecta meu 1Password", "configura o cofre") ou pelo comando.
+
+**REGRA DE OURO — o token NUNCA passa pelo chat:**
+- 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.
+
+**Fluxo:**
+
+1. **Checar se ja esta conectado** (sem expor segredos):
+   ```bash
+   op whoami
+   ```
+   - SE funciona → ja conectado. Informar e encerrar (rodar de novo so se o expert quiser trocar o token).
+   - SE `op` nem existe ou falha → seguir.
+
+2. **Confirmar que o expert tem o token em maos.** Perguntar: "Voce ja gerou o seu token de Service Account no 1Password (aquele codigo grandao que comeca com `ops_`)?" 
+   - SE nao → orientar a voltar no Step Sistema de Senhas e Credenciais da plataforma e gerar. Parar aqui ate ele ter o token.
+   - ATENCAO: o 1Password mostra o token UMA vez, na criacao. Se o expert fechou a tela sem salvar, precisa gerar um novo.
+
+3. **Pedir a UNICA acao dele:** "Copia o token agora (Cmd+C no Mac / Ctrl+C no Windows) e me avisa quando copiar. NAO cola ele aqui no chat — so copia."
+
+4. **Quando ele confirmar, rodar:**
+   ```bash
+   npx auroq-os conectar-1password
+   ```
+   O comando le o token direto da area de transferencia, instala o 1Password CLI se faltar, valida a conexao online e salva permanente. O output NUNCA contem o token — e seguro.
+
+5. **Interpretar o resultado pro expert:**
+   - `✅ 1Password conectado com sucesso` → confirmar com gate real: rodar `op vault list` e mostrar que o cofre apareceu. Dai em diante toda credencial nova vai pro vault via `op`, nunca em texto plano.
+   - `nao contem um token valido` → ele copiou outra coisa por cima (o clipboard guarda so a ULTIMA copia). Pedir pra copiar o token de novo e repetir o passo 4. Sem stress, acontece.
+   - `token foi lido mas a conexao falhou` → token revogado/expirado ou sem internet. Orientar a gerar token novo no painel se a internet estiver ok.
+
+6. **Pos-conexao por sistema:**
+   - **Mac:** os proximos comandos ja enxergam a conexao nesta mesma sessao. Nada a fazer.
+   - **Windows:** a sessao atual NAO enxerga a conexao nova. Orientar: fechar TODAS as janelas do terminal (ou o VS Code inteiro), abrir de novo e voltar pro Claude. Verificar com `op whoami` quando ele voltar.
+
 ### *pr
 1. Verificar branch atual
 2. `git log` — resumir commits desde main

package/README.md

@@ -47,6 +47,7 @@ $companion
 | `auroq-os logout` | Encerra sessao local (remove `~/.arcane/credentials.json`) |
 | `auroq-os whoami` | Mostra usuario autenticado e status de acesso |
 | `auroq-os sync-codex` | Regenera e verifica as skills locais do Codex |
+| `auroq-os conectar-1password` | Conecta o 1Password CLI — le o token de Service Account direto do Ctrl+C (nunca digitado nem exposto), instala o `op` se faltar, valida online e salva permanente (Mac/Windows) |
 
 Dentro do projeto instalado, os mesmos checks ficam disponiveis como
 `npm run auroq:sync:codex`, `npm run auroq:sync:codex:check` e

package/bin/auroq-os.js

@@ -392,19 +392,9 @@ async function init() {
   }
   success(`${dirsCopied} modulos instalados (Meta Squads + scripts)`);
 
-  // ─── Fase 4c: Adaptador Codex CLI (skills locais por projeto)
-  step('Configurando Codex CLI...');
-  try {
-    execSync('node scripts/sync-codex-skills.mjs --clean', { cwd: targetDir, stdio: 'pipe' });
-    execSync('node scripts/sync-codex-skills.mjs --check', { cwd: targetDir, stdio: 'pipe' });
-    success('Codex CLI pronto — skills locais verificadas ($companion, $ops, etc.)');
-  } catch {
-    warn('Sync de skills do Codex falhou — rode "npx auroq-os sync-codex" para diagnosticar');
-  }
-
-  // ─── Fase 5: Package.json + npm install
-  step('Configurando dependencias...');
-
+  // O package.json precisa existir ANTES do sync do Codex: o ownership das
+  // skills usa o name do package — gerar skills antes dele criava marcador
+  // com o nome da pasta e todo sync seguinte recusava ("foreign").
   const pkgPath = path.join(targetDir, 'package.json');
   if (!(await fs.pathExists(pkgPath))) {
     await fs.writeJSON(pkgPath, {
@@ -418,6 +408,19 @@ async function init() {
     }, { spaces: 2 });
   }
 
+  // ─── Fase 4c: Adaptador Codex CLI (skills locais por projeto)
+  step('Configurando Codex CLI...');
+  try {
+    execSync('node scripts/sync-codex-skills.mjs --clean', { cwd: targetDir, stdio: 'pipe' });
+    execSync('node scripts/sync-codex-skills.mjs --check', { cwd: targetDir, stdio: 'pipe' });
+    success('Codex CLI pronto — skills locais verificadas ($companion, $ops, etc.)');
+  } catch {
+    warn('Sync de skills do Codex falhou — rode "npx auroq-os sync-codex" para diagnosticar');
+  }
+
+  // ─── Fase 5: npm install
+  step('Configurando dependencias...');
+
   // Comandos namespaced: adiciona a manutencao Auroq sem sobrescrever scripts do negocio.
   const targetPackage = await fs.readJSON(pkgPath);
   targetPackage.scripts = targetPackage.scripts || {};
@@ -563,6 +566,12 @@ if (command === 'init' || command === 'install') {
   log(`  3. Digite: ${CYAN}*update${RESET}`);
   log('');
   log(`${DIM}O Ops atualiza o framework sem tocar nos seus dados.${RESET}`);
+} else if (command === 'conectar-1password' || command === 'connect-1password') {
+  const onepassword = require('../lib/onepassword');
+  onepassword.connect().catch(e => {
+    error(`Falha ao conectar 1Password: ${e.message}`);
+    process.exit(1);
+  });
 } else if (command === 'sync-codex') {
   // Regenera as skills do Codex CLI a partir dos comandos atuais do projeto.
   try {
@@ -583,6 +592,7 @@ if (command === 'init' || command === 'install') {
   log(`  ${CYAN}check-access${RESET}  Validar acesso ativo (online; exit 0=ativo, 1=bloqueado)`);
   log(`  ${CYAN}update${RESET}   Atualizar (via Ops dentro do Claude Code)`);
   log(`  ${CYAN}sync-codex${RESET}  Gerar e verificar as skills locais do Codex CLI ($nome)`);
+  log(`  ${CYAN}conectar-1password${RESET}  Conectar o 1Password CLI (token lido do Ctrl+C, nunca digitado)`);
   log('');
   log(`${DIM}Uso: npx auroq-os init${RESET}`);
   log('');

package/lib/onepassword.js

@@ -0,0 +1,268 @@
+'use strict';
+
+/**
+ * Auroq OS — Conexao 1Password CLI
+ *
+ * Fluxo seguro: o aluno copia o token de Service Account (ops_...) e roda
+ * `npx auroq-os conectar-1password`. O token e lido direto da area de
+ * transferencia, validado online e gravado de forma persistente — nunca e
+ * digitado, impresso ou passado por argumento de linha de comando.
+ *
+ * @module auroq-os/onepassword
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+const { execSync, execFileSync } = require('child_process');
+
+const PURPLE = '\x1b[38;2;120;80;200m';
+const GOLD = '\x1b[38;2;245;158;11m';
+const CYAN = '\x1b[38;2;34;211;238m';
+const GREEN = '\x1b[38;2;52;211;153m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+function log(msg) { console.log(`  ${msg}`); }
+function step(msg) { console.log(`\n  ${CYAN}▸${RESET} ${msg}`); }
+function ok(msg) { console.log(`  ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`  ${GOLD}!${RESET} ${msg}`); }
+function err(msg) { console.log(`  ${PURPLE}✗${RESET} ${msg}`); }
+
+const TOKEN_VAR = 'OP_SERVICE_ACCOUNT_TOKEN';
+
+// ─── Helpers puros (testaveis) ───────────────────────────
+
+function isValidToken(value) {
+  return typeof value === 'string' && /^ops_[A-Za-z0-9_=+/.-]{20,}$/.test(value);
+}
+
+/**
+ * Remove qualquer linha antiga do token e devolve o conteudo novo do arquivo
+ * de ambiente com a linha export atualizada no final.
+ */
+const ENV_COMMENT = '# 1Password CLI - Service Account (gravado pelo Auroq OS)';
+
+const TOKEN_LINE_RE = /^\s*(export\s+)?OP_SERVICE_ACCOUNT_TOKEN=/;
+
+function upsertEnvFileContent(existing, token) {
+  // Remove apenas linhas que DEFINEM a variavel (nao comentarios do usuario
+  // que so mencionam o nome) + o marcador de bloco do Auroq.
+  const kept = String(existing || '')
+    .split('\n')
+    .filter((line) => !TOKEN_LINE_RE.test(line) && line.trim() !== ENV_COMMENT);
+  while (kept.length > 0 && kept[kept.length - 1].trim() === '') kept.pop();
+  kept.push('');
+  kept.push(ENV_COMMENT);
+  kept.push(`export ${TOKEN_VAR}='${token}'`);
+  kept.push('');
+  return kept.join('\n');
+}
+
+// ─── Deteccao e instalacao do op ─────────────────────────
+
+function hasCommand(cmd) {
+  try {
+    const probe = process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`;
+    execSync(probe, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function opVersion() {
+  try {
+    return execSync('op --version', { stdio: 'pipe', encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function installOp() {
+  if (process.platform === 'darwin') {
+    if (!hasCommand('brew')) {
+      err('Homebrew nao encontrado. Instale em https://brew.sh e rode este comando de novo.');
+      return false;
+    }
+    log(`${DIM}Instalando via Homebrew (pode levar um minuto)...${RESET}`);
+    try {
+      execSync('brew install --cask 1password-cli', { stdio: 'pipe', maxBuffer: 64 * 1024 * 1024 });
+      return true;
+    } catch {
+      err('Instalacao via Homebrew falhou. Tente manualmente: brew install --cask 1password-cli');
+      return false;
+    }
+  }
+
+  if (process.platform === 'win32') {
+    if (!hasCommand('winget')) {
+      err('winget nao encontrado. Instale o 1Password CLI manualmente:');
+      err('https://developer.1password.com/docs/cli/get-started/');
+      return false;
+    }
+    log(`${DIM}Instalando via winget (pode levar um minuto)...${RESET}`);
+    try {
+      execSync('winget install --id AgileBits.1Password.CLI --accept-source-agreements --accept-package-agreements', { stdio: 'pipe', maxBuffer: 64 * 1024 * 1024 });
+      return true;
+    } catch {
+      err('Instalacao via winget falhou. Tente manualmente: winget install AgileBits.1Password.CLI');
+      return false;
+    }
+  }
+
+  err('Instalacao automatica disponivel apenas no macOS e Windows.');
+  err('Instale o 1Password CLI manualmente: https://developer.1password.com/docs/cli/get-started/');
+  return false;
+}
+
+// ─── Clipboard (sem dependencia externa) ─────────────────
+
+function readClipboard() {
+  const opts = { stdio: 'pipe', encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 };
+  try {
+    if (process.platform === 'darwin') {
+      return execSync('pbpaste', opts);
+    }
+    if (process.platform === 'win32') {
+      return execSync('powershell -NoProfile -Command "Get-Clipboard -Raw"', opts);
+    }
+    // Linux: tenta xclip, depois xsel
+    if (hasCommand('xclip')) {
+      return execSync('xclip -selection clipboard -o', opts);
+    }
+    if (hasCommand('xsel')) {
+      return execSync('xsel --clipboard --output', opts);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Validacao online e persistencia ─────────────────────
+
+function testToken(token) {
+  try {
+    const out = execFileSync('op', ['whoami'], {
+      stdio: 'pipe',
+      encoding: 'utf8',
+      env: { ...process.env, [TOKEN_VAR]: token },
+    });
+    return out.trim();
+  } catch {
+    return null;
+  }
+}
+
+function persistToken(token) {
+  if (process.platform === 'win32') {
+    // Variavel de ambiente do usuario — token passa por env var, nunca por argv
+    const psEnv = { stdio: 'pipe', env: { ...process.env, AUROQ_OP_TOKEN: token } };
+    try {
+      execSync(
+        `powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('${TOKEN_VAR}', $env:AUROQ_OP_TOKEN, 'User')"`,
+        psEnv
+      );
+    } catch {
+      // Maquinas corporativas com Constrained Language Mode bloqueiam chamadas
+      // .NET — fallback via registro (Set-ItemProperty e cmdlet, permitido)
+      execSync(
+        `powershell -NoProfile -Command "Set-ItemProperty -Path 'HKCU:\\Environment' -Name '${TOKEN_VAR}' -Value $env:AUROQ_OP_TOKEN"`,
+        psEnv
+      );
+      warn('Gravado via registro (modo restrito detectado). Se o terminal novo nao enxergar, reinicie o computador uma vez.');
+    }
+    return 'variavel de ambiente do usuario (Windows)';
+  }
+
+  // macOS: sempre ~/.zshenv (zsh e o shell padrao do sistema).
+  // Linux: ~/.bashrc se o shell for bash, senao ~/.zshenv.
+  const shell = process.env.SHELL || '';
+  const envFile = (process.platform !== 'darwin' && shell.includes('bash'))
+    ? path.join(os.homedir(), '.bashrc')
+    : path.join(os.homedir(), '.zshenv');
+
+  const existing = fs.existsSync(envFile) ? fs.readFileSync(envFile, 'utf8') : '';
+  fs.writeFileSync(envFile, upsertEnvFileContent(existing, token), { mode: 0o600 });
+  return envFile.replace(os.homedir(), '~');
+}
+
+// ─── Comando principal ───────────────────────────────────
+
+async function connect() {
+  console.log(`\n${PURPLE}${BOLD}  Conectar 1Password — Auroq OS${RESET}`);
+
+  // 1. Garantir que o op existe
+  step('Verificando 1Password CLI...');
+  let version = opVersion();
+  if (!version) {
+    warn('1Password CLI (op) nao encontrado — instalando...');
+    if (!installOp()) process.exit(1);
+    version = opVersion();
+    if (!version) {
+      err('op instalado mas nao encontrado no PATH. Feche e abra o terminal, e rode de novo.');
+      process.exit(1);
+    }
+  }
+  ok(`1Password CLI v${version}`);
+
+  // 2. Ler o token da area de transferencia
+  step('Lendo token da area de transferencia...');
+  const raw = readClipboard();
+  if (raw === null) {
+    err('Nao consegui ler a area de transferencia neste sistema.');
+    process.exit(1);
+  }
+  const token = raw.replace(/\s/g, '');
+
+  if (!isValidToken(token)) {
+    err('A area de transferencia nao contem um token valido (deve comecar com ops_).');
+    log('');
+    log(`${BOLD}Como resolver:${RESET}`);
+    log(`  1. Abra o 1Password e copie o seu token de Service Account (${CYAN}Ctrl/Cmd + C${RESET})`);
+    log(`  2. ${BOLD}Sem copiar mais nada${RESET}, rode este comando de novo`);
+    process.exit(1);
+  }
+  ok('Token encontrado (formato valido)');
+
+  // 3. Validar online ANTES de gravar
+  step('Testando conexao com o 1Password...');
+  const whoami = testToken(token);
+  if (!whoami) {
+    err('O token foi lido mas a conexao falhou. Possiveis causas:');
+    log('  - Token revogado ou expirado — gere um novo no painel do 1Password');
+    log('  - Sem internet no momento — confira a conexao e rode de novo');
+    process.exit(1);
+  }
+  ok('Conexao validada');
+  console.log(whoami.split('\n').map((l) => `    ${DIM}${l}${RESET}`).join('\n'));
+
+  // 4. Gravar persistente
+  step('Salvando conexao...');
+  const where = persistToken(token);
+  ok(`Token salvo em ${where}`);
+
+  // 5. Resultado
+  const restartHint = process.platform === 'win32'
+    ? `${DIM}  Importante: feche TODAS as janelas do terminal (se usa VS Code ou${RESET}
+${DIM}  Windows Terminal, feche o programa inteiro) e abra de novo para${RESET}
+${DIM}  que eles enxerguem a conexao nova.${RESET}`
+    : `${DIM}  Importante: feche e abra de novo o terminal (e o Claude/Codex) para${RESET}
+${DIM}  que eles enxerguem a conexao nova.${RESET}`;
+
+  console.log(`
+${GREEN}${BOLD}  ✅ 1Password conectado com sucesso.${RESET}
+
+${DIM}  A conexao e permanente — voce nao precisa repetir este processo.${RESET}
+${restartHint}
+`);
+}
+
+module.exports = {
+  connect,
+  // exportados para testes
+  isValidToken,
+  upsertEnvFileContent,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auroq-os",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "Auroq OS — Sistema Operacional de IA para Experts",
   "bin": {
     "auroq-os": "bin/auroq-os.js"
@@ -18,7 +18,7 @@
     "auroq:sync:codex:check": "npm run sync:codex:check",
     "auroq:validate": "npm run validate:hybrid",
     "validate:hybrid": "node scripts/validate-hybrid.mjs",
-    "lint": "node --check bin/auroq-os.js && node --check lib/auth.js && node --check lib/credentials.js && node --check lib/supabase.js && node --check scripts/sync-codex-skills.mjs && node --check scripts/validate-hybrid.mjs",
+    "lint": "node --check bin/auroq-os.js && node --check lib/auth.js && node --check lib/credentials.js && node --check lib/onepassword.js && node --check lib/supabase.js && node --check scripts/sync-codex-skills.mjs && node --check scripts/validate-hybrid.mjs",
     "typecheck": "npm run validate:hybrid",
     "test": "node --test tests/*.test.mjs",
     "build": "npm pack --dry-run --json > /dev/null"

package/scripts/sync-codex-skills.mjs

@@ -123,7 +123,11 @@ function readOwner(dir) {
   if (content === legacyMarker) return { kind: 'legacy' };
   try {
     const data = JSON.parse(content);
-    return data.projectId === projectId ? { kind: 'owned', data } : { kind: 'foreign', data };
+    if (data.projectId === projectId) return { kind: 'owned', data };
+    // Mesma pasta de projeto = mesmo dono, mesmo que o name do package tenha
+    // mudado depois (ex: marcador gerado antes do package.json existir).
+    if (data.sourceRoot && path.resolve(data.sourceRoot) === root) return { kind: 'owned', data };
+    return { kind: 'foreign', data };
   } catch {
     return { kind: 'foreign', data: { invalidMarker: true } };
   }

package/tests/installer-hybrid.test.mjs

@@ -33,8 +33,10 @@ test('installer entrega projeto hibrido funcional sem sobrescrever package scrip
 
     const installedOps = fs.readFileSync(path.join(target, '.claude', 'commands', 'AuroqOS', 'agents', 'ops.md'), 'utf8');
     assert.match(installedOps, /PRE-GATE OBRIGATORIO — sistema de senhas e credenciais/);
-    assert.match(installedOps, /Voltar ao Step anterior e configurar o 1Password/);
+    assert.match(installedOps, /Conectar agora pelo Ops \(RECOMENDADO se ele ja tem o token\)/);
+    assert.match(installedOps, /Voltar ao Step anterior da plataforma/);
     assert.match(installedOps, /Seguir com vault local \(MENOS SEGURO\)/);
+    assert.match(installedOps, /\*conectar-1password/);
     assert.doesNotMatch(installedOps, /#### 1\. 1Password — cofre cifrado/);
 
     const check = execFileSync(process.execPath, [path.join(target, 'scripts', 'sync-codex-skills.mjs'), '--check'], {

package/tests/onepassword.test.mjs

@@ -0,0 +1,54 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { isValidToken, upsertEnvFileContent } = require('../lib/onepassword.js');
+
+test('isValidToken aceita token de service account real', () => {
+  assert.equal(isValidToken('ops_' + 'a'.repeat(800)), true);
+  assert.equal(isValidToken('ops_eyJzaWduSW5BZGRyZXNzIjoibXkuMXBhc3N3b3JkLmNvbSJ9'), true);
+});
+
+test('isValidToken rejeita lixo do clipboard', () => {
+  assert.equal(isValidToken(''), false);
+  assert.equal(isValidToken('pbpaste > ~/.op-token'), false);
+  assert.equal(isValidToken('ops_'), false); // prefixo sem corpo
+  assert.equal(isValidToken('ops_curto'), false); // corpo curto demais
+  assert.equal(isValidToken('token ops_abc'), false); // nao comeca com ops_
+  assert.equal(isValidToken(null), false);
+  assert.equal(isValidToken(undefined), false);
+});
+
+test('upsertEnvFileContent adiciona o export em arquivo vazio', () => {
+  const out = upsertEnvFileContent('', 'ops_' + 'x'.repeat(40));
+  assert.match(out, /export OP_SERVICE_ACCOUNT_TOKEN='ops_x+'/);
+  assert.match(out, /gravado pelo Auroq OS/);
+});
+
+test('upsertEnvFileContent remove definicao antiga mas preserva comentarios do usuario', () => {
+  const existing = [
+    'export PATH="$HOME/bin:$PATH"',
+    '# comentario do usuario sobre OP_SERVICE_ACCOUNT_TOKEN — nao apagar',
+    "export OP_SERVICE_ACCOUNT_TOKEN='ops_velho1234567890123456789'",
+    "  OP_SERVICE_ACCOUNT_TOKEN='ops_sem_export_indentado_123'",
+    'alias ll="ls -la"',
+  ].join('\n');
+  const out = upsertEnvFileContent(existing, 'ops_' + 'n'.repeat(40));
+  assert.equal(out.includes('ops_velho'), false);
+  assert.equal(out.includes('ops_sem_export'), false);
+  // comentario do usuario que so MENCIONA a var fica intacto
+  assert.equal(out.includes('# comentario do usuario sobre OP_SERVICE_ACCOUNT_TOKEN'), true);
+  assert.equal(out.includes('export PATH="$HOME/bin:$PATH"'), true);
+  assert.equal(out.includes('alias ll="ls -la"'), true);
+  // exatamente UMA linha de export do token
+  const exports = out.split('\n').filter((l) => l.startsWith('export OP_SERVICE_ACCOUNT_TOKEN'));
+  assert.equal(exports.length, 1);
+});
+
+test('upsertEnvFileContent e idempotente', () => {
+  const token = 'ops_' + 'i'.repeat(40);
+  const once = upsertEnvFileContent('export FOO=bar', token);
+  const twice = upsertEnvFileContent(once, token);
+  assert.equal(once, twice);
+});

package/tests/sync-codex-skills.test.mjs

@@ -65,3 +65,24 @@ test('check detecta drift e sync bloqueia colisao externa', () => {
     fs.rmSync(home, { recursive: true, force: true });
   }
 });
+
+test('sync local continua dono apos rename do package (marcador antigo da mesma pasta)', () => {
+  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'auroq-os-rename-'));
+  try {
+    fs.mkdirSync(path.join(proj, 'scripts'), { recursive: true });
+    fs.mkdirSync(path.join(proj, '.claude', 'commands'), { recursive: true });
+    fs.copyFileSync(script, path.join(proj, 'scripts', 'sync-codex-skills.mjs'));
+    fs.writeFileSync(path.join(proj, '.claude', 'commands', 'test-agent.md'), '# test-agent\n\nAgente de teste.\n');
+    // Cenario do bug: primeiro sync SEM package.json (name = nome da pasta)...
+    const projScript = path.join(proj, 'scripts', 'sync-codex-skills.mjs');
+    execFileSync(process.execPath, [projScript, '--clean'], { cwd: proj, encoding: 'utf8' });
+    assert.ok(fs.existsSync(path.join(proj, '.agents', 'skills', 'test-agent', 'SKILL.md')));
+    // ...depois o init cria o package.json com outro name (meu-negocio).
+    fs.writeFileSync(path.join(proj, 'package.json'), JSON.stringify({ name: 'meu-negocio', version: '1.0.0' }));
+    // Antes do fix: "Recusando sobrescrever ...; ownership: foreign."
+    execFileSync(process.execPath, [projScript, '--clean'], { cwd: proj, encoding: 'utf8' });
+    execFileSync(process.execPath, [projScript, '--check'], { cwd: proj, encoding: 'utf8' });
+  } finally {
+    fs.rmSync(proj, { recursive: true, force: true });
+  }
+});