omnispace 0.6.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`, `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.
 
@@ -34,6 +34,18 @@ Só ler a pasta, sem vincular nem enviar nada:
 npx -y omnispace@latest init . --scan-only
 ```
 
+Ver o que mudou nesta pasta e no servidor, e qual o próximo comando (só lê, não altera nada):
+
+```
+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:
 
 ```
@@ -60,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/conflicts.js

@@ -27,8 +27,11 @@ export async function addConflicts(root, paths) {
     if (paths.length > 0)
         await writeList(root, [...(await readList(root)), ...paths]);
 }
-/** Paths still holding markers. Resolved (or deleted) files leave the list as a side effect. */
-export async function unresolvedConflicts(root) {
+/**
+ * Paths still holding markers. Resolved (or deleted) files leave the list as a side effect,
+ * unless `readOnly` (omnispace status never writes to the folder).
+ */
+export async function unresolvedConflicts(root, opts = {}) {
     const list = await readList(root);
     const pending = [];
     for (const path of list) {
@@ -40,7 +43,7 @@ export async function unresolvedConflicts(root) {
             // file gone: nothing left to resolve
         }
     }
-    if (pending.length !== list.length)
+    if (!opts.readOnly && pending.length !== list.length)
         await writeList(root, pending);
     return pending;
 }

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

@@ -13,6 +13,9 @@ import { LockedError } from "./lock.js";
 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
 
@@ -23,13 +26,16 @@ 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] [--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 ainda não reorganiza a sua pasta. O que fazer com o que foi varrido
-é decidido na tela de revisão, 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);
@@ -53,6 +59,19 @@ async function main(argv) {
         return runSync(args.slice(1));
     if (command === "clone")
         return runClone(args.slice(1));
+    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

@@ -0,0 +1,188 @@
+import { basename } from "node:path";
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { buildManifest } from "./include.js";
+import { unresolvedConflicts } from "./conflicts.js";
+import { readJournal } from "./journal.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).
+ * A path equal on both sides (same edit made twice) counts as nothing to do.
+ */
+export function summarizeStatus(local, base, head) {
+    const plan = planPull(local, base, head);
+    const kind = (path) => !base.has(path) ? "nova" : !local.has(path) ? "apagada" : "editada";
+    return {
+        local: [...plan.localOnly, ...plan.conflicts].sort().map((path) => ({ path, kind: kind(path) })),
+        remote: plan.writes.length + plan.deletes.length + plan.conflicts.length,
+        both: plan.conflicts,
+    };
+}
+/** The commands to run next, in order. Empty when the folder and the server agree. */
+export function nextSteps(opts) {
+    const { head, baseVersion, summary, markers, pullInterrupted } = opts;
+    if (pullInterrupted)
+        return ["omnispace sync --pull   (termina o pull que parou no meio)"];
+    if (markers.length > 0) {
+        return ["resolva os marcadores de conflito nos arquivos acima", "omnispace sync --push"];
+    }
+    const steps = [];
+    if (head > baseVersion) {
+        steps.push(summary.both.length > 0
+            ? `omnispace sync --pull   (vai pedir decisão em ${summary.both.length} arquivo(s) mudado(s) dos dois lados)`
+            : "omnispace sync --pull");
+    }
+    if (summary.local.length > 0)
+        steps.push("omnispace sync --push");
+    return steps;
+}
+export function timeAgo(iso, now = Date.now()) {
+    const minutes = Math.round((now - new Date(iso).getTime()) / 60000);
+    if (minutes < 1)
+        return "agora";
+    if (minutes < 60)
+        return `há ${minutes} min`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `há ${hours} h`;
+    return `há ${Math.round(hours / 24)} d`;
+}
+const KIND_MARK = { nova: "+", editada: "~", apagada: "-" };
+function listChanges(changes, max = 20) {
+    for (const change of changes.slice(0, max))
+        console.log(`    ${KIND_MARK[change.kind]} ${change.path}`);
+    if (changes.length > max)
+        console.log(`    ... e mais ${changes.length - max}`);
+}
+function countKinds(changes) {
+    const parts = ["editada", "nova", "apagada"]
+        .map((k) => [k, changes.filter((c) => c.kind === k).length])
+        .filter(([, n]) => n > 0)
+        .map(([k, n]) => `${n} ${n === 1 ? k : `${k}s`}`);
+    return parts.join(", ");
+}
+/**
+ * `omnispace status` (P1, docs/plan/p1-continuidade-visivel.md): what this folder has that the
+ * 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, 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 })]);
+    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");
+        console.log(`Esta pasta está na versão ${config.baseVersion}. Sem o servidor não dá para dizer o que mudou.\n`);
+        return 1;
+    }
+    const head = res.head;
+    // 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) {
+        console.log("No servidor: nenhuma versão publicada ainda");
+    }
+    else {
+        const when = res.publishedAt ? `, publicada ${timeAgo(res.publishedAt)}` : "";
+        const who = res.publishedBy ? ` por ${res.publishedBy}` : "";
+        console.log(`No servidor: versão ${head}${when}${who}`);
+    }
+    if (summary.local.length > 0) {
+        console.log(`\nMudanças nesta pasta ainda não enviadas: ${summary.local.length} (${countKinds(summary.local)})`);
+        listChanges(summary.local);
+    }
+    if (head > config.baseVersion) {
+        console.log(`\nNo servidor há ${summary.remote} arquivo(s) diferente(s) da versão desta pasta.`);
+    }
+    if (summary.both.length > 0) {
+        console.log(`\nMudados dos dois lados (o pull pergunta o que fazer):`);
+        for (const path of summary.both.slice(0, 20))
+            console.log(`    ${path}`);
+    }
+    if (markers.length > 0) {
+        console.log("\nAinda com marcadores de conflito (<<<<<<< esta máquina), o push recusa até serem editados:");
+        for (const path of markers)
+            console.log(`    ${path}`);
+    }
+    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.`);
+    }
+    if (journal)
+        console.log(`\nUm pull da versão ${journal.head} parou no meio.`);
+    if (steps.length === 0) {
+        console.log(head === 0 ? "\n✓ Pasta vazia e nada publicado ainda.\n" : `\n✓ Em dia com a versão ${head}.\n`);
+    }
+    else {
+        console.log("\nPróximo passo:");
+        steps.forEach((step, i) => console.log(`  ${i + 1}. ${step}`));
+        console.log("");
+    }
+    return 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.6.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": {