auroq-os 2.8.0 → 2.8.2

package/lib/cofre.js

@@ -0,0 +1,1453 @@
+'use strict';
+
+/**
+ * Auroq OS — Camada comum de cofre (1Password e Infisical)
+ *
+ * O aluno escolhe UM cofre para as chaves dos agentes: o 1Password (pago, rota A, lib/onepassword.js) ou o
+ * Infisical (gratis, rota B, lib/infisical.js). Os agentes nao precisam saber qual e: usam
+ * `auroq-os segredo ler|gravar|listar|apagar|qual <ref>` e esta camada fala com o cofre certo.
+ *
+ *  - `cofre.json` (em ~/.arcane, 0600, sem segredo) guarda qual cofre esta ativo;
+ *  - backends `1password` e `infisical`: ler, gravar, listar, apagar com o MESMO formato de resposta;
+ *  - `segredoCli`: o comando `segredo` (valor so por stdin ou arquivo, nunca em argumento; erro so no stderr);
+ *  - `conectarCofre`: o comando `conectar-cofre` (escolha do cofre, continua a rota em andamento);
+ *  - `migrar`: Infisical -> 1Password, sem apagar nada da origem. Ligar o 1Password sozinho NAO troca o cofre de
+ *    quem ja usa o Infisical (as chaves ainda estao la): so a migracao troca, depois de levar tudo.
+ *  - gravar/apagar no 1Password e o login no Infisical usam uma trava de arquivo em ~/.arcane (um comando por vez
+ *    nesta maquina; o agente dispara comandos em paralelo).
+ *
+ * Nenhum valor de segredo, chave do agente ou token aparece em tela, log, mensagem de erro, argumento de
+ * comando ou arquivo de configuracao. Valor so por stdin (op), corpo de requisicao (Infisical) ou memoria.
+ * Todas as dependencias (`d`) sao trocaveis nos testes; os modulos pesados so carregam quando precisam.
+ *
+ * @module auroq-os/cofre
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+
+const VAULT_NAME = 'Claude';
+const ITEM_TAG = 'auroq-os';
+const TEST_SECRET = 'AUROQ_TESTE';
+// Segredo de teste da conexao: `AUROQ_TESTE` ou `AUROQ_TESTE_<letras e numeros>` (nome unico por teste). Nao e chave do aluno.
+const TEST_SECRET_RE = /^AUROQ_TESTE(?:_[A-Za-z0-9]+)?$/;
+const CREDENTIAL = 'credential';
+const TIPOS = ['1password', 'infisical'];
+const NOME_TIPO = { '1password': '1Password', infisical: 'Infisical' };
+const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_VALUE_BYTES = 1024 * 1024;
+const STDIN_IDLE_MS = 30000;
+const OP_TIMEOUT_MS = 60000;
+const LOCK_STALE_MS = 3 * 60 * 1000; // uma gravacao leva segundos: trava com mais de 3 min e de comando que morreu
+const TROCA_STALE_MS = 10 * 1000; // a troca de trava velha dura milissegundos: mais de 10 s e de comando que morreu no meio
+const LOCK_WAIT_MS = 60000; // quanto um comando espera a vez de gravar no 1Password
+const LOGIN_LOCK_WAIT_MS = 20000; // quanto espera a vez de entrar no Infisical
+const BLOQUEIO_MS = 5 * 60 * 1000; // o Infisical trava a identidade por uns 5 minutos depois de varias tentativas erradas
+const NOTA_AUROQ = 'Guardado pelo Auroq OS (comando segredo). O agente le e grava aqui.';
+const ESCOLHA_MSG = 'Quer o 1Password (uns 3 dolares por mes, confira o preco na tela, preenche senha no navegador, recomendado) ou o gratis (Infisical, so guarda as chaves do agente)?';
+
+// Codigos do comando `segredo` (stderr: AUROQ_ERRO codigo=<c> mensagem="...").
+// `uso` = uso errado da linha de comando (ref faltando, valor em argumento, opcao desconhecida).
+const SEGREDO_CODIGOS = ['nome-invalido', 'cofre-nao-configurado', 'nao-encontrado', 'sem-valor', 'ja-existe-confirmar',
+  'credencial-invalida', 'credencial-indisponivel', 'sem-permissao', 'rede', 'limite', 'bloqueada', 'falha', 'uso'];
+// Saida: 0 ok, 1 erro geral, 2 uso errado, 3 nao encontrado, 4 cofre nao configurado.
+const SEGREDO_EXIT = Object.freeze({ ok: 0, erro: 1, uso: 2, 'nao-encontrado': 3, 'cofre-nao-configurado': 4 });
+const CODIGOS_DE_USO = new Set(['uso', 'nome-invalido', 'sem-valor', 'ja-existe-confirmar']);
+
+function exitCodeFor(codigo) {
+  if (!codigo) return SEGREDO_EXIT.ok;
+  if (codigo === 'nao-encontrado') return SEGREDO_EXIT['nao-encontrado'];
+  if (codigo === 'cofre-nao-configurado') return SEGREDO_EXIT['cofre-nao-configurado'];
+  if (CODIGOS_DE_USO.has(codigo)) return SEGREDO_EXIT.uso;
+  return SEGREDO_EXIT.erro;
+}
+
+// ─── Dependencias (preguicosas) ──────────────────────────
+
+const LAZY = {
+  onepassword: () => require('./onepassword'),
+  infisical: () => require('./infisical'),
+  api: () => require('./infisical-api'),
+};
+
+/** Modulo real so quando precisa; `d.<nome>` (teste) substitui o modulo INTEIRO. */
+function mod(d, name) {
+  return (d && d[name]) || LAZY[name]();
+}
+
+function envOf(d) {
+  return (d && d.env) || process.env;
+}
+
+function nowOf(d) {
+  return d && typeof d.now === 'function' ? d.now() : Date.now();
+}
+
+// ─── Texto seguro ────────────────────────────────────────
+
+/**
+ * Uma linha so, sem nada com cara de segredo. `secrets` = valores que esta execucao conhece (o valor que
+ * esta sendo gravado, o client secret): saem do texto antes de qualquer outra coisa.
+ */
+function oneLine(text, max = 300, secrets = []) {
+  let s = String(text === undefined || text === null ? '' : text);
+  const known = secrets.filter((x) => typeof x === 'string' && x.length >= 6);
+  for (const sec of known) s = s.split(sec).join('[oculto]');
+  s = s
+    .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, '')
+    .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, '')
+    .replace(/[\n\r\u0085\u2028\u2029\t]+/g, ' ');
+  for (const sec of known) s = s.split(sec.replace(/\s+/g, ' ')).join('[oculto]');
+  return s
+    .replace(/ops_[A-Za-z0-9_=+/.-]{10,}/g, 'ops_[oculto]')
+    .replace(/eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]*/g, '[oculto]')
+    .replace(/\b[0-9a-fA-F]{64}\b/g, '[oculto]')
+    .replace(/\bst\.[A-Za-z0-9._-]{10,}/g, '[oculto]')
+    .replace(/\[(ERROR|WARNING)\]\s+\d{4}\/\d{2}\/\d{2}\s+\d{2}:\d{2}:\d{2}\s*/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max);
+}
+
+function quoted(text, max = 400, secrets = []) {
+  return oneLine(text, max, secrets).replace(/"/g, "'");
+}
+
+function fail(codigo, mensagem) {
+  return { ok: false, codigo, mensagem };
+}
+
+function stripOneNewline(text) {
+  return String(text).replace(/\r?\n$/, '');
+}
+
+// ─── Trava de arquivo (gravacoes e logins em paralelo na mesma maquina) ───
+
+const sleep = (ms) => new Promise((resolve) => { setTimeout(resolve, ms); });
+
+function readLockInfo(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+/** Trava velha = dono morreu, passou do prazo ou o arquivo esta estragado (vazio so conta depois de uns segundos: o dono pode estar escrevendo). */
+function lockIsStale(file, staleMs) {
+  const info = readLockInfo(file);
+  if (!info || !Number.isInteger(info.pid) || info.pid <= 0 || !Number.isFinite(info.at)) {
+    try { return Date.now() - fs.statSync(file).mtimeMs > 5000; } catch { return true; }
+  }
+  const age = Date.now() - info.at;
+  if (age < -60000 || age > staleMs) return true;
+  try {
+    process.kill(info.pid, 0);
+    return false;
+  } catch (e) {
+    return e.code === 'ESRCH';
+  }
+}
+
+/** 'ok' (peguei), 'ocupada' (outro comando segura) ou 'sem-trava' (permissao ou disco: segue sem trava, como a rota A). */
+function tryLock(file, nonce, staleMs) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const fd = fs.openSync(file, 'wx', 0o600);
+      try { fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now(), nonce })); } finally { fs.closeSync(fd); }
+      return 'ok';
+    } catch (e) {
+      if (e.code !== 'EEXIST') return 'sem-trava';
+      if (!lockIsStale(file, staleMs)) return 'ocupada';
+      tomarVelha(file, staleMs);
+    }
+  }
+  return 'ocupada';
+}
+
+/**
+ * Remove a trava velha SEM apagar uma trava nova: quem viu a trava velha e foi mais lento nao pode apagar a que
+ * outro comando acabou de criar (antes, dois comandos entravam juntos e o "um por vez" se perdia). Por isso so um
+ * comando por vez faz a troca (arquivo `.troca`, vida de milissegundos) e ele confere DE NOVO, ja la dentro, se a
+ * trava continua velha. Quem nao consegue a troca nao faz nada: tryLock tenta de novo e, se ainda houver trava,
+ * devolve 'ocupada'. Troca esquecida (comando morto bem nessa hora) com mais de 10 s e velha e sai.
+ */
+function tomarVelha(file, staleMs) {
+  const troca = `${file}.troca`;
+  let fd;
+  try {
+    fd = fs.openSync(troca, 'wx', 0o600);
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      try { if (Date.now() - fs.statSync(troca).mtimeMs > TROCA_STALE_MS) fs.unlinkSync(troca); } catch { /* outro limpou */ }
+    }
+    return;
+  }
+  try {
+    fs.closeSync(fd);
+    fs.statSync(file); // sumiu = o dono soltou: nao ha o que tomar (lockIsStale trata "sumiu" como velha)
+    if (lockIsStale(file, staleMs)) fs.unlinkSync(file);
+  } catch { /* sumiu ou outro pegou antes */ } finally {
+    try { fs.unlinkSync(troca); } catch { /* ja foi */ }
+  }
+}
+
+function releaseLock(file, nonce) {
+  const info = readLockInfo(file);
+  if (info && info.nonce === nonce) {
+    try { fs.unlinkSync(file); } catch { /* ja foi */ }
+  }
+}
+
+/**
+ * Roda `fn` com a trava `file` (UMA execucao por vez nesta maquina), ESPERANDO a vez ate `waitMs`.
+ * Acabou o prazo: `onTimeout()` decide o resultado; sem `onTimeout`, roda `fn` mesmo assim (nunca trava o aluno).
+ */
+async function withFileLock(file, fn, { waitMs = LOCK_WAIT_MS, staleMs = LOCK_STALE_MS, onTimeout = null } = {}) {
+  const nonce = crypto.randomBytes(8).toString('hex');
+  const ate = Date.now() + waitMs;
+  let got = tryLock(file, nonce, staleMs);
+  while (got === 'ocupada' && Date.now() < ate) {
+    await sleep(40 + Math.floor(Math.random() * 80));
+    got = tryLock(file, nonce, staleMs);
+  }
+  if (got === 'ocupada' && onTimeout) return onTimeout();
+  try {
+    return await fn();
+  } finally {
+    if (got === 'ok') releaseLock(file, nonce);
+  }
+}
+
+/** Valor a gravar sem BOM do Windows, sem a quebra de linha final e sem espaco nas pontas (credencial nao tem). */
+function cleanValue(text) {
+  return String(text).replace(/^\uFEFF/, '').replace(/(\r\n|\n|\r)$/, '').trim();
+}
+
+// ─── cofre.json (qual cofre esta ativo) ──────────────────
+
+function dirOf(d) {
+  if (d && d.dir) {
+    try { fs.mkdirSync(d.dir, { recursive: true, mode: 0o700 }); } catch { /* quem escreve trata */ }
+    return d.dir;
+  }
+  return mod(d, 'onepassword').auroqDir();
+}
+
+function cofreFile(d) {
+  return path.join(dirOf(d), 'cofre.json');
+}
+
+/** `cofre.json` valido ({versao, tipo, anterior, atualizado_em}) ou null. Nunca lanca. */
+function readCofre(d) {
+  try {
+    const data = JSON.parse(fs.readFileSync(cofreFile(d), 'utf8'));
+    if (!data || typeof data !== 'object' || data.versao !== 1 || !TIPOS.includes(data.tipo)) return null;
+    return {
+      versao: 1,
+      tipo: data.tipo,
+      anterior: TIPOS.includes(data.anterior) ? data.anterior : null,
+      atualizado_em: data.atualizado_em || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Marca o cofre ativo. Mesmo cofre de antes = nao mexe no arquivo. `anterior` = o cofre que estava ativo
+ * antes (ou o que a migracao informa). Lanca se nao conseguir gravar: quem chama decide se isso importa.
+ */
+function registrar(tipo, options = {}, d = {}) {
+  if (!TIPOS.includes(tipo)) throw new Error('tipo de cofre invalido');
+  const prev = readCofre(d);
+  const opts = options && typeof options === 'object' ? options : {};
+  if (prev && prev.tipo === tipo && opts.anterior === undefined) return prev;
+  let anterior = null;
+  if (opts.anterior !== undefined) anterior = TIPOS.includes(opts.anterior) ? opts.anterior : null;
+  else if (prev) anterior = prev.tipo !== tipo ? prev.tipo : prev.anterior;
+  const data = { versao: 1, tipo, anterior, atualizado_em: new Date(nowOf(d)).toISOString() };
+  mod(d, 'onepassword').writeFileAtomic(cofreFile(d), `${JSON.stringify(data, null, 2)}\n`);
+  return data;
+}
+
+const AVISO_MANTIDO = 'O 1Password ficou conectado, mas o cofre ativo continua o gratis (Infisical) porque as chaves ainda estao la. Quem troca para o 1Password e a migracao: rode "npx auroq-os conectar-cofre --migrar" (com 0 chaves tambem serve). Ate la, o segredo ler/gravar continua no Infisical.';
+const AVISO_CHAVES_ANTIGAS = 'As chaves que ja estavam no 1Password continuam la e NAO foram levadas para o Infisical (nada foi copiado: o Infisical so tem o que ja foi guardado nele). Para ver quais sao: segredo listar --cofre 1password. Para usar uma antiga sem o valor passar pela conversa: segredo ler NOME --cofre 1password, sempre dentro de $(...) ou por pipe, nunca sozinho. Levar para o gratis nao e automatico.';
+
+/** Linha de aviso (nao e erro): para o agente `AUROQ_AVISO ...`, para a pessoa o texto puro. */
+function avisoLinha(agente, atributos, mensagem) {
+  return agente ? `AUROQ_AVISO ${atributos} mensagem="${quoted(mensagem)}"` : mensagem;
+}
+
+/**
+ * Depois de uma conexao: 'registrado' (cofre ativo marcado), 'mantido' (o Infisical esta ativo e pronto: ligar o
+ * 1Password NAO troca de cofre, so a migracao troca, depois de levar as chaves) ou 'nao' (a conexao nao terminou ok).
+ * `argv` = o que o aluno digitou: o modo manual do 1Password termina ok sem devolver resultado.
+ */
+async function avaliarRegistro(result, tipo, d, argv) {
+  try {
+    const manual = result === undefined && tipo === '1password' && Array.isArray(argv) && argv.includes('--manual');
+    if (!manual && !(result && result.status === 'ok')) return 'nao';
+    const atual = readCofre(d);
+    if (tipo === '1password' && atual && atual.tipo === 'infisical' && (await backends(d).infisical.pronto())) return 'mantido';
+    registrar(tipo, {}, d);
+    return 'registrado';
+  } catch {
+    return 'nao'; // o registro e conforto
+  }
+}
+
+/**
+ * Registra o cofre quando a conexao terminou `ok`. Nunca lanca e nunca falha a conexao. Devolve true so se
+ * registrou. Se o Infisical esta ativo e pronto, ligar o 1Password nao troca o cofre: avisa (`d.print`).
+ */
+async function registrarSeOk(result, tipo = '1password', d = {}, argv = []) {
+  const r = await avaliarRegistro(result, tipo, d, argv);
+  if (r === 'mantido') {
+    try {
+      const print = (d && d.print) || ((line) => console.log(line));
+      print(avisoLinha(Array.isArray(argv) && argv.includes('--agente'), 'cofre=infisical mantido=sim', AVISO_MANTIDO));
+    } catch { /* o aviso e conforto */ }
+  }
+  return r === 'registrado';
+}
+
+// ─── Referencias e nomes ─────────────────────────────────
+
+/**
+ * Nome de item ou de campo. `__` separa item e campo na chave do Infisical, entao nao pode aparecer dentro de
+ * um nome; e um nome terminado em `_` colaria o `_` ao separador (`A_` + `__` + `B` = `A___B`) e a volta
+ * (`refFromKey`) perderia o nome. Por isso termina em letra, numero, `.` ou `-`.
+ */
+function validName(s) {
+  return typeof s === 'string' && NAME_RE.test(s) && !s.includes('__') && !s.endsWith('_');
+}
+
+function normCampo(campo) {
+  return String(campo).toLowerCase() === CREDENTIAL ? CREDENTIAL : campo;
+}
+
+/**
+ * `op://Claude/ITEM[/CAMPO]`, `cofre://ITEM[/CAMPO]` ou `ITEM[/CAMPO]` -> { item, campo } (campo padrao
+ * `credential`) ou null (`nome-invalido`). Outro cofre que nao o Claude e referencia com 3+ partes: null.
+ */
+function parseRef(texto) {
+  if (typeof texto !== 'string') return null;
+  let t = texto.trim();
+  if (!t) return null;
+  let m = t.match(/^op:\/\/(.*)$/i);
+  if (m) {
+    const partes = m[1].split('/');
+    if (partes.length < 2 || partes.length > 3) return null;
+    if (partes[0].toLowerCase() !== VAULT_NAME.toLowerCase()) return null;
+    t = partes.slice(1).join('/');
+  } else {
+    m = t.match(/^cofre:\/\/(.*)$/i);
+    if (m) t = m[1];
+  }
+  const partes = t.split('/');
+  if (partes.length > 2) return null;
+  const item = partes[0];
+  const campo = partes.length === 2 ? partes[1] : CREDENTIAL;
+  if (!validName(item) || !validName(campo)) return null;
+  return { item, campo: normCampo(campo) };
+}
+
+function toRef(x) {
+  if (x && typeof x === 'object' && typeof x.item === 'string') {
+    const campo = x.campo === undefined || x.campo === null ? CREDENTIAL : x.campo;
+    return validName(x.item) && validName(campo) ? { item: x.item, campo: normCampo(campo) } : null;
+  }
+  return parseRef(x);
+}
+
+/** Chave do segredo no Infisical: `ITEM` se o campo e `credential`, senao `ITEM__CAMPO`. */
+function infisicalKey(ref) {
+  const r = toRef(ref);
+  if (!r) return null;
+  return r.campo === CREDENTIAL ? r.item : `${r.item}__${r.campo}`;
+}
+
+/** Volta da chave para { item, campo }. Chave que nao segue o formato: null. */
+function refFromKey(key) {
+  if (typeof key !== 'string' || !key) return null;
+  const i = key.indexOf('__');
+  const item = i === -1 ? key : key.slice(0, i);
+  const campo = i === -1 ? CREDENTIAL : key.slice(i + 2);
+  if (!validName(item) || !validName(campo)) return null;
+  return { item, campo: normCampo(campo) };
+}
+
+function refText(ref) {
+  return ref.campo === CREDENTIAL ? ref.item : `${ref.item}/${ref.campo}`;
+}
+
+function opReference(ref) {
+  return `op://${VAULT_NAME}/${ref.item}/${ref.campo}`;
+}
+
+// ─── Mensagens por codigo ────────────────────────────────
+
+function messageFor(codigo, tipo, detalhe = '') {
+  const nome = NOME_TIPO[tipo] || 'cofre';
+  switch (codigo) {
+    case 'cofre-nao-configurado':
+      return tipo
+        ? `O ${nome} nao esta conectado neste computador (ou o cofre ${VAULT_NAME} nao esta visivel para a chave). Rode: npx auroq-os conectar-cofre --cofre ${tipo}`
+        : 'Nenhum cofre conectado neste computador. Rode: npx auroq-os conectar-cofre';
+    case 'nao-encontrado':
+      return `Nao achei esse segredo no ${nome}.`;
+    case 'credencial-invalida': {
+      const recente = tipo === 'infisical' ? 'Se a chave acabou de ser criada, espere um minuto e tente de novo. ' : '';
+      return `O ${nome} recusou a chave deste computador (revogada ou invalida). ${recente}Para gerar outra, rode: npx auroq-os conectar-cofre --cofre ${tipo} --rotacionar`;
+    }
+    case 'credencial-indisponivel':
+      return `Nao consegui usar a chave deste computador no ${nome} agora. Tente de novo em alguns minutos.`;
+    case 'sem-permissao':
+      return `A chave do agente nao tem permissao para isso no ${nome}.`;
+    case 'rede':
+      return `Sem conexao com o ${nome} agora.`;
+    case 'limite':
+      return `O ${nome} limitou os acessos por enquanto (limite de uso). Tente de novo em alguns minutos.`;
+    case 'bloqueada':
+      return `O ${nome} bloqueou a chave por alguns minutos (muitas tentativas erradas). Espere uns 5 minutos e tente de novo, sem repetir antes.`;
+    default:
+      return `Resposta inesperada do ${nome}.${detalhe ? ` ${detalhe}` : ''}`;
+  }
+}
+
+function failure(codigo, tipo, detalhe) {
+  return fail(codigo, messageFor(codigo, tipo, detalhe));
+}
+
+// ─── Backend 1Password ───────────────────────────────────
+
+const OP_NOT_VAULT_RE = /(isn't a vault|is not a vault|vault[^.\n]{0,40}(?:not found|could not be found)|no vault)/i;
+const OP_NOT_FOUND_RE = /(isn't an item|is not an item|isn't a field|is not a field|no item|item[^.\n]{0,40}(?:not found|could not be found)|could not be found|no field)/i;
+const OP_AMBIGUOUS_RE = /more than one item/i;
+const OP_PERMISSION_RE = /(forbidden|permission|not allowed|insufficient|denied|\b403\b)/i;
+
+/** Falha de um comando do `op` -> { codigo, detalhe }. O `op` fala ingles; nome de item vem entre aspas, por isso "nao achei" vem antes. */
+function classifyOp(d, r, secrets = []) {
+  const o = mod(d, 'onepassword');
+  const stderr = String((r && r.stderr) || '');
+  if (r && r.missing) return { codigo: 'cofre-nao-configurado', detalhe: '' };
+  if (OP_NOT_VAULT_RE.test(stderr)) return { codigo: 'cofre-nao-configurado', detalhe: '' };
+  if (OP_AMBIGUOUS_RE.test(stderr)) return { codigo: 'falha', detalhe: `Tem mais de um item com esse nome no cofre ${VAULT_NAME}; apague ou renomeie o repetido.` };
+  if (OP_NOT_FOUND_RE.test(stderr)) return { codigo: 'nao-encontrado', detalhe: '' };
+  const c = o.classifyTokenFailure(r);
+  if (c === 'tempo' || c === 'rede') return { codigo: 'rede', detalhe: '' };
+  if (c === 'limite') return { codigo: 'limite', detalhe: '' };
+  if (c === 'token-invalido') return { codigo: 'credencial-invalida', detalhe: '' };
+  if (OP_PERMISSION_RE.test(stderr)) return { codigo: 'sem-permissao', detalhe: '' };
+  const base = o.classifyFailure(r);
+  if (base === 'sem-sessao' || base === 'sessao') return { codigo: 'credencial-indisponivel', detalhe: '' };
+  return { codigo: 'falha', detalhe: oneLine(stderr, 200, secrets) };
+}
+
+function itemTemplate(ref, valor) {
+  const extra = ref.campo !== CREDENTIAL;
+  const empty = (id, type, label) => ({ id, type, label, value: '' });
+  const fields = [
+    { id: 'notesPlain', type: 'STRING', purpose: 'NOTES', label: 'notesPlain', value: NOTA_AUROQ },
+    empty('username', 'STRING', 'username'),
+    { id: CREDENTIAL, type: 'CONCEALED', label: CREDENTIAL, value: extra ? '' : valor },
+    empty('type', 'MENU', 'type'),
+    empty('filename', 'STRING', 'filename'),
+    empty('validFrom', 'DATE', 'valid from'),
+    empty('expires', 'DATE', 'expires'),
+    empty('hostname', 'STRING', 'hostname'),
+  ];
+  if (extra) fields.push({ type: 'CONCEALED', label: ref.campo, value: valor });
+  return { title: ref.item, category: 'API_CREDENTIAL', fields };
+}
+
+function findField(fields, campo) {
+  const want = String(campo).toLowerCase();
+  if (campo === CREDENTIAL) {
+    return fields.find((f) => f && f.id === CREDENTIAL) || fields.find((f) => f && String(f.label || '').toLowerCase() === CREDENTIAL);
+  }
+  return fields.find((f) => f && String(f.label || '').toLowerCase() === want);
+}
+
+function makeOpBackend(d) {
+  const tipo = '1password';
+
+  async function token() {
+    const o = mod(d, 'onepassword');
+    const valid = (t) => (t && o.isValidToken(String(t).trim()) ? String(t).trim() : null);
+    const fromEnv = valid(envOf(d)[o.TOKEN_VAR]);
+    if (fromEnv) return fromEnv;
+    try { return valid(await (d.readOpToken ? d.readOpToken() : o.readPersistedToken())); } catch { return null; }
+  }
+
+  async function call(tk, args, input = '') {
+    const o = mod(d, 'onepassword');
+    const run = d.op || o.runOp;
+    // `isolate`: o agente nunca pode cair na janela da digital do app; vale so a chave
+    const env = o.opEnv(String(tk).trim(), { isolate: true });
+    // a chave do Infisical (ID e segredo) nao tem nada a ver com o `op`: nao vai para o ambiente dele
+    for (const k of Object.keys(env)) {
+      if (/^AUROQ_INFISICAL_/i.test(k)) delete env[k];
+    }
+    return run(args, { env, input, timeoutMs: OP_TIMEOUT_MS });
+  }
+
+  const semChave = () => failure('cofre-nao-configurado', tipo);
+
+  /** Gravar e apagar leem o item, mudam e gravam de volta: dois comandos juntos criariam item repetido ou perderiam um campo. Um por vez. */
+  const comTrava = (fn) => withFileLock(path.join(dirOf(d), 'cofre-op.lock'), fn, {
+    waitMs: d.lockWaitMs === undefined ? LOCK_WAIT_MS : d.lockWaitMs,
+    onTimeout: () => fail('falha', 'Outro comando esta gravando no 1Password agora. Tente de novo em alguns instantes.'),
+  });
+
+  async function run(args, input, secrets) {
+    const tk = await token();
+    if (!tk) return { erro: semChave() };
+    const r = await call(tk, args, input);
+    if (r.ok) return { r, tk };
+    const c = classifyOp(d, r, secrets);
+    return { erro: failure(c.codigo, tipo, c.detalhe) };
+  }
+
+  const backend = {
+    tipo,
+    nome: NOME_TIPO[tipo],
+    async pronto() {
+      return Boolean(await token());
+    },
+    async ler(ref) {
+      const x = await run(['read', opReference(ref)], '', []);
+      if (x.erro) return x.erro;
+      return { ok: true, valor: stripOneNewline(x.r.stdout) };
+    },
+    async gravar(ref, valor) {
+      return comTrava(async () => {
+        const secrets = [valor];
+        const got = await run(['item', 'get', ref.item, '--vault', VAULT_NAME, '--format', 'json'], '', secrets);
+        let item = null;
+        if (got.erro) {
+          if (got.erro.codigo !== 'nao-encontrado') return got.erro;
+        } else {
+          try { item = JSON.parse(got.r.stdout); } catch { item = null; }
+          if (!item || typeof item !== 'object' || !Array.isArray(item.fields)) return failure('falha', tipo, 'Nao entendi o item que ja existe no cofre.');
+        }
+        let w;
+        if (!item) {
+          w = await run(['item', 'create', '-', '--vault', VAULT_NAME, '--tags', ITEM_TAG], JSON.stringify(itemTemplate(ref, valor)), secrets);
+        } else {
+          // item que ja existe (pode ser do aluno, com varios campos): muda ou insere SO o campo pedido
+          const campo = findField(item.fields, ref.campo);
+          if (campo) campo.value = valor;
+          else item.fields.push(ref.campo === CREDENTIAL ? { id: CREDENTIAL, type: 'CONCEALED', label: CREDENTIAL, value: valor } : { type: 'CONCEALED', label: ref.campo, value: valor });
+          w = await run(['item', 'edit', ref.item, '--vault', VAULT_NAME], JSON.stringify(item), secrets);
+        }
+        if (w.erro) return w.erro;
+        return { ok: true, criado: !item };
+      });
+    },
+    async listar() {
+      const x = await run(['item', 'list', '--vault', VAULT_NAME, '--format', 'json'], '', []);
+      if (x.erro) return x.erro;
+      let list = null;
+      try { list = JSON.parse(x.r.stdout); } catch { list = null; }
+      if (!Array.isArray(list)) return failure('falha', tipo, 'Nao entendi a lista de itens do cofre.');
+      const nomes = [...new Set(list.map((i) => oneLine(i && i.title, 120)).filter(Boolean))].sort();
+      return { ok: true, nomes };
+    },
+    /**
+     * { ok, existe, campos }. `existe` confere o item e, se o campo pedido nao e o `credential`, o campo tambem.
+     * `campos` = rotulos dos campos do item que TEM valor (nunca os valores): e o que o arquivamento leva junto.
+     */
+    async existe(ref) {
+      const l = await backend.listar();
+      if (!l.ok) return l;
+      if (!l.nomes.some((n) => n.toLowerCase() === ref.item.toLowerCase())) return { ok: true, existe: false, campos: [] };
+      const got = await run(['item', 'get', ref.item, '--vault', VAULT_NAME, '--format', 'json'], '', []);
+      if (got.erro) return got.erro.codigo === 'nao-encontrado' ? { ok: true, existe: false, campos: [] } : got.erro;
+      let item = null;
+      try { item = JSON.parse(got.r.stdout); } catch { item = null; }
+      if (!item || typeof item !== 'object' || !Array.isArray(item.fields)) return failure('falha', tipo, 'Nao entendi o item que ja existe no cofre.');
+      const campos = item.fields
+        .filter((f) => f && typeof f.value === 'string' && f.value !== '' && f.value !== NOTA_AUROQ)
+        .map((f) => oneLine(f.label || f.id, 60))
+        .filter(Boolean);
+      const achou = ref.campo === CREDENTIAL ? true : Boolean(findField(item.fields, ref.campo));
+      return { ok: true, existe: achou, campos: [...new Set(campos)] };
+    },
+    async apagar(ref) {
+      // no 1Password o item e a unidade: arquiva o item inteiro (volta pelo Arquivo do app, nao se perde)
+      return comTrava(async () => {
+        if (ref.campo !== CREDENTIAL) {
+          // campo que nao existe nao arquiva nada (antes, o erro de digitacao no campo arquivava o item inteiro)
+          const e = await backend.existe(ref);
+          if (!e.ok) return e;
+          if (!e.existe) return failure('nao-encontrado', tipo);
+        }
+        const x = await run(['item', 'delete', ref.item, '--vault', VAULT_NAME, '--archive'], '', []);
+        if (x.erro) return x.erro;
+        return { ok: true };
+      });
+    },
+  };
+  return backend;
+}
+
+// ─── Backend Infisical ───────────────────────────────────
+
+const API_PARA_SEGREDO = {
+  rede: 'rede',
+  tempo: 'rede',
+  servidor: 'rede',
+  limite: 'limite',
+  'limite-plano': 'limite',
+  bloqueada: 'bloqueada',
+  'credencial-invalida': 'credencial-invalida',
+  'sessao-expirada': 'credencial-indisponivel',
+  'plano-restringe': 'sem-permissao',
+  'sem-permissao': 'sem-permissao',
+  'nao-encontrado': 'nao-encontrado',
+};
+
+// Cabe inteira na linha AUROQ_RESULTADO (o texto da linha corta em 400 caracteres): o comando e o "rode de novo" ficam de fora se passar.
+const MSG_ORIGEM_MORTA = 'O Infisical recusou a chave deste computador (revogada, ou a identidade ou o projeto foi apagado), entao esperar nao resolve. Gere a chave de novo: npx auroq-os conectar-cofre --cofre infisical --agente (entre na sua conta do Infisical; se ela foi apagada, crie outra, e gratis). Depois rode a migracao de novo: o que ainda estiver la passa; sem nada la, o 1Password vira o cofre ativo.';
+
+// O plano gratis barrou a acao (nao e a chave sem direito, nem falta de vaga): a frase padrao de 'sem-permissao'
+// faria o aluno mexer na chave ou apagar coisa no painel sem necessidade.
+const MSG_PLANO_RESTRINGE = 'O plano gratis do Infisical nao permitiu essa acao. Isso NAO e falta de vaga: nao apague nada no painel por causa disso. Nao da para contornar daqui; se o 1Password for uma opcao para voce, use ele como cofre, ou peca ajuda ao Arcano.';
+
+function makeInfisicalBackend(d) {
+  const tipo = 'infisical';
+  let session = null; // { client, config } depois do login (so em memoria; o token nunca vai para disco)
+  let loginErro = null; // chave morta ou bloqueada neste processo: nao insiste (cada tentativa errada conta para a trava do Infisical)
+
+  // Valor de verdade (id/segredo) e nao uma linha do aluno que BUSCA a chave de outro jeito (ex.: $(security find-generic-password ...))
+  const literal = (v) => typeof v === 'string' && /^[A-Za-z0-9._~+/=-]+$/.test(v.trim());
+
+  /**
+   * Chaves para tentar, na ordem. A gravada vem primeiro: `--rotacionar` e a regeneracao so atualizam o arquivo,
+   * e um terminal/Claude aberto antes ainda tem a chave velha (revogada) no ambiente; cada login errado conta
+   * para a trava de 5 minutos da identidade (que vale para todos os computadores do aluno).
+   */
+  async function creds() {
+    const inf = mod(d, 'infisical');
+    const env = envOf(d);
+    const out = [];
+    const add = (id, secret) => {
+      const clientId = typeof id === 'string' ? id.trim() : '';
+      const clientSecret = typeof secret === 'string' ? secret.trim() : '';
+      if (clientId && clientSecret && !out.some((c) => c.clientId === clientId && c.clientSecret === clientSecret)) out.push({ clientId, clientSecret });
+    };
+    let persisted = null;
+    try { persisted = await inf.readPersistedCreds(); } catch { persisted = null; }
+    if (persisted && literal(persisted.clientId) && literal(persisted.clientSecret)) add(persisted.clientId, persisted.clientSecret);
+    add(env[inf.CLIENT_ID_VAR], env[inf.CLIENT_SECRET_VAR]);
+    return out;
+  }
+
+  function config() {
+    const inf = mod(d, 'infisical');
+    let cfg = null;
+    try { cfg = inf.readConfig(); } catch { cfg = null; }
+    return cfg && typeof cfg === 'object' && cfg.projectId ? cfg : null;
+  }
+
+  function mapFail(r, secrets = []) {
+    const codigo = API_PARA_SEGREDO[r && r.codigo] || 'falha';
+    if (r && r.codigo === 'plano-restringe') return fail(codigo, MSG_PLANO_RESTRINGE);
+    const detalhe = codigo === 'falha' ? oneLine(r && r.mensagem, 200, secrets) : '';
+    return failure(codigo, tipo, detalhe);
+  }
+
+  // Marca (sem segredo: so a identidade e ate quando) de que o Infisical bloqueou a identidade: os outros comandos
+  // deste computador nem tentam entrar enquanto durar, em vez de repetir o erro que a mantem bloqueada.
+  const bloqueioFile = () => path.join(dirOf(d), 'cofre-infisical-bloqueio.json');
+  function bloqueioAte(clientIds) {
+    try {
+      const m = JSON.parse(fs.readFileSync(bloqueioFile(), 'utf8'));
+      if (m && m.versao === 1 && clientIds.includes(m.clientId) && Number.isFinite(m.ate) && m.ate > nowOf(d)) return m.ate;
+    } catch { /* sem marca */ }
+    return 0;
+  }
+  function marcarBloqueio(clientId) {
+    try { mod(d, 'onepassword').writeFileAtomic(bloqueioFile(), `${JSON.stringify({ versao: 1, clientId, ate: nowOf(d) + BLOQUEIO_MS })}\n`); } catch { /* conforto */ }
+  }
+  function limparBloqueio() {
+    try { fs.unlinkSync(bloqueioFile()); } catch { /* nao tinha */ }
+  }
+
+  /** Entra com a chave deste computador (so uma rodada por processo e uma por vez na maquina). Tenta a seguinte so se a anterior morreu. */
+  async function entrar(list, cfg, baseUrl) {
+    const api = mod(d, 'api');
+    const secrets = list.map((c) => c.clientSecret);
+    const ate = bloqueioAte(list.map((c) => c.clientId));
+    if (ate) {
+      const min = Math.max(1, Math.ceil((ate - nowOf(d)) / 60000));
+      return fail('bloqueada', `${messageFor('bloqueada', tipo)} (falta uns ${min} minuto(s))`);
+    }
+    let last = null;
+    for (const c of list) {
+      const r = await api.ops.universalLogin(api.createClient({ baseUrl }), { clientId: c.clientId, clientSecret: c.clientSecret });
+      if (r && r.ok && r.accessToken) {
+        limparBloqueio();
+        session = { client: api.createClient({ baseUrl, token: r.accessToken }), config: cfg };
+        return { ok: true };
+      }
+      last = r || { codigo: 'falha' };
+      if (last.codigo === 'bloqueada') marcarBloqueio(c.clientId);
+      if (last.codigo !== 'credencial-invalida') break; // so a chave morta justifica tentar a outra (cada erro conta para a trava)
+    }
+    return mapFail(last, secrets);
+  }
+
+  /** Login da identidade (so com a chave deste computador). */
+  async function login() {
+    if (session) return { ok: true };
+    if (loginErro) return loginErro;
+    const cfg = config();
+    const list = await creds();
+    if (!cfg || !list.length) return failure('cofre-nao-configurado', tipo);
+    const api = mod(d, 'api');
+    const baseUrl = api.normalizeDomain(cfg.dominio || 'us');
+    if (!baseUrl) return failure('falha', tipo, 'O endereco do Infisical gravado neste computador e invalido.');
+    // varios comandos juntos (o agente dispara em paralelo) entram um de cada vez: um erro seguido de acerto nao soma na trava
+    const r = await withFileLock(path.join(dirOf(d), 'cofre-infisical-login.lock'), () => entrar(list, cfg, baseUrl), {
+      waitMs: d.loginLockWaitMs === undefined ? LOGIN_LOCK_WAIT_MS : d.loginLockWaitMs,
+    });
+    if (!r.ok && (r.codigo === 'credencial-invalida' || r.codigo === 'bloqueada')) loginErro = r;
+    return r;
+  }
+
+  /** Roda uma operacao com a sessao; se o Infisical diz que a sessao expirou, entra de novo UMA vez. */
+  async function withSession(fn, secrets = []) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const l = await login();
+      if (!l.ok) return l;
+      const r = await fn(session.client, session.config);
+      if (r && !r.ok && r.codigo === 'sessao-expirada' && attempt === 0) {
+        session = null;
+        continue;
+      }
+      return r && r.ok ? r : mapFail(r, secrets);
+    }
+    return failure('credencial-indisponivel', tipo);
+  }
+
+  const scope = (cfg) => ({ projectId: cfg.projectId, environment: cfg.env || 'prod' });
+
+  const backend = {
+    tipo,
+    nome: NOME_TIPO[tipo],
+    async pronto() {
+      if (!config()) return false;
+      const inf = mod(d, 'infisical');
+      const env = envOf(d);
+      const doAmbiente = (v) => typeof v === 'string' && v.trim() !== '';
+      if (doAmbiente(env[inf.CLIENT_ID_VAR]) && doAmbiente(env[inf.CLIENT_SECRET_VAR])) return true; // sem ler a chave gravada (no Windows isso abre o PowerShell)
+      return (await creds()).length > 0;
+    },
+    async ler(ref) {
+      const name = infisicalKey(ref);
+      const r = await withSession((client, cfg) => mod(d, 'api').ops.readSecret(client, { ...scope(cfg), name }));
+      if (!r.ok) return r;
+      return { ok: true, valor: typeof r.value === 'string' ? r.value : '' };
+    },
+    async gravar(ref, valor) {
+      const name = infisicalKey(ref);
+      const r = await withSession((client, cfg) => mod(d, 'api').ops.writeSecret(client, { ...scope(cfg), name, value: valor }), [valor]);
+      if (!r.ok) return r;
+      return { ok: true, criado: Boolean(r.criado) };
+    },
+    /** Chaves como estao no Infisical (nomes, nunca valores). */
+    async chaves() {
+      const r = await withSession((client, cfg) => mod(d, 'api').ops.listSecretNames(client, scope(cfg)));
+      if (!r.ok) return r;
+      return { ok: true, chaves: [...new Set(Array.isArray(r.names) ? r.names.map(String) : [])].sort() };
+    },
+    async listar() {
+      const c = await backend.chaves();
+      if (!c.ok) return c;
+      const nomes = c.chaves.map((k) => {
+        const ref = refFromKey(k);
+        return ref && infisicalKey(ref) === k ? refText(ref) : oneLine(k, 120);
+      });
+      return { ok: true, nomes: [...new Set(nomes)].sort() };
+    },
+    async existe(ref) {
+      const c = await backend.chaves();
+      if (!c.ok) return c;
+      return { ok: true, existe: c.chaves.includes(infisicalKey(ref)) };
+    },
+    async apagar(ref) {
+      const name = infisicalKey(ref);
+      const r = await withSession((client, cfg) => mod(d, 'api').ops.deleteSecret(client, { ...scope(cfg), name }));
+      return r.ok ? { ok: true } : r;
+    },
+  };
+  return backend;
+}
+
+/** { '1password': backend, infisical: backend }. Criar nao toca em disco nem em rede; cada backend guarda a sua sessao. */
+function backends(d = {}) {
+  return { '1password': makeOpBackend(d), infisical: makeInfisicalBackend(d) };
+}
+
+// ─── Qual cofre ──────────────────────────────────────────
+
+/**
+ * Cofre ativo. `cofre.json` manda; sem o arquivo (aluno que conectou antes dele existir): chave do 1Password
+ * no ambiente ou gravada => 1password; senao credenciais do Infisical + infisical.json => infisical; senao null.
+ */
+async function detectarTipo(d = {}) {
+  const c = readCofre(d);
+  if (c) return c.tipo;
+  const b = backends(d);
+  if (await b['1password'].pronto()) return '1password';
+  if (await b.infisical.pronto()) return 'infisical';
+  return null;
+}
+
+/**
+ * Nome de cofre para repetir na mensagem de erro: so se parece nome de cofre (letras minusculas, ate 12). O argumento
+ * pode ser o proprio valor do segredo (agente que errou a ordem); mensagem de erro nunca repete texto livre.
+ */
+function eco(texto) {
+  return typeof texto === 'string' && /^[a-z][a-z-]{1,11}$/.test(texto) ? ` "${texto}"` : '';
+}
+
+async function resolveBackend(opts, d) {
+  const o = opts && typeof opts === 'object' ? opts : {};
+  const b = backends(d);
+  const tipo = o.cofre || (await detectarTipo(d));
+  if (!tipo) return { erro: failure('cofre-nao-configurado', null) };
+  if (!TIPOS.includes(tipo)) return { erro: fail('uso', `Cofre desconhecido${eco(tipo)}. Use 1password ou infisical.`) };
+  return { tipo, backend: b[tipo] };
+}
+
+/** { ok:true, valor, cofre } | { ok:false, codigo, mensagem }. `opts.cofre` forca o backend. */
+async function ler(texto, opts = {}, d = {}) {
+  const ref = toRef(texto);
+  if (!ref) return failure('nome-invalido', null);
+  const x = await resolveBackend(opts, d);
+  if (x.erro) return x.erro;
+  const r = await x.backend.ler(ref);
+  if (!r.ok) return r;
+  // existe mas sem valor (campo vazio): exit 0 com saida vazia faria o agente usar uma chave vazia
+  if (r.valor === '') {
+    return fail('nao-encontrado', `O segredo ${refText(ref)} existe no ${x.backend.nome}, mas esta sem valor (vazio). Grave o valor de novo. Se voce o guardou em outro campo (ITEM/CAMPO), leia com o nome completo.`);
+  }
+  return { ...r, cofre: x.tipo };
+}
+
+/** Grava e CONFERE lendo de volta. O valor nunca sai desta funcao em mensagem de erro. */
+async function gravar(texto, valor, opts = {}, d = {}) {
+  const ref = toRef(texto);
+  if (!ref) return failure('nome-invalido', null);
+  if (typeof valor !== 'string' || valor === '') return fail('sem-valor', 'O valor esta vazio.');
+  const x = await resolveBackend(opts, d);
+  if (x.erro) return x.erro;
+  const w = await x.backend.gravar(ref, valor);
+  if (!w.ok) return w;
+  const back = await x.backend.ler(ref);
+  if (!back.ok) {
+    // O valor JA esta gravado: "nao-encontrado" (3) e "cofre-nao-configurado" (4) diriam ao agente que nada foi gravado
+    const codigo = back.codigo === 'nao-encontrado' || back.codigo === 'cofre-nao-configurado' ? 'falha' : back.codigo;
+    return fail(codigo, `Gravei no ${x.backend.nome}, mas nao consegui conferir lendo de volta (${oneLine(back.mensagem, 200, [valor])}) Confira que o nome existe com: segredo listar`);
+  }
+  if (back.valor !== valor) {
+    return fail('falha', `Gravei no ${x.backend.nome}, mas o que li de volta nao e igual ao que mandei (o cofre pode ter mudado espacos ou quebras de linha nas pontas). Nao use essa chave ainda: grave de novo por stdin, sem espaco nem linha extra nas pontas (gerador | npx auroq-os segredo gravar ${refText(ref)}).`);
+  }
+  return { ok: true, criado: Boolean(w.criado), cofre: x.tipo };
+}
+
+/** { ok:true, nomes:[...], cofre }: so nomes, nunca valores. */
+async function listar(opts = {}, d = {}) {
+  const x = await resolveBackend(opts, d);
+  if (x.erro) return x.erro;
+  const r = await x.backend.listar();
+  return r.ok ? { ok: true, nomes: r.nomes, cofre: x.tipo } : r;
+}
+
+/**
+ * Apaga. Sem `opts.confirmo` nao apaga: diz se existe, o que sera apagado e pede `--confirmo` (`ja-existe-confirmar`).
+ * No 1Password o item inteiro vai para o Arquivo do app (nao da para apagar so um campo): por isso a confirmacao
+ * diz isso ANTES, e `ITEM/CAMPO --confirmo` so apaga se o campo for o unico com valor do item; senao o agente
+ * precisa pedir o item inteiro de forma explicita (`apagar ITEM --confirmo`).
+ */
+async function apagar(texto, opts = {}, d = {}) {
+  const ref = toRef(texto);
+  if (!ref) return failure('nome-invalido', null);
+  const x = await resolveBackend(opts, d);
+  if (x.erro) return x.erro;
+  const confirmo = Boolean(opts && opts.confirmo);
+  const op = x.tipo === '1password';
+  if (!confirmo || (op && ref.campo !== CREDENTIAL)) {
+    const e = await x.backend.existe(ref);
+    if (!e.ok) return e;
+    if (!e.existe) return failure('nao-encontrado', x.tipo);
+    const campos = op ? (e.campos || []) : [];
+    const lista = campos.slice(0, 8).join(', ') + (campos.length > 8 ? ` e mais ${campos.length - 8}` : '');
+    const comando = `npx auroq-os segredo apagar ${ref.item} --confirmo`;
+    if (op && ref.campo !== CREDENTIAL) {
+      const outros = campos.filter((c) => c.toLowerCase() !== ref.campo.toLowerCase());
+      if (outros.length) {
+        return fail('ja-existe-confirmar', `ATENCAO: o 1Password nao apaga so um campo. Apagar ${refText(ref)} arquivaria o item ${ref.item} INTEIRO, com tudo que tem nele (campos com valor: ${lista}), nao so ${ref.campo}; ele volta pelo Arquivo do app. Se e isso mesmo que o aluno quer, rode: ${comando}`);
+      }
+    }
+    if (!confirmo) {
+      const alvo = ref.campo === CREDENTIAL ? 'a chave principal' : ref.campo;
+      const maisQueOAlvo = campos.some((c) => c.toLowerCase() !== ref.campo.toLowerCase()) ? `, nao so ${alvo}` : '';
+      const inteiro = op ? ` ATENCAO: no 1Password isso arquiva o item ${ref.item} INTEIRO${lista ? ` (campos com valor: ${lista})` : ''}${maisQueOAlvo}; ele volta pelo Arquivo do app.` : '';
+      return fail('ja-existe-confirmar', `O segredo ${refText(ref)} existe no ${x.backend.nome}.${inteiro} Para apagar de verdade, rode de novo com --confirmo.`);
+    }
+  }
+  const r = await x.backend.apagar(ref);
+  return r.ok ? { ok: true, cofre: x.tipo, itemInteiro: op } : r;
+}
+
+/** Cofre ativo e se esta pronto, SEM rede: { tipo: '1password'|'infisical'|'nenhum', pronto: boolean }. */
+async function qual(opts = {}, d = {}) {
+  const tipo = (opts && opts.cofre) || (await detectarTipo(d));
+  if (!tipo || !TIPOS.includes(tipo)) return { tipo: 'nenhum', pronto: false };
+  const pronto = await backends(d)[tipo].pronto();
+  return { tipo, pronto: Boolean(pronto) };
+}
+
+function buildQualLine(q) {
+  return `AUROQ_COFRE tipo=${q.tipo} pronto=${q.pronto ? 'sim' : 'nao'}`;
+}
+
+// ─── segredo (linha de comando) ──────────────────────────
+
+const SEGREDO_USO = 'Uso: auroq-os segredo ler|gravar|apagar <ITEM[/CAMPO]> | listar | qual  [--cofre 1password|infisical]  (gravar: valor por stdin ou --arquivo F; apagar: --confirmo)';
+
+function parseSegredoArgs(argv) {
+  const out = { cmd: null, pos: [], cofre: null, arquivo: null, confirmo: false, erro: null };
+  const args = Array.isArray(argv) ? argv.map(String) : [];
+  const valueOf = (name, i, inline) => {
+    if (inline !== undefined) {
+      if (inline === '') out.erro = out.erro || `Falta o valor de ${name}.`;
+      return { v: inline || null, skip: 0 };
+    }
+    const next = args[i + 1];
+    if (next === undefined || next.startsWith('--')) {
+      out.erro = out.erro || `Falta o valor de ${name}.`;
+      return { v: null, skip: 0 };
+    }
+    return { v: next, skip: 1 };
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--confirmo') out.confirmo = true;
+    else if (a === '--cofre' || a.startsWith('--cofre=')) {
+      const { v, skip } = valueOf('--cofre', i, a.startsWith('--cofre=') ? a.slice(8) : undefined);
+      i += skip;
+      out.cofre = v;
+    } else if (a === '--arquivo' || a.startsWith('--arquivo=')) {
+      const { v, skip } = valueOf('--arquivo', i, a.startsWith('--arquivo=') ? a.slice(10) : undefined);
+      i += skip;
+      out.arquivo = v;
+    } else if (a.startsWith('--')) {
+      // nao repete o texto: o argumento pode ser o proprio valor do segredo (--valor=sk-...)
+      out.erro = out.erro || 'Opcao desconhecida (so existem --cofre, --arquivo e --confirmo).';
+    } else {
+      out.pos.push(a);
+    }
+  }
+  out.cmd = out.pos.shift() || null;
+  if (out.cofre !== null && !TIPOS.includes(out.cofre)) out.erro = out.erro || `Cofre desconhecido${eco(out.cofre)}. Use 1password ou infisical.`;
+  return out;
+}
+
+/** Le o stream inteiro (texto). Sem dado por `idleMs` desiste (stdin aberto e vazio nao pode travar o agente). */
+function readStream(stream, { max = MAX_VALUE_BYTES, idleMs = STDIN_IDLE_MS } = {}) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let total = 0;
+    let done = false;
+    let timer = null;
+    const finish = (r, stop) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      stream.removeListener('data', onData);
+      stream.removeListener('end', onEnd);
+      stream.removeListener('error', onError);
+      if (stop) {
+        try { stream.pause(); } catch { /* ja fechado */ }
+        try { if (typeof stream.destroy === 'function') stream.destroy(); } catch { /* ja fechado */ }
+      }
+      resolve(r);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => finish({ vazio: true }, true), idleMs);
+    };
+    const onData = (chunk) => {
+      const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+      total += b.length;
+      if (total > max) { finish({ grande: true }, true); return; }
+      chunks.push(b);
+      arm();
+    };
+    const onEnd = () => finish({ texto: Buffer.concat(chunks).toString('utf8') }, false);
+    const onError = () => finish({ erro: true }, true);
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onError);
+    arm();
+  });
+}
+
+/** Le no maximo `max + 1` bytes do arquivo (o byte a mais mostra que passou do limite): arquivo enorme nunca vai inteiro para a memoria. */
+function readFileBounded(file, max) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buf = Buffer.alloc(max + 1);
+    let n = 0;
+    while (n < buf.length) {
+      const got = fs.readSync(fd, buf, n, buf.length - n, null);
+      if (got === 0) break;
+      n += got;
+    }
+    return buf.subarray(0, n);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/** Valor a gravar: `--arquivo F` ou stdin (so se nao for terminal). Tira o BOM do Windows, a quebra de linha final e os espacos das pontas. */
+async function readValue(o, d) {
+  let texto;
+  if (o.arquivo) {
+    let lido;
+    try {
+      lido = d.readFile ? d.readFile(o.arquivo) : readFileBounded(o.arquivo, MAX_VALUE_BYTES);
+    } catch {
+      return fail('sem-valor', 'Nao consegui ler o arquivo informado em --arquivo. Confira o caminho.');
+    }
+    // nunca vira o texto "undefined" (nem "[object Object]") gravado como se fosse o segredo
+    if (typeof lido !== 'string' && !Buffer.isBuffer(lido)) return fail('sem-valor', 'Nao consegui ler o arquivo informado em --arquivo. Confira o caminho.');
+    if (Buffer.byteLength(lido) > MAX_VALUE_BYTES) return fail('uso', 'O valor passa de 1 MiB; nao grava.');
+    texto = String(lido);
+  } else {
+    const stdin = d.stdin || process.stdin;
+    if (stdin.isTTY) {
+      return fail('sem-valor', 'O valor nao pode ser digitado aqui nem ir na linha de comando. Mande por pipe (gerador | npx auroq-os segredo gravar ITEM) ou use --arquivo F.');
+    }
+    const lido = await readStream(stdin, { idleMs: d.stdinIdleMs || STDIN_IDLE_MS });
+    if (lido.grande) return fail('uso', 'O valor passa de 1 MiB; nao grava.');
+    if (lido.erro || lido.vazio) return fail('sem-valor', 'Nao recebi o valor por stdin. Mande por pipe ou use --arquivo F.');
+    texto = lido.texto;
+  }
+  const valor = cleanValue(texto);
+  if (valor === '') return fail('sem-valor', 'O valor esta vazio.');
+  // NUL ou U+FFFD = nao e texto UTF-8 (tipico de arquivo UTF-16 salvo pelo PowerShell com ">"): recusa em vez de gravar lixo "conferido"
+  if (/[\u0000\uFFFD]/.test(valor)) {
+    return fail('sem-valor', 'O valor nao parece texto comum (UTF-8); veio de um arquivo UTF-16 do Windows? Salve de novo como UTF-8 ou mande por pipe: gerador | npx auroq-os segredo gravar ITEM');
+  }
+  return { ok: true, valor };
+}
+
+/**
+ * `auroq-os segredo <ler|gravar|listar|apagar|qual> ...` -> codigo de saida (0 ok, 1 erro, 2 uso, 3 nao
+ * encontrado, 4 cofre nao configurado). `ler` escreve o valor em stdout e NADA mais; erro vai so para o
+ * stderr como `AUROQ_ERRO codigo=<c> mensagem="..."`, nunca com valor.
+ */
+async function segredoCli(argv, d = {}) {
+  const out = d.stdout || process.stdout;
+  const errOut = d.stderr || process.stderr;
+  const write = (stream, text) => { stream.write(text); };
+  let secrets = [];
+  const erro = (codigo, mensagem) => {
+    write(errOut, `AUROQ_ERRO codigo=${codigo} mensagem="${quoted(mensagem, 400, secrets)}"\n`);
+    return exitCodeFor(codigo);
+  };
+  try {
+    const o = parseSegredoArgs(argv);
+    if (o.erro) return erro('uso', `${o.erro} ${SEGREDO_USO}`);
+    const opts = { cofre: o.cofre || undefined, confirmo: o.confirmo };
+
+    if (o.cmd === 'qual') {
+      if (o.pos.length) return erro('uso', SEGREDO_USO);
+      write(out, `${buildQualLine(await qual(opts, d))}\n`);
+      return SEGREDO_EXIT.ok;
+    }
+    if (o.cmd === 'listar') {
+      if (o.pos.length) return erro('uso', SEGREDO_USO);
+      const r = await listar(opts, d);
+      if (!r.ok) return erro(r.codigo, r.mensagem);
+      if (r.nomes.length) write(out, `${r.nomes.join('\n')}\n`);
+      return SEGREDO_EXIT.ok;
+    }
+    if (o.cmd === 'ler' || o.cmd === 'apagar' || o.cmd === 'gravar') {
+      if (o.pos.length !== 1) {
+        const dica = o.cmd === 'gravar' && o.pos.length > 1 ? ' O valor nunca vai na linha de comando: mande por stdin ou use --arquivo F.' : '';
+        return erro('uso', `${SEGREDO_USO}${dica}`);
+      }
+      const ref = parseRef(o.pos[0]);
+      // nao repete o nome recebido: quem erra a ordem dos argumentos manda o valor do segredo no lugar do nome
+      if (!ref) {
+        // so o tamanho, nunca o texto: nome com mais de 64 caracteres quase sempre e o valor no lugar do nome
+        const parece = o.pos[0].length > 64 ? ' O que veio no lugar do nome tem mais de 64 caracteres: parece o valor? O valor nunca vai na linha de comando; mande por stdin ou use --arquivo F.' : '';
+        return erro('nome-invalido', `Nome invalido. Use ITEM ou ITEM/CAMPO (letras, numeros, ponto, hifen e underscore; sem "__"; ate 64 caracteres cada).${parece}`);
+      }
+
+      if (o.cmd === 'ler') {
+        const r = await ler(ref, opts, d);
+        if (!r.ok) return erro(r.codigo, r.mensagem);
+        write(out, out.isTTY ? `${r.valor}\n` : r.valor);
+        return SEGREDO_EXIT.ok;
+      }
+      if (o.cmd === 'gravar') {
+        // primeiro o cofre: sem cofre conectado nao adianta esperar o valor no stdin (e o agente recebe o erro certo na hora)
+        const x = await resolveBackend(opts, d);
+        if (x.erro) return erro(x.erro.codigo, x.erro.mensagem);
+        if (!(await x.backend.pronto())) {
+          const sem = failure('cofre-nao-configurado', x.tipo);
+          return erro(sem.codigo, sem.mensagem);
+        }
+        const v = await readValue(o, d);
+        if (!v.ok) return erro(v.codigo, v.mensagem);
+        secrets = [v.valor];
+        const r = await gravar(ref, v.valor, { ...opts, cofre: x.tipo }, d);
+        if (!r.ok) return erro(r.codigo, r.mensagem);
+        write(out, `AUROQ_SEGREDO gravado ref=${refText(ref)} cofre=${r.cofre}\n`);
+        return SEGREDO_EXIT.ok;
+      }
+      const r = await apagar(ref, opts, d);
+      if (!r.ok) return erro(r.codigo, r.mensagem);
+      write(out, `AUROQ_SEGREDO apagado ref=${refText(ref)} cofre=${r.cofre}${r.itemInteiro ? ' nota=item-inteiro-arquivado' : ''}\n`);
+      return SEGREDO_EXIT.ok;
+    }
+    return erro('uso', SEGREDO_USO);
+  } catch (e) {
+    return erro('falha', `Falha inesperada ao falar com o cofre: ${oneLine(e && e.message, 160, secrets)}`);
+  }
+}
+
+// ─── conectar-cofre ──────────────────────────────────────
+
+function parseConectarArgs(argv) {
+  const args = Array.isArray(argv) ? argv.map(String) : [];
+  const o = { cofre: null, cofreInvalido: null, estado: false, agente: false, migrar: false, ignorarForaDoFormato: false, rest: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--cofre' || a.startsWith('--cofre=')) {
+      let v = a.startsWith('--cofre=') ? a.slice(8) : null;
+      if (v === null && args[i + 1] !== undefined && !args[i + 1].startsWith('--')) v = args[++i];
+      if (TIPOS.includes(v)) o.cofre = v;
+      else o.cofreInvalido = v || '';
+    } else if (a === '--migrar') {
+      o.migrar = true;
+    } else if (a === '--ignorar-fora-do-formato') {
+      o.ignorarForaDoFormato = true;
+    } else {
+      if (a === '--estado') o.estado = true;
+      if (a === '--agente') o.agente = true;
+      o.rest.push(a);
+    }
+  }
+  return o;
+}
+
+/** Estado salvo de uma rota: { existe, pronto }. Arquivo ausente ou estragado = nao existe. */
+function stateInfo(d, tipo) {
+  if (d && typeof d.stateInfo === 'function') return d.stateInfo(tipo);
+  try {
+    const file = mod(d, tipo === '1password' ? 'onepassword' : 'infisical').stateFile();
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!data || typeof data !== 'object' || data.versao !== 1 || !data.etapas || typeof data.etapas !== 'object') return { existe: false, pronto: false };
+    return { existe: true, pronto: data.etapas.pronto === 'feito' };
+  } catch {
+    return { existe: false, pronto: false };
+  }
+}
+
+/** Qual rota seguir: --cofre, depois cofre.json, depois a UNICA rota em andamento, depois o que ja esta conectado. null = perguntar. */
+async function escolherRota(o, d) {
+  if (o.cofre) return o.cofre;
+  const c = readCofre(d);
+  if (c) return c.tipo;
+  const andamento = TIPOS.filter((t) => {
+    const s = stateInfo(d, t);
+    return s.existe && !s.pronto;
+  });
+  if (andamento.length === 1) return andamento[0];
+  if (andamento.length === 0) return detectarTipo(d);
+  return null;
+}
+
+/** Roda `fn` guardando o que ela escreve com console.log (a linha de estado das rotas sai por la). */
+async function capturarLinhas(fn) {
+  const original = console.log;
+  const linhas = [];
+  console.log = (...args) => { linhas.push(...util.format(...args).split('\n')); };
+  try {
+    await fn();
+  } finally {
+    console.log = original;
+  }
+  return linhas;
+}
+
+function resultLine(r) {
+  const contagem = r.movidos !== undefined ? ` movidos=${r.movidos} iguais=${r.iguais} falhas=${r.falhas}` : '';
+  return `AUROQ_RESULTADO cofre=${r.status} codigo=${r.codigo}${contagem} mensagem="${quoted(r.mensagem)}"`;
+}
+
+const buildMigrationLine = resultLine;
+
+function escolha(prefixo = '') {
+  return { status: 'aguardando', codigo: 'escolher-cofre', mensagem: `${prefixo}${ESCOLHA_MSG}` };
+}
+
+/** Erros que o aluno resolve (a telemetria do instalador nao os conta como instalacao quebrada). Aceita o resultado ou o codigo. */
+function isStudentActionable(result) {
+  const codigo = typeof result === 'string' ? result : result && result.codigo;
+  if (!codigo) return false;
+  if (codigo === 'origem-indisponivel') return true;
+  for (const nome of ['onepassword', 'infisical']) {
+    try {
+      const m = mod(null, nome);
+      if (typeof m.isStudentActionable === 'function' && m.isStudentActionable(codigo)) return true;
+    } catch { /* modulo ausente: segue */ }
+  }
+  return false;
+}
+
+/**
+ * `auroq-os conectar-cofre [--cofre 1password|infisical] [--agente] [--estado] [--migrar] [flags da rota]`.
+ * Devolve o resultado da rota (ou o proprio: escolha, estado, migracao). Codigo de saida: 0 ok/aguardando, 1 erro.
+ */
+async function conectarCofre(argv = [], d = {}) {
+  const print = d.print || ((line) => console.log(line));
+  const setExit = d.setExit || ((code) => { process.exitCode = code; });
+  const o = parseConectarArgs(argv);
+  const emit = (r) => {
+    print(o.agente ? resultLine(r) : r.mensagem);
+    setExit(r.status === 'erro' ? 1 : 0);
+    return r;
+  };
+
+  if (o.cofreInvalido !== null) return emit(escolha(`Nao conheco esse cofre${eco(o.cofreInvalido)}. `));
+  if (o.migrar) return emit(await migrar({ de: 'infisical', para: '1password', ignorarForaDoFormato: o.ignorarForaDoFormato }, d));
+
+  const tipo = await escolherRota(o, d);
+
+  if (o.estado) {
+    if (!tipo) {
+      print(o.agente ? 'AUROQ_ESTADO cofre=nenhum proxima=escolha' : `Nenhum cofre conectado ainda. ${ESCOLHA_MSG}`);
+      return { status: 'ok', codigo: 'estado', cofre: 'nenhum' };
+    }
+    const rota = mod(d, tipo === '1password' ? 'onepassword' : 'infisical');
+    if (!o.agente) {
+      await rota.connect({ argv: o.rest });
+      return { status: 'ok', codigo: 'estado', cofre: tipo };
+    }
+    const ativo = (await detectarTipo(d)) || 'nenhum';
+    const linhas = await capturarLinhas(() => rota.connect({ argv: o.rest }));
+    const linha = linhas.find((l) => /^AUROQ_ESTADO\b/.test(l));
+    const resto = linha ? linha.replace(/^AUROQ_ESTADO\s*/, '') : `${tipo}=desconhecido`;
+    print(`AUROQ_ESTADO cofre=${ativo} ${resto}`.trim());
+    return { status: 'ok', codigo: 'estado', cofre: ativo };
+  }
+
+  if (!tipo) return emit(escolha());
+
+  const rota = mod(d, tipo === '1password' ? 'onepassword' : 'infisical');
+  // ANTES da rota: ela mesma marca o Infisical como cofre ativo quando termina
+  const tinhaChavesNoUmPassword = tipo === 'infisical' && (await umPasswordAtivo(d));
+  const result = await rota.connect({ argv: o.rest });
+  await registrarSeOk(result, tipo, d, o.rest);
+  if (tinhaChavesNoUmPassword && result && result.status === 'ok') {
+    // escolha explicita do aluno: o Infisical passa a ser o cofre ativo, mas as chaves do 1Password nao vieram junto
+    print(avisoLinha(o.agente, 'cofre=infisical chaves-antigas=1password', AVISO_CHAVES_ANTIGAS));
+  }
+  return result;
+}
+
+/** O 1Password e o cofre ativo e esta pronto neste computador (sem rede)? */
+async function umPasswordAtivo(d) {
+  try {
+    return (await detectarTipo(d)) === '1password' && Boolean(await backends(d)['1password'].pronto());
+  } catch {
+    return false;
+  }
+}
+
+// ─── Migracao Infisical -> 1Password ─────────────────────
+
+function migracao(status, codigo, mensagem, n = {}) {
+  return { status, codigo, movidos: n.movidos || 0, iguais: n.iguais || 0, falhas: n.falhas || 0, mensagem };
+}
+
+/**
+ * Leva as chaves do Infisical para o cofre Claude do 1Password e, so se TUDO foi, troca o cofre ativo (e a UNICA
+ * coisa que troca para o 1Password quem ja usa o Infisical: conectar o 1Password sozinho nao troca). Nao apaga
+ * nada da origem. Cada valor e lido, gravado e relido para conferir, sempre em memoria: nunca aparece em
+ * mensagem. `AUROQ_TESTE` e `AUROQ_TESTE_<codigo>` (segredo de teste da conexao) ficam de fora. Nomes que so diferem na caixa (abc e ABC)
+ * sao falha (o 1Password os juntaria num item so); valor diferente que ja estava no 1Password e trocado pelo do
+ * Infisical e a mensagem diz quais (so nomes). `options.ignorarForaDoFormato`: nomes que o Auroq nao usa ficam
+ * no Infisical, sem impedir a troca.
+ */
+async function migrar(options = {}, d = {}) {
+  const de = (options && options.de) || 'infisical';
+  const para = (options && options.para) || '1password';
+  if (de !== 'infisical' || para !== '1password') {
+    return migracao('erro', 'falha', 'So existe a migracao do Infisical para o 1Password.');
+  }
+  const b = backends(d);
+  const origem = b.infisical;
+  const destino = b['1password'];
+
+  if (!(await origem.pronto())) {
+    return migracao('erro', 'origem-indisponivel', 'O Infisical nao esta conectado neste computador, entao nao tenho de onde levar as chaves.');
+  }
+  if (!(await destino.pronto())) {
+    return migracao('aguardando', 'conectar-1password-primeiro', 'Falta conectar o 1Password neste computador. Rode: npx auroq-os conectar-cofre --cofre 1password --agente. Depois rode a migracao de novo.');
+  }
+  // o cofre Claude precisa estar visivel para a chave do 1Password
+  const vis = await destino.listar();
+  if (!vis.ok) {
+    if (['cofre-nao-configurado', 'credencial-invalida', 'sem-permissao'].includes(vis.codigo)) {
+      return migracao('aguardando', 'conectar-1password-primeiro', `A chave do 1Password deste computador nao enxerga o cofre ${VAULT_NAME}. Rode: npx auroq-os conectar-cofre --cofre 1password --agente. Depois rode a migracao de novo.`);
+    }
+    return migracao('erro', 'falha', `Nao consegui olhar o cofre ${VAULT_NAME} do 1Password agora (${vis.codigo}). Tente de novo em alguns minutos.`);
+  }
+
+  const lista = await origem.chaves();
+  if (!lista.ok) {
+    // chave revogada ou identidade/projeto apagado: esperar nunca resolve; o caminho e gerar a chave de novo.
+    // 'sem-permissao' por causa do plano gratis (plano-restringe) NAO e isso: regenerar a chave nao muda nada.
+    const morta = lista.codigo === 'credencial-invalida' || lista.codigo === 'nao-encontrado'
+      || (lista.codigo === 'sem-permissao' && lista.mensagem !== MSG_PLANO_RESTRINGE);
+    if (morta) {
+      return migracao('erro', 'origem-indisponivel', MSG_ORIGEM_MORTA);
+    }
+    return migracao('erro', 'origem-indisponivel', `Nao consegui listar as chaves do Infisical agora (${lista.codigo}). Tente de novo em alguns minutos.`);
+  }
+  const chaves = lista.chaves.filter((k) => !ehSegredoDeTeste(k));
+  const colide = colisoesDeCaixa(chaves);
+  const ignorarForaDoFormato = Boolean(options && options.ignorarForaDoFormato);
+
+  let movidos = 0;
+  let iguais = 0;
+  const falhou = []; // erro de verdade (rede, cofre, conferencia): rodar de novo pode resolver
+  const colidiram = []; // so diferem na caixa (abc e ABC): no 1Password sao o MESMO nome, uma apagaria a outra
+  const foraDoFormato = []; // nome que o Auroq nao usa (espaco, mais de 64...): rodar de novo nunca resolve
+  const trocadas = []; // o 1Password ja tinha OUTRO valor com esse nome e ficou com o do Infisical
+  for (const chave of chaves) {
+    const ref = refFromKey(chave);
+    // chave fora do formato (ou que nao volta igual) nao tem lugar certo no 1Password: nao se perde em silencio
+    if (!ref || infisicalKey(ref) !== chave) { foraDoFormato.push(oneLine(chave, 80)); continue; }
+    if (colide.has(chave)) { colidiram.push(chave); continue; }
+    const src = await origem.ler(ref);
+    if (!src.ok) { falhou.push(chave); continue; }
+    const atual = await destino.ler(ref);
+    if (atual.ok && atual.valor === src.valor) { iguais += 1; continue; }
+    if (!atual.ok && atual.codigo !== 'nao-encontrado') { falhou.push(chave); continue; }
+    const w = await destino.gravar(ref, src.valor);
+    if (!w.ok) { falhou.push(chave); continue; }
+    const back = await destino.ler(ref);
+    if (back.ok && back.valor === src.valor) {
+      movidos += 1;
+      if (atual.ok && atual.valor !== '') trocadas.push(oneLine(chave, 80));
+    } else {
+      falhou.push(chave);
+    }
+  }
+
+  const lista10 = (a) => a.slice(0, 10).join(', ') + (a.length > 10 ? ` e mais ${a.length - 10}` : '');
+  const aviso = trocadas.length
+    ? ` Atencao: ${trocadas.length} chave(s) ja existiam no 1Password com outro valor e ficaram com o do Infisical (${lista10(trocadas)}); o valor anterior fica no historico do item, no app do 1Password.`
+    : '';
+  const deixadas = ignorarForaDoFormato ? foraDoFormato : [];
+  const bloqueiam = ignorarForaDoFormato ? [] : foraDoFormato;
+  const n = { movidos, iguais, falhas: falhou.length + colidiram.length + bloqueiam.length };
+  if (n.falhas) {
+    let msg = `Passei ${movidos} chave(s) para o 1Password e ${iguais} ja estavam iguais.`;
+    if (falhou.length) msg += ` ${falhou.length} deram erro (${lista10(falhou)}): rode a migracao de novo.`;
+    if (colidiram.length) {
+      msg += ` ${colidiram.length} tem o mesmo nome mudando so maiuscula/minuscula (${lista10(colidiram)}); no 1Password isso e o mesmo nome e uma apagaria a outra, entao nao passei nenhuma delas. No painel do Infisical, deixe so uma de cada par (ou renomeie) e rode de novo.`;
+    }
+    if (bloqueiam.length) {
+      msg += ` ${bloqueiam.length} tem nome que o Auroq nao usa (${lista10(bloqueiam)}): so vale letra, numero, ponto, hifen e underline, ate 64 caracteres, sem espaco e sem dois underlines seguidos. Rodar de novo nao resolve: renomeie ou apague essas chaves no painel do Infisical e rode a migracao, ou, se quiser deixa-las no Infisical (o Auroq nao le esses nomes de qualquer jeito), rode: npx auroq-os conectar-cofre --migrar --ignorar-fora-do-formato.`;
+    }
+    msg += ` Nao troquei o cofre e nao apaguei nada do Infisical.${aviso}`;
+    return migracao('erro', 'migrado-parcial', msg, n);
+  }
+  try {
+    registrar('1password', { anterior: 'infisical' }, d);
+  } catch (e) {
+    return migracao('erro', 'falha', `Passei as chaves, mas nao consegui marcar o 1Password como cofre ativo (${oneLine(e && e.message, 120)}). Rode a migracao de novo.`, n);
+  }
+  const ficaram = deixadas.length ? ` Deixei ${deixadas.length} chave(s) no Infisical porque o nome nao serve para o Auroq (${lista10(deixadas)}); nao apaguei nada.` : '';
+  if (!chaves.length) {
+    return migracao('ok', 'nada-a-migrar', 'O Infisical nao tinha chaves para passar. O 1Password passa a ser o cofre ativo; o Infisical continua como estava.', n);
+  }
+  return migracao('ok', 'migrado', `Passei ${movidos} chave(s) para o 1Password (${iguais} ja estavam iguais). O 1Password e o cofre ativo agora; nao apaguei nada do Infisical.${ficaram}${aviso}`, n);
+}
+
+/** E um segredo de teste da conexao (a migracao nao leva)? So o nome `AUROQ_TESTE` ou `AUROQ_TESTE_<letras e numeros>`. */
+function ehSegredoDeTeste(nome) {
+  return typeof nome === 'string' && TEST_SECRET_RE.test(nome);
+}
+
+/** Chaves canonicas que so diferem na caixa (abc e ABC): o 1Password nao diferencia caixa no titulo nem no campo. */
+function colisoesDeCaixa(chaves) {
+  const porNome = new Map();
+  for (const chave of chaves) {
+    const r = refFromKey(chave);
+    if (!r || infisicalKey(r) !== chave) continue; // fora do formato: ja tem tratamento proprio
+    const nome = `${r.item}\u0000${r.campo}`.toLowerCase();
+    porNome.set(nome, (porNome.get(nome) || []).concat(chave));
+  }
+  const colide = new Set();
+  for (const ks of porNome.values()) if (ks.length > 1) ks.forEach((k) => colide.add(k));
+  return colide;
+}
+
+module.exports = {
+  cofreFile,
+  readCofre,
+  registrar,
+  registrarSeOk,
+  detectarTipo,
+  parseRef,
+  infisicalKey,
+  refFromKey,
+  backends,
+  ler,
+  gravar,
+  listar,
+  apagar,
+  qual,
+  segredoCli,
+  conectarCofre,
+  migrar,
+  buildQualLine,
+  buildMigrationLine,
+  SEGREDO_EXIT,
+  // auxiliares (testes e fiacao)
+  SEGREDO_CODIGOS,
+  exitCodeFor,
+  isStudentActionable,
+  parseSegredoArgs,
+  parseConectarArgs,
+  readStream,
+  oneLine,
+  validName,
+  refText,
+  opReference,
+  itemTemplate,
+  classifyOp,
+  VAULT_NAME,
+  ITEM_TAG,
+  TEST_SECRET,
+  ehSegredoDeTeste,
+  withFileLock,
+  tryLock,
+  tomarVelha,
+  TIPOS,
+  ESCOLHA_MSG,
+};