omnispace 0.7.0 → 0.11.0

package/README.md

@@ -2,7 +2,7 @@
 
 CLI do [Omni](https://omni.tzolkin.cloud): transforma uma pasta da sua máquina em um espaço Omni e sincroniza esse espaço entre máquinas.
 
-> Alpha. Existem `login`, `logout`, `whoami`, `init`, `status`, `sync --push`, `sync --pull` e `clone`.
+> Alpha. Existem `login`, `logout`, `whoami`, `init`, `status`, `sync --push`, `sync --pull`, `clone`, `vincular` e `desvincular`.
 
 Precisa do Node 20 ou mais novo.
 
@@ -40,6 +40,12 @@ Ver o que mudou nesta pasta e no servidor, e qual o próximo comando (só lê, n
 npx -y omnispace@latest status
 ```
 
+Em uma linha só (feito para o hook de início do Claude Code; sai sempre com 0):
+
+```
+npx -y omnispace@latest status --resumo
+```
+
 Publicar uma nova versão do espaço no servidor:
 
 ```
@@ -66,13 +72,36 @@ Baixar um espaço da sua conta em outra máquina (o código aparece no site, em
 npx -y omnispace@latest clone <código> "nome-da-pasta"
 ```
 
+Ligar uma pasta que já tem os arquivos a um espaço da sua conta (criado no site, ou para voltar depois de desvincular). Arquivos iguais ficam, os diferentes perguntam o que fazer:
+
+```
+npx -y omnispace@latest vincular
+```
+
+Tirar esta máquina da conta e o `.omni/` das pastas dela (pede duas confirmações; seus arquivos ficam, e cópias de conflito vão para `omni-backups-<data>/`):
+
+```
+npx -y omnispace@latest desvincular
+```
+
 No Windows, se o caminho tiver espaço ou apóstrofo, entre na pasta com aspas duplas: `cd "C:\caminho\da\pasta"`.
 
 ## O que o Omni lê e envia
 
 - A pasta é lida para montar a lista de arquivos. Sobem só arquivos de texto (Markdown, código, JSON e afins), até 25 MB por arquivo e 100 MB por espaço. Nome de arquivo que o Windows não aceita (como `CON`, `a:b.md` ou terminado em ponto) fica de fora, para o espaço abrir em qualquer sistema.
-- Nunca sobem: `.env` e variações, chaves (`.pem`, `.key`, `id_rsa`), pastas `.git`, `node_modules` e de build, imagens e mídia.
-- Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado.
+- Nunca sobem: `.env` e variações, chaves (`.pem`, `.key`, `id_rsa`), pastas `.git`, `node_modules` e de build, imagens e mídia, e o `.claude/settings.local.json` do Claude Code (configuração de cada máquina; o `.claude/settings.json` sincroniza) e o `.claude/worktrees/` (cópias do repositório das sessões paralelas do Claude Code).
+- Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado. A exceção é `omnispace env push` (abaixo), quando você escolhe chave por chave.
 - Antes de enviar, a CLI mostra o que sobe e o que fica de fora e pede confirmação.
 - Na pasta, o Omni grava só `.omni/space.json` (e, só enquanto um sync roda, `.omni/lock`, `.omni/tmp/` e `.omni/pull-pending.json`, apagados no fim; `.omni/backups/` e `.omni/conflicts.json` quando há conflito). Se um sync for interrompido, rodar o mesmo comando de novo continua de onde parou. Nada disso sincroniza. O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto, legível só pelo seu usuário.
 - A CLI só fala com o servidor por HTTPS (`http` só vale para um servidor na própria máquina, em desenvolvimento).
+
+## Credenciais do `.env` no cofre do espaço
+
+```
+npx -y omnispace@latest env push
+```
+
+Com a CLI logada, dentro da pasta do espaço: a CLI lê os arquivos `.env` da raiz (menos `.env.example`, `.env.sample` e `.env.template`) e pergunta chave por chave se ela vai para o cofre do espaço. Mostra o nome, o arquivo e no máximo os 4 últimos caracteres do valor. Antes de enviar, pede que você confirme no navegador, logado na sua conta, digitando o código do terminal. O valor vai cifrado para o cofre (Vault) e não aparece em tela, log nem resposta. Sem terminal, nada é enviado.
+
+- `env list` mostra as chaves guardadas (só nomes).
+- `env rm <CHAVE> [--arquivo .env.local]` apaga do cofre de vez, também com confirmação no navegador. Se um conector usava a chave, ele fica desligado.

package/dist/ask.js

@@ -0,0 +1,115 @@
+import { basename, resolve } from "node:path";
+import { callApi } from "./api.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+export const ASK_USAGE = 'Uso: omnispace ask "<pergunta>" [pasta] [--fontes] [--detalhes]';
+/** `ask "<pergunta>" [pasta] [--fontes] [--detalhes]`. The question must come quoted: one argument. */
+export function parseAskArgs(rest, cwd = process.cwd()) {
+    const positional = rest.filter((a) => !a.startsWith("--"));
+    const unknown = rest.filter((a) => a.startsWith("--") && a !== "--fontes" && a !== "--detalhes");
+    if (unknown.length > 0)
+        return { error: `Opção desconhecida: ${unknown[0]}\n${ASK_USAGE}` };
+    if (positional.length === 0 || !positional[0].trim())
+        return { error: ASK_USAGE };
+    if (positional.length > 2)
+        return { error: `Coloque a pergunta entre aspas.\n${ASK_USAGE}` };
+    return {
+        question: positional[0].trim(),
+        folder: resolve(cwd, positional[1] ?? "."),
+        sourcesOnly: rest.includes("--fontes"),
+        details: rest.includes("--detalhes"),
+    };
+}
+const REASON = { index: "index.md", log: "log.md", link: "apontado no index", termo: "busca por termo" };
+/** What `omnispace ask` prints, as lines. `baseVersion`: the version this folder is on. */
+export function formatAsk(res, opts) {
+    const out = [];
+    const consultedList = () => {
+        for (const c of res.consulted) {
+            out.push(`  [${c.id}] ${c.path}  (${REASON[c.reason] ?? c.reason}, ${c.chars.toLocaleString("pt-BR")} caracteres${c.truncated ? ", em parte" : ""})`);
+        }
+    };
+    if (opts.sourcesOnly) {
+        out.push(`Arquivos que entrariam na resposta (versão ${res.version}, sem chamar o modelo):`);
+        if (res.consulted.length === 0)
+            out.push("  nenhum");
+        consultedList();
+    }
+    else {
+        out.push("Resposta:", res.answer ?? "", "");
+        const sources = res.sources ?? [];
+        if (sources.length > 0) {
+            out.push("Fontes:");
+            for (const s of sources)
+                out.push(`  [${s.id}] ${s.path}  (versão ${s.version})`);
+        }
+        else {
+            out.push("Fontes: nenhuma citada. Esta resposta não se apoia em arquivo do espaço.");
+        }
+    }
+    out.push("", "Limites:");
+    for (const limit of res.limits)
+        out.push(`  - ${limit}`);
+    if (res.version > 0 && opts.baseVersion < res.version) {
+        out.push(`  - Esta pasta está na versão ${opts.baseVersion}; a resposta usa a versão ${res.version} do servidor.`);
+    }
+    if (opts.details) {
+        const s = res.stats;
+        if (!opts.sourcesOnly) {
+            out.push("", "Consultados:");
+            consultedList();
+        }
+        out.push("", "Custo desta pergunta:");
+        out.push(`  arquivos: ${s.filesUsed ?? 0} usados, ${s.filesScanned ?? 0} lidos na busca, ${s.filesInVersion ?? 0} na versão`);
+        out.push(`  contexto: ${(s.contextChars ?? 0).toLocaleString("pt-BR")} caracteres`);
+        if (s.model) {
+            out.push(`  modelo: ${s.model}, ${s.inputTokens ?? 0} tokens de entrada, ${s.outputTokens ?? 0} de saída`);
+            out.push(`  custo estimado: US$ ${(s.costUsd ?? 0).toFixed(5)}`);
+        }
+        if (s.ms !== undefined)
+            out.push(`  tempo: ${(s.ms / 1000).toFixed(1)} s`);
+    }
+    return out;
+}
+/**
+ * `omnispace ask`: a question about this folder's space, answered by the server from the latest
+ * published version. Reads nothing from the folder besides .omni/space.json, and writes nothing.
+ * Never retried: an answer costs tokens.
+ */
+export async function askSpace(args) {
+    const config = await readSpaceConfig(args.folder);
+    if (!config) {
+        console.log(`\n${basename(args.folder)} não é um espaço Omni (não tem .omni/space.json).`);
+        console.log("Rode o ask de dentro da pasta de um espaço, ou passe o caminho dela.\n");
+        return 1;
+    }
+    if (!config.spaceId) {
+        console.log("\nEsta pasta foi vinculada pelo navegador, mas o espaço ainda não foi criado.\n");
+        return 1;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.log(`\nNenhuma sessão da CLI nesta máquina para ${config.apiUrl}.`);
+        console.log("Para entrar: omnispace login\n");
+        return 1;
+    }
+    if (!args.sourcesOnly)
+        console.log("\n→ Consultando a versão publicada...");
+    const res = await callApi(config.apiUrl, token, "/api/cli/ask", {
+        spaceId: config.spaceId,
+        question: args.question,
+        sourcesOnly: args.sourcesOnly,
+    });
+    if (!res.ok) {
+        console.log(`\nSem resposta: ${res.error}`);
+        if (res.expired || res.status === 401)
+            console.log("Para entrar de novo: omnispace login");
+        console.log("");
+        return 1;
+    }
+    console.log("");
+    const opts = { baseVersion: config.baseVersion, sourcesOnly: args.sourcesOnly, details: args.details };
+    for (const line of formatAsk(res, opts))
+        console.log(line);
+    console.log("");
+    return 0;
+}

package/dist/desvincular.js

@@ -0,0 +1,148 @@
+import { readdir, rename, rm, stat } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+import { join, resolve } from "node:path";
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { readJournal } from "./journal.js";
+import { defaultApiUrl, loadCredential, readSpaceConfig, removeToken } from "./config.js";
+import { LOCAL_BACKUPS_DIR } from "./include.js";
+export async function terminalAsk(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function freeName(base) {
+    for (let n = 1;; n++) {
+        const candidate = n === 1 ? base : `${base}-${n}`;
+        if (!(await exists(candidate)))
+            return candidate;
+    }
+}
+/**
+ * Takes the Omni out of one folder: `.omni/` goes, every other file stays. Conflict backups are
+ * the person's work, so a non-empty `.omni/backups/` is moved to `omni-backups-<data>` in the same
+ * folder first. Only touches a folder whose `.omni/space.json` is of `spaceId` (when given), so a
+ * stale path from the server can never clean the wrong folder.
+ */
+export async function cleanFolder(root, spaceId, today = new Date()) {
+    const config = await readSpaceConfig(root);
+    if (!config)
+        return { cleaned: false, skipped: "não tem .omni/space.json" };
+    if (spaceId && config.spaceId !== spaceId)
+        return { cleaned: false, skipped: "é de outro espaço" };
+    let backupsMovedTo;
+    const backups = join(root, ...LOCAL_BACKUPS_DIR.split("/"));
+    if ((await exists(backups)) && (await readdir(backups)).length > 0) {
+        backupsMovedTo = await freeName(join(root, `omni-backups-${today.toISOString().slice(0, 10)}`));
+        await rename(backups, backupsMovedTo);
+    }
+    await rm(join(root, ".omni"), { recursive: true, force: true });
+    return { cleaned: true, backupsMovedTo };
+}
+/**
+ * `omnispace desvincular [pasta]` (P1, Lucas 2026-09-27): this machine leaves the account and the
+ * Omni leaves its folders. Asks twice. Works when the machine was already removed on the web
+ * (then only the disk is cleaned: the given folder and the CLI session).
+ */
+export async function unlinkMachine(root, ask = process.stdin.isTTY ? terminalAsk : null) {
+    if (!ask) {
+        console.error("desvincular pede duas confirmações e precisa de um terminal. Rode direto no terminal, sem pipe.");
+        return 1;
+    }
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    let machineName = null;
+    let serverKnows = false;
+    const folders = [];
+    const seen = new Set();
+    const addFolder = async (path, spaceId, name) => {
+        const abs = resolve(path);
+        const key = abs.toLowerCase();
+        if (seen.has(key))
+            return;
+        const config = await readSpaceConfig(abs);
+        if (!config || (spaceId && config.spaceId !== spaceId))
+            return;
+        seen.add(key);
+        folders.push({ root: abs, spaceId: config.spaceId ?? spaceId, name, pullInterrupted: (await readJournal(abs)) !== null });
+    };
+    if (credential) {
+        const res = await callApi(apiUrl, credential.token, "/api/cli/machine", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (res.ok) {
+            serverKnows = true;
+            machineName = res.name ?? null;
+            for (const i of res.installations) {
+                if (i.localPath)
+                    await addFolder(i.localPath, i.spaceId, i.name);
+            }
+        }
+        else if (res.status !== 401) {
+            console.error(`Não deu para falar com o servidor: ${res.error}. Nada foi alterado; tente de novo.`);
+            return 1;
+        }
+    }
+    await addFolder(root, null, "esta pasta");
+    if (!serverKnows && !credential && folders.length === 0) {
+        console.log("Nada para desvincular: esta máquina não tem sessão da CLI e esta pasta não é um espaço Omni.");
+        return 0;
+    }
+    console.log("\nO que vai acontecer:");
+    if (serverKnows)
+        console.log(`  • A máquina ${machineName ?? "desta sessão"} sai da sua conta (as versões que ela publicou ficam).`);
+    else if (credential)
+        console.log("  • A sessão da CLI já não vale no servidor (máquina removida ou sessão encerrada); só o disco é limpo.");
+    if (credential)
+        console.log("  • A sessão da CLI desta máquina é apagada (~/.omni).");
+    for (const f of folders) {
+        console.log(`  • ${f.root}: sai a pasta .omni/ (${f.name}); seus arquivos ficam.`);
+        if (f.pullInterrupted)
+            console.log("      atenção: um pull parou no meio nesta pasta e não vai poder ser retomado.");
+    }
+    if (folders.length === 0)
+        console.log("  • Nenhuma pasta com .omni/ encontrada nesta máquina.");
+    console.log("  • Cópias de conflito em .omni/backups/, se houver, vão para omni-backups-<data>/ na mesma pasta.");
+    console.log("\nPara voltar depois: omnispace login e, dentro da pasta, omnispace vincular.\n");
+    const first = (await ask("Continuar? (s/n) ")).toLowerCase();
+    if (first !== "s" && first !== "sim") {
+        console.log("Nada foi alterado.");
+        return 1;
+    }
+    const second = await ask('Para confirmar, digite "remover": ');
+    if (second.toLowerCase() !== "remover") {
+        console.log("Confirmação não bateu. Nada foi alterado.");
+        return 1;
+    }
+    if (serverKnows && credential) {
+        // Not retried: a repeat after a cut connection would answer 401, which is handled next time.
+        const left = await callApi(apiUrl, credential.token, "/api/cli/machine/leave", {});
+        if (!left.ok && left.status !== 401) {
+            console.error(`O servidor não removeu a máquina: ${left.error}. Nada foi alterado no disco; tente de novo.`);
+            return 1;
+        }
+    }
+    for (const f of folders) {
+        const result = await cleanFolder(f.root, f.spaceId);
+        if (!result.cleaned)
+            console.log(`  ${f.root}: ficou como estava (${result.skipped}).`);
+        else
+            console.log(`✓ ${f.root}: .omni/ removida${result.backupsMovedTo ? `; cópias de conflito em ${result.backupsMovedTo}` : ""}.`);
+    }
+    if (credential)
+        await removeToken(apiUrl);
+    console.log("✓ Esta máquina não está mais ligada ao Omni.");
+    console.log("  Para voltar: omnispace login e, dentro da pasta, omnispace vincular.\n");
+    return 0;
+}

package/dist/dotenv.js

@@ -0,0 +1,100 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+// Leitura dos `.env` da pasta para `omnispace env push` (pós-marco C1; ADR 004). Diferente da
+// varredura (scan.ts), aqui o valor é lido de propósito, porque a pessoa vai decidir chave por chave
+// o que sobe para o cofre. O valor fica só na memória deste processo: nunca é impresso (só os 4
+// últimos caracteres, e só de valor longo), nunca vai para arquivo nem para log.
+const MAX_ENV_BYTES = 256 * 1024;
+/** Same rule as the server (lib/cli-verify.ts): `.env`, `.env.local`, `.env.production.local`. */
+export const ENV_FILE_RE = /^\.env(\.[A-Za-z0-9_-]{1,32}){0,3}$/;
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+/** Files that hold placeholders, not the real values. */
+const TEMPLATE_RE = /(^|\.)(example|sample|template|dist|defaults?)(\.|$)/i;
+/**
+ * Parses a `.env` the way dotenv does for the common cases: `export KEY=v`, spaces around `=`,
+ * unquoted values with a trailing ` # comment`, single quotes (literal), double quotes (with \n and
+ * multi-line). A later line with the same key wins. Lines that are not assignments are skipped.
+ */
+export function parseDotenv(text, file = ".env") {
+    const lines = text.replace(/^/, "").split(/\r?\n/);
+    const byKey = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).replace(/^export\s+/, "").trim();
+        if (!ENV_KEY_RE.test(key))
+            continue;
+        let rest = line.slice(eq + 1).trim();
+        let value;
+        const quote = rest[0];
+        if (quote === '"' || quote === "'" || quote === "`") {
+            // Multi-line quoted value: keep reading lines until the closing quote.
+            let body = rest.slice(1);
+            let close = findClosing(body, quote);
+            while (close < 0 && i + 1 < lines.length) {
+                i++;
+                body += `\n${lines[i]}`;
+                close = findClosing(body, quote);
+            }
+            if (close < 0)
+                continue; // never closed: not a value we can trust
+            value = body.slice(0, close);
+            if (quote === '"')
+                value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+        }
+        else {
+            const hash = rest.search(/\s#/);
+            if (hash >= 0)
+                rest = rest.slice(0, hash);
+            value = rest.trim();
+        }
+        byKey.set(key, { file, key, value });
+    }
+    return [...byKey.values()];
+}
+function findClosing(body, quote) {
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] === "\\" && quote === '"') {
+            i++;
+            continue;
+        }
+        if (body[i] === quote)
+            return i;
+    }
+    return -1;
+}
+/** The `.env` files at the root of the folder, without templates, in a stable order. */
+export async function listEnvFiles(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    return entries
+        .filter((e) => e.isFile() && ENV_FILE_RE.test(e.name) && !TEMPLATE_RE.test(e.name.slice(4)))
+        .map((e) => e.name)
+        .sort((a, b) => (a === ".env" ? -1 : b === ".env" ? 1 : a.localeCompare(b)));
+}
+/** Every variable of every `.env` at the root. Empty values are skipped (nothing to keep). */
+export async function readEnvVars(root) {
+    const vars = [];
+    const skipped = [];
+    for (const file of await listEnvFiles(root)) {
+        const path = join(root, file);
+        if ((await stat(path)).size > MAX_ENV_BYTES) {
+            skipped.push(file);
+            continue;
+        }
+        vars.push(...parseDotenv(await readFile(path, "utf8"), file).filter((v) => v.value !== ""));
+    }
+    return { vars, skipped };
+}
+/**
+ * What the terminal shows of a value: the last 4 characters, and only when the value is long enough
+ * for 4 characters to say nothing useful about it (ADR 004 and barrier 4).
+ */
+export function maskValue(value) {
+    if (value.length < 12 || /\s/.test(value.slice(-4)))
+        return "(valor não mostrado)";
+    return `••••${value.slice(-4)}`;
+}

package/dist/env.js

@@ -0,0 +1,243 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callApi } from "./api.js";
+import { insecureApiUrl, loadToken, readSpaceConfig } from "./config.js";
+import { maskValue, readEnvVars } from "./dotenv.js";
+import { openBrowser } from "./login.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+const STATUS_TEXT = {
+    active: "conectado",
+    active_limited: "conectado com limitação",
+    error: "com erro",
+    disabled: "desligado",
+};
+const USAGE = `Uso:
+  omnispace env push [pasta]                      pergunta chave por chave o que vai para o cofre do espaço
+  omnispace env list [pasta]                      mostra as chaves guardadas (só nomes)
+  omnispace env rm <CHAVE>... [--arquivo .env] [--pasta <pasta>]  apaga do cofre, de vez`;
+async function askTerminal(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** The space of this folder and this machine's session, or a printed reason why not. */
+async function context(root) {
+    const config = await readSpaceConfig(root);
+    if (!config?.spaceId) {
+        console.error(config ? "O espaço desta pasta ainda não foi criado. Termine a conta no navegador." : "Esta pasta não é um espaço Omni. Rode omnispace init primeiro.");
+        return null;
+    }
+    // Barrier 1: credentials only travel over https, whatever the folder's config says.
+    const insecure = insecureApiUrl(config.apiUrl);
+    if (insecure) {
+        console.error(insecure);
+        return null;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.error("Nenhuma sessão da CLI nesta máquina. Para entrar: omnispace login");
+        return null;
+    }
+    return { apiUrl: config.apiUrl, token, spaceId: config.spaceId };
+}
+function refused(res, what) {
+    console.error(`${what}: ${res.error}`);
+    if (res.expired || res.status === 401)
+        console.error("Para entrar de novo: omnispace login");
+}
+/**
+ * Asks for the on-the-spot verification and waits for the browser. Returns the device code to send
+ * with the action, or null (refused, expired, failed).
+ */
+async function verify(ctx, action, keys, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const start = await callApi(ctx.apiUrl, ctx.token, "/api/cli/verify/start", { spaceId: ctx.spaceId, action, keys }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!start.ok) {
+        refused(start, "Falha ao pedir a verificação");
+        return null;
+    }
+    const deviceCode = start.deviceCode;
+    const expiresAt = Date.now() + start.expiresIn * 1000;
+    const waitMs = opts.pollMs ?? start.interval * 1000;
+    log("");
+    log("Confirme no navegador, logado na sua conta:");
+    log(`  ${start.verifyUrl}`);
+    log("e digite este código:");
+    log(`  ${start.userCode}`);
+    log("");
+    if (opts.openBrowser)
+        openBrowser(start.verifyUrl);
+    log("→ Esperando a confirmação (Ctrl+C cancela, nada é enviado)...");
+    while (Date.now() < expiresAt) {
+        await new Promise((r) => setTimeout(r, waitMs));
+        const poll = await callApi(ctx.apiUrl, ctx.token, "/api/cli/verify/poll", { deviceCode }, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (poll.ok && poll.state === "pending")
+            continue;
+        if (poll.ok && poll.state === "approved")
+            return deviceCode;
+        console.error(poll.denied ? "Recusado no navegador. Nada foi enviado." : `Verificação não concluída: ${poll.error}`);
+        return null;
+    }
+    console.error("O código expirou antes da confirmação. Nada foi enviado.");
+    return null;
+}
+async function readVault(ctx) {
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/list", { spaceId: ctx.spaceId }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok) {
+        refused(res, "Falha ao ler o cofre do espaço");
+        return null;
+    }
+    return { keys: res.keys, connectors: (res.connectors ?? []) };
+}
+async function push(root, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ask = opts.ask ?? askTerminal;
+    const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+    if (!interactive) {
+        console.error("omnispace env push só roda num terminal, porque cada chave é decidida por você. Nada foi enviado.");
+        return 1;
+    }
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const { vars, skipped } = await readEnvVars(root);
+    for (const file of skipped)
+        console.error(`${file} ficou de fora: maior que 256 KB.`);
+    if (vars.length === 0) {
+        log("Nenhuma variável com valor nos arquivos .env da raiz desta pasta. Nada a enviar.");
+        return 0;
+    }
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    const already = new Set(vault.keys.map((s) => `${s.file}\n${s.key}`));
+    log("");
+    log(`${vars.length} variáveis nos arquivos .env desta pasta. Para cada uma, responda:`);
+    log("  s = guardar no cofre do espaço   n = pular   q = parar de perguntar");
+    log("O valor vai cifrado para o cofre (Vault) e nunca aparece na tela nem em log.");
+    log("");
+    const accepted = [];
+    for (const v of vars) {
+        const note = already.has(`${v.file}\n${v.key}`) ? "  [já está no cofre, será substituída]" : "";
+        const answer = (await ask(`  ${v.key}  (${v.file})  ${maskValue(v.value)}${note}  Guardar? [s/n/q] `)).toLowerCase();
+        if (answer === "q")
+            break;
+        if (answer === "s" || answer === "sim" || answer === "y")
+            accepted.push(v);
+    }
+    if (accepted.length === 0) {
+        log("\nNada escolhido. Nada foi enviado.");
+        return 0;
+    }
+    const keys = accepted.map(({ file, key }) => ({ file, key }));
+    const deviceCode = await verify(ctx, "env_push", keys, opts);
+    if (!deviceCode)
+        return 1;
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/store", {
+        spaceId: ctx.spaceId,
+        verification: deviceCode,
+        entries: accepted.map(({ file, key, value }) => ({ file, key, value })),
+    });
+    if (!res.ok) {
+        refused(res, "O cofre recusou o envio");
+        return 1;
+    }
+    log("");
+    for (const s of res.stored) {
+        log(`✓ ${s.key} (${s.file}) ${s.replaced ? "substituída" : "guardada"} no cofre`);
+    }
+    for (const c of (res.connectors ?? [])) {
+        log(`${c.state === "linked" ? "✓" : "!"} ${c.message}`);
+        if (c.test?.ok)
+            log("  ✓ Teste de conexão passou: o conector está ligado para o Omni neste espaço.");
+        else if (c.test)
+            log(`  ✗ Teste de conexão falhou: ${c.test.message ?? "sem detalhe"}. O conector fica desligado até passar.`);
+    }
+    log("");
+    return 0;
+}
+async function list(root, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    if (vault.keys.length === 0) {
+        log("O cofre deste espaço está vazio. Para guardar chaves do .env: omnispace env push");
+    }
+    else {
+        log(`${vault.keys.length} chave(s) no cofre deste espaço (só nomes, nenhum valor sai do cofre):`);
+        for (const s of vault.keys)
+            log(`  ${s.key}  (${s.file})  atualizada em ${new Date(s.updatedAt).toLocaleString("pt-BR")}`);
+    }
+    if (vault.connectors.length > 0) {
+        log("");
+        log("Conectores do espaço:");
+        for (const c of vault.connectors) {
+            const state = !c.hasCredential ? "sem credencial" : (STATUS_TEXT[c.status] ?? c.status);
+            log(`  ${c.name}: ${state}${c.status === "error" && c.message ? ` (${c.message})` : ""}`);
+        }
+    }
+    return 0;
+}
+async function remove(root, names, file, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    if (names.length === 0) {
+        console.error(USAGE);
+        return 1;
+    }
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    const targets = vault.keys.filter((s) => names.includes(s.key) && (!file || s.file === file)).map(({ file: f, key }) => ({ file: f, key }));
+    const unknown = names.filter((n) => !targets.some((t) => t.key === n));
+    for (const n of unknown)
+        console.error(`${n}${file ? ` (${file})` : ""} não está no cofre deste espaço.`);
+    if (targets.length === 0)
+        return 1;
+    log(`Vai apagar do cofre, de vez: ${targets.map((t) => `${t.key} (${t.file})`).join(", ")}`);
+    const deviceCode = await verify(ctx, "env_rm", targets, opts);
+    if (!deviceCode)
+        return 1;
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/remove", { spaceId: ctx.spaceId, verification: deviceCode, keys: targets });
+    if (!res.ok) {
+        refused(res, "O cofre recusou");
+        return 1;
+    }
+    for (const r of res.removed)
+        log(`✓ ${r.key} (${r.file}) apagada do cofre`);
+    for (const c of (res.disconnected ?? []))
+        log(`! O conector ${c} usava essa credencial: a cópia dele foi apagada e ele ficou desligado.`);
+    return unknown.length > 0 ? 1 : 0;
+}
+/** `omnispace env <push|list|rm> ...`, the one entry in the dispatcher (index.ts). */
+export async function runEnv(args, opts = {}) {
+    const [sub, ...rest] = args;
+    const valueOf = (flag) => {
+        const eq = rest.find((a) => a.startsWith(`${flag}=`));
+        if (eq)
+            return eq.slice(flag.length + 1);
+        const i = rest.indexOf(flag);
+        return i >= 0 ? rest[i + 1] : undefined;
+    };
+    // The word after `--arquivo` or `--pasta` is that flag's value, not a key name.
+    const flagValues = new Set(["--arquivo", "--pasta"].map((f) => rest.indexOf(f)).filter((i) => i >= 0).map((i) => rest[i + 1]));
+    const positional = rest.filter((a) => !a.startsWith("-") && !flagValues.has(a));
+    if (sub === "push")
+        return push(resolve(positional[0] ?? process.cwd()), opts);
+    if (sub === "list")
+        return list(resolve(positional[0] ?? process.cwd()), opts);
+    if (sub === "rm")
+        return remove(resolve(valueOf("--pasta") ?? process.cwd()), positional, valueOf("--arquivo"), opts);
+    console.error(USAGE);
+    return 1;
+}

package/dist/include.js

@@ -57,6 +57,25 @@ export function isSecret(name) {
         /^id_(rsa|ed25519|ecdsa)/.test(lower) ||
         /\.(pem|key|p12|pfx)$/.test(lower));
 }
+/**
+ * Settings of a tool on this machine that happen to live in the folder: Claude Code keeps
+ * permissions and local choices in `.claude/settings.local.json` (the shared `settings.json`
+ * does sync). Out of the sync since 2026-09-27 (Lucas, P1 fatia 2); it can carry values
+ * specific to one machine.
+ */
+const MACHINE_CONFIG_RE = /(^|\/)\.claude\/settings\.local\.json$/i;
+export function isMachineConfig(path) {
+    return MACHINE_CONFIG_RE.test(path);
+}
+/**
+ * A path the policy keeps out by its name alone. Older versions on the server may still hold
+ * such a path (settings.local.json synced until 2026-09-27): pull and status drop it from the
+ * comparison, so it is never deleted or overwritten here because the server stopped having it.
+ */
+export function neverSyncs(path) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    return isSecret(name) || isMachineConfig(path) || isLocalOnly(path);
+}
 export function isText(name) {
     const lower = name.toLowerCase();
     if (TEXT_NAMES.has(lower))
@@ -150,6 +169,10 @@ export async function buildManifest(root) {
                 excluded.push({ path, reason: "segredo" });
                 continue;
             }
+            if (isMachineConfig(path)) {
+                excluded.push({ path, reason: "configuração desta máquina" });
+                continue;
+            }
             if (!isText(entry.name)) {
                 excluded.push({ path, reason: "binário ou mídia" });
                 continue;

package/dist/index.js

@@ -14,24 +14,34 @@ import { defaultApiUrl, insecureApiUrl } from "./config.js";
 import { login, logout, printWhoami, whoami } from "./login.js";
 import { initWithAccount } from "./init-account.js";
 import { statusSpace } from "./status.js";
-const USAGE = `
-Omni CLI
-
-Uso:
-  omni login                        entra na sua conta pelo navegador (a sessão vale 14 dias sem uso)
-  omni logout                       encerra a sessão da CLI nesta máquina
-  omni whoami                       mostra a conta, a máquina e até quando a sessão vale
-  omni init [pasta] [--nome <nome>] com a CLI logada, cria o espaço na sua conta e liga a pasta
-  omni init [pasta] --scan-only     varre a pasta e mostra o que encontrou
-  omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
-  omni status [pasta]               o que mudou aqui e no servidor, e o próximo comando (só lê)
-  omni sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
-  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
-        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
-  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
-
-A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
-varrido é decidido na tela de revisão, no navegador.
+import { terminalAsk, unlinkMachine } from "./desvincular.js";
+import { linkExistingSpace } from "./vincular.js";
+import { askSpace, parseAskArgs } from "./ask.js";
+import { runEnv } from "./env.js";
+const USAGE = `
+Omni CLI
+
+Uso:
+  omni login                        entra na sua conta pelo navegador (a sessão vale 14 dias sem uso)
+  omni logout                       encerra a sessão da CLI nesta máquina
+  omni whoami                       mostra a conta, a máquina e até quando a sessão vale
+  omni init [pasta] [--nome <nome>] com a CLI logada, cria o espaço na sua conta e liga a pasta
+  omni init [pasta] --scan-only     varre a pasta e mostra o que encontrou
+  omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
+  omni status [pasta] [--resumo]    o que mudou aqui e no servidor, e o próximo comando (só lê)
+  omni ask "<pergunta>" [pasta]     responde com base na versão publicada do espaço, com as fontes
+        [--fontes]                  só mostra quais arquivos seriam lidos, sem chamar o modelo
+        [--detalhes]                mostra também custo, contexto e arquivos consultados
+  omni sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
+  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
+        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
+  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
+  omni vincular [pasta] [--espaco <nome>]  liga uma pasta que já tem os arquivos a um espaço da conta
+  omni desvincular [pasta]          tira esta máquina da conta e o .omni/ das pastas (pede 2 confirmações)
+  omni env push|list|rm [pasta]     guarda chaves do .env no cofre do espaço, uma a uma (confirma no navegador)
+
+A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
+varrido é decidido na tela de revisão, no navegador.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -55,8 +65,29 @@ async function main(argv) {
         return runSync(args.slice(1));
     if (command === "clone")
         return runClone(args.slice(1));
-    if (command === "status")
-        return statusSpace(resolve(args.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd()));
+    if (command === "env")
+        return runEnv(args.slice(1), { openBrowser: process.stdout.isTTY });
+    if (command === "vincular") {
+        const rest = args.slice(1);
+        const espacoIndex = rest.indexOf("--espaco");
+        const espaco = rest.find((a) => a.startsWith("--espaco="))?.slice("--espaco=".length) ?? (espacoIndex >= 0 ? rest[espacoIndex + 1] : undefined);
+        const folder = rest.find((a, i) => !a.startsWith("-") && (espacoIndex < 0 || i !== espacoIndex + 1));
+        return linkExistingSpace(folder ?? process.cwd(), { espaco, yes: rest.includes("--yes") }, process.stdin.isTTY ? terminalAsk : null);
+    }
+    if (command === "desvincular")
+        return unlinkMachine(resolve(args.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd()));
+    if (command === "status") {
+        const rest = args.slice(1);
+        return statusSpace(resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()), { resumo: rest.includes("--resumo") });
+    }
+    if (command === "ask") {
+        const ask = parseAskArgs(args.slice(1));
+        if ("error" in ask) {
+            console.error(ask.error);
+            return 1;
+        }
+        return askSpace(ask);
+    }
     if (command !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());
@@ -83,20 +114,20 @@ async function main(argv) {
             if (!who.ok && !who.noToken)
                 console.error(`\n${who.error}`);
             const site = defaultApiUrl();
-            console.log(`
-Omni CLI
-
-Já tem conta no Omni? Entre por aqui e rode o init de novo:
-  npx -y omnispace@latest login
-
-Primeira vez? Comece pelo navegador:
-  ${site}/omnispace/escolha
-
-Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, rode:
-  npx -y omnispace@latest init . --link <código>
-
-Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
-  npx -y omnispace@latest init . --scan-only
+            console.log(`
+Omni CLI
+
+Já tem conta no Omni? Entre por aqui e rode o init de novo:
+  npx -y omnispace@latest login
+
+Primeira vez? Comece pelo navegador:
+  ${site}/omnispace/escolha
+
+Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, rode:
+  npx -y omnispace@latest init . --link <código>
+
+Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
+  npx -y omnispace@latest init . --scan-only
 `);
             return who.ok || who.noToken ? 0 : 1;
         }

package/dist/login.js

@@ -10,7 +10,7 @@ import { RETRY_DELAYS_MS } from "./retry.js";
  * Opens the page in the default browser. Best effort: the URL is always printed too. Only http(s)
  * URLs, and never through a shell (on Windows `cmd /c start` would parse `&` and `|` in the URL).
  */
-function openBrowser(url) {
+export function openBrowser(url) {
     if (!/^https?:\/\//.test(url))
         return;
     const os = platform();

package/dist/pull.js

@@ -5,7 +5,7 @@ import { homedir, platform } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { callApi } from "./api.js";
 import { isRetryableStatus, RETRY_DELAYS_MS, RetryableError, withRetry } from "./retry.js";
-import { buildManifest, hashFile, LOCAL_BACKUPS_DIR, LOCAL_TMP_DIR } from "./include.js";
+import { buildManifest, hashFile, LOCAL_BACKUPS_DIR, LOCAL_TMP_DIR, neverSyncs } from "./include.js";
 import { mergeText } from "./merge.js";
 import { addConflicts } from "./conflicts.js";
 import { ApplyError, applyJournal, clearJournal, readJournal, writeJournal } from "./journal.js";
@@ -13,6 +13,14 @@ import { withLock } from "./lock.js";
 import { pushSpace } from "./sync.js";
 import { printUnreadable } from "./report.js";
 import { defaultApiUrl, loadToken, machineHostname, readSpaceConfig, saveToken, writeSpaceConfig, } from "./config.js";
+/**
+ * A server manifest as path → hash, minus the paths the policy keeps out. A path excluded after
+ * it had synced (settings.local.json, 2026-09-27) is still in old versions: left in, the pull on
+ * another machine would delete that machine's own copy. Used by pull and status.
+ */
+export function remoteMap(list) {
+    return new Map(list.filter((f) => !neverSyncs(f.path)).map((f) => [f.path, f.hash]));
+}
 /**
  * Three-way comparison per path (ADR 002): local, base (the version this folder last synced) and
  * head. Maps are path → hash; a missing path means "does not exist".
@@ -323,8 +331,8 @@ async function pullWith(root, config, token, opts, asker) {
     }
     const head = pull.head;
     const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
-    const base = new Map(pull.base.map((f) => [f.path, f.hash]));
-    const headMap = new Map(pull.files.map((f) => [f.path, f.hash]));
+    const base = remoteMap(pull.base);
+    const headMap = remoteMap(pull.files);
     const plan = planPull(local, base, headMap);
     if (head === config.baseVersion) {
         if (head === 0)

package/dist/status.js

@@ -4,7 +4,7 @@ import { RETRY_DELAYS_MS } from "./retry.js";
 import { buildManifest } from "./include.js";
 import { unresolvedConflicts } from "./conflicts.js";
 import { readJournal } from "./journal.js";
-import { planPull } from "./pull.js";
+import { planPull, remoteMap } from "./pull.js";
 import { loadToken, readSpaceConfig } from "./config.js";
 /**
  * What `omnispace status` reports, from the same three-way comparison the pull uses (ADR 002).
@@ -67,33 +67,50 @@ function countKinds(changes) {
  * server does not, what the server has that the folder does not, and the next command. Read only:
  * no lock, nothing written to the folder or to `.omni/`.
  */
-export async function statusSpace(root) {
+export async function statusSpace(root, opts = {}) {
+    // --resumo: one line, always exit 0. Made for the Claude Code SessionStart hook, whose output
+    // becomes context for the agent: it must never break the session start.
+    const brief = (line) => {
+        console.log(`Omni: ${line}`);
+        return 0;
+    };
     const config = await readSpaceConfig(root);
     if (!config) {
+        if (opts.resumo)
+            return brief("esta pasta não é um espaço Omni.");
         console.log(`\n${basename(root)} não é um espaço Omni (não tem .omni/space.json).`);
         console.log("Para transformar esta pasta num espaço: omnispace init\n");
         return 1;
     }
     if (!config.spaceId) {
+        if (opts.resumo)
+            return brief("pasta vinculada, espaço ainda não criado no navegador.");
         console.log("\nEsta pasta foi vinculada pelo navegador, mas o espaço ainda não foi criado.");
         console.log("Termine a conta no navegador e depois rode: omnispace sync --push\n");
         return 1;
     }
     const token = await loadToken(config.apiUrl);
     if (!token) {
+        if (opts.resumo)
+            return brief("CLI sem sessão nesta máquina; rode omnispace login.");
         console.log(`\nNenhuma sessão da CLI nesta máquina para ${config.apiUrl}.`);
         console.log("Para entrar: omnispace login\n");
         return 1;
     }
     const [journal, markers] = await Promise.all([readJournal(root), unresolvedConflicts(root, { readOnly: true })]);
-    console.log("\n→ Lendo a pasta...");
+    if (!opts.resumo)
+        console.log("\n→ Lendo a pasta...");
     const manifest = await buildManifest(root);
     if (manifest.truncated) {
+        if (opts.resumo)
+            return brief("pasta grande demais para comparar.");
         console.error("Pasta grande ou funda demais para comparar (limite de 20.000 arquivos e 12 níveis).");
         return 1;
     }
     const res = await callApi(config.apiUrl, token, "/api/cli/sync/status", { spaceId: config.spaceId, baseVersion: config.baseVersion }, { retryDelaysMs: RETRY_DELAYS_MS });
     if (!res.ok) {
+        if (opts.resumo)
+            return brief(`servidor não consultado (${res.error}); pasta na versão ${config.baseVersion}.`);
         console.log(`\nServidor não consultado: ${res.error}`);
         if (res.expired || res.status === 401)
             console.log("Para entrar de novo: omnispace login");
@@ -101,13 +118,32 @@ export async function statusSpace(root) {
         return 1;
     }
     const head = res.head;
-    const headMap = new Map(res.files.map((f) => [f.path, f.hash]));
-    const baseMap = res.base ? new Map(res.base.map((f) => [f.path, f.hash])) : headMap;
+    // Same filter as the pull: a path the policy keeps out is not a pending change on either side.
+    const headMap = remoteMap(res.files);
+    const baseMap = res.base ? remoteMap(res.base) : headMap;
     const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
     // An unreadable file is missing from the manifest; left in, it would show up as deleted here.
     const skip = (path) => manifest.unreadable.some((u) => path === u || path.startsWith(`${u}/`));
     const readable = (map) => new Map([...map].filter(([path]) => !skip(path)));
     const summary = summarizeStatus(local, readable(baseMap), readable(headMap));
+    const steps = nextSteps({
+        head,
+        baseVersion: config.baseVersion,
+        summary,
+        markers,
+        pullInterrupted: journal !== null,
+    });
+    if (opts.resumo) {
+        const parts = [`${res.name}: pasta na versão ${config.baseVersion}, servidor na ${head}`];
+        if (summary.local.length > 0)
+            parts.push(`${summary.local.length} mudança(s) local(is) não enviada(s)`);
+        if (markers.length > 0)
+            parts.push(`${markers.length} arquivo(s) com marcador de conflito`);
+        if (journal)
+            parts.push("pull interrompido");
+        parts.push(steps.length === 0 ? "em dia" : `próximo: ${steps.map((s) => s.replace(/\s+\(.*\)$/, "")).join(", depois ")}`);
+        return brief(`${parts.join("; ")}.`);
+    }
     console.log(`\nEspaço: ${res.name} (${res.slug})`);
     console.log(`Nesta pasta: ${config.baseVersion === 0 ? "nenhuma versão ainda" : `versão ${config.baseVersion}`}`);
     if (head === 0) {
@@ -138,13 +174,6 @@ export async function statusSpace(root) {
     if (manifest.unreadable.length > 0) {
         console.log(`\n${manifest.unreadable.length} arquivo(s) não puderam ser lidos (abertos em outro programa?); a comparação ignora esses.`);
     }
-    const steps = nextSteps({
-        head,
-        baseVersion: config.baseVersion,
-        summary,
-        markers,
-        pullInterrupted: journal !== null,
-    });
     if (journal)
         console.log(`\nUm pull da versão ${journal.head} parou no meio.`);
     if (steps.length === 0) {

package/dist/vincular.js

@@ -0,0 +1,107 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { defaultApiUrl, loadCredential, readSpaceConfig, writeSpaceConfig } from "./config.js";
+import { whoami } from "./login.js";
+import { pullSpace } from "./pull.js";
+import { pushSpace } from "./sync.js";
+/**
+ * `omnispace vincular [pasta] [--espaco <slug>]` (P1, Lucas 2026-09-27): links a folder that
+ * already has the files to a space of the account. The way back after `desvincular` or
+ * "Remover máquina", and the step after "Criar espaço" on the web. The folder starts at version 0,
+ * so the first pull compares file by file: equal files stay as they are, files only here stay to be
+ * pushed, files only on the server come down, and different ones ask (manter local, mesclar, backup).
+ */
+export async function linkExistingSpace(target, opts, ask) {
+    const root = resolve(target);
+    if (root.toLowerCase() === resolve(homedir()).toLowerCase()) {
+        console.error(`Essa é a pasta do seu usuário (${root}), não a de um projeto.`);
+        return 1;
+    }
+    const existing = await readSpaceConfig(root);
+    if (existing?.spaceId) {
+        console.error("Esta pasta já está ligada a um espaço. Para ver o estado: omnispace status");
+        return 1;
+    }
+    if (existing?.sessionId) {
+        console.error("Esta pasta está no meio da criação pelo navegador. Termine lá antes.");
+        return 1;
+    }
+    const who = await whoami();
+    if (!who.ok || !who.me.hasAccount) {
+        console.error(who.ok ? "Esta máquina ainda não está numa conta." : who.error);
+        console.error("Para entrar: omnispace login");
+        return 1;
+    }
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    if (!credential) {
+        console.error("Sem sessão da CLI. Rode omnispace login.");
+        return 1;
+    }
+    const list = await callApi(apiUrl, credential.token, "/api/cli/spaces/list", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!list.ok) {
+        console.error(`Falha ao listar os espaços: ${list.error}`);
+        return 1;
+    }
+    const spaces = list.spaces;
+    if (spaces.length === 0) {
+        console.error("A conta ainda não tem espaço. Para criar um a partir desta pasta: omnispace init");
+        return 1;
+    }
+    let chosen;
+    if (opts.espaco) {
+        chosen = spaces.find((s) => s.slug === opts.espaco || s.name === opts.espaco);
+        if (!chosen) {
+            console.error(`Nenhum espaço "${opts.espaco}" na conta. Os que existem: ${spaces.map((s) => s.slug).join(", ")}`);
+            return 1;
+        }
+    }
+    else {
+        if (!ask) {
+            console.error(`Sem terminal para escolher. Use --espaco <nome>: ${spaces.map((s) => s.slug).join(", ")}`);
+            return 1;
+        }
+        console.log("\nEspaços da sua conta:");
+        spaces.forEach((s, i) => {
+            const version = s.head === 0 ? "sem versão ainda" : `versão ${s.head}`;
+            console.log(`  ${i + 1}. ${s.name} (${s.slug}) · ${version}${s.installedHere ? " · já ligado a outra pasta desta máquina" : ""}`);
+        });
+        const answer = await ask("\nNúmero do espaço desta pasta: ");
+        chosen = spaces[Number(answer) - 1];
+        if (!chosen) {
+            console.log("Nenhum espaço escolhido. Nada foi alterado.");
+            return 1;
+        }
+    }
+    if (chosen.installedHere) {
+        console.log(`\nAtenção: ${chosen.name} já está ligado a outra pasta desta máquina. A ligação passa para esta.`);
+    }
+    if (!opts.yes) {
+        if (!ask) {
+            console.error("Sem terminal para confirmar. Rode de novo com --yes.");
+            return 1;
+        }
+        const ok = (await ask(`Ligar ${root} ao espaço ${chosen.name}? (s/n) `)).toLowerCase();
+        if (ok !== "s" && ok !== "sim") {
+            console.log("Nada foi alterado.");
+            return 1;
+        }
+    }
+    // Not retried: a second call would just link again, but a cut connection is better reported.
+    const attached = await callApi(apiUrl, credential.token, "/api/cli/spaces/attach", { spaceId: chosen.spaceId, localPath: root });
+    if (!attached.ok) {
+        console.error(`Falha ao ligar a pasta: ${attached.error}`);
+        return 1;
+    }
+    await writeSpaceConfig(root, { apiUrl, machineId: credential.machineId, spaceId: chosen.spaceId, baseVersion: 0 });
+    console.log(`✓ Pasta ligada ao espaço ${chosen.name}.`);
+    const head = attached.head;
+    if (head === 0) {
+        console.log("O espaço ainda não tem versão. Publicando o conteúdo desta pasta como a primeira:");
+        return pushSpace(root, { yes: Boolean(opts.yes) });
+    }
+    console.log(`\nComparando esta pasta com a versão ${head}: arquivos iguais ficam, os diferentes perguntam o que fazer.`);
+    return pullSpace(root, {});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.7.0",
+  "version": "0.11.0",
   "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
   "type": "module",
   "bin": {