omnispace 0.7.0 → 0.9.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,12 +72,24 @@ 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.
+- 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).
 - Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado.
 - 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.

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/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,6 +14,8 @@ 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";
+import { terminalAsk, unlinkMachine } from "./desvincular.js";
+import { linkExistingSpace } from "./vincular.js";
 const USAGE = `
 Omni CLI
 
@@ -24,11 +26,13 @@ Uso:
   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 status [pasta] [--resumo]    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
+  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)
 
 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.
@@ -55,8 +59,19 @@ 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 === "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 !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());

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.9.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": {