omnispace 0.5.2 → 0.7.0

package/README.md

@@ -2,13 +2,27 @@
 
 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 `init`, `sync --push`, `sync --pull` e `clone`.
+> Alpha. Existem `login`, `logout`, `whoami`, `init`, `status`, `sync --push`, `sync --pull` e `clone`.
 
 Precisa do Node 20 ou mais novo.
 
 ## Uso
 
-Comece pelo site: ele mostra o código de vínculo. Depois, dentro da pasta do espaço:
+Já tem conta no Omni? Entre pelo navegador (a CLI mostra um link e um código; a senha nunca passa pelo terminal):
+
+```
+npx -y omnispace@latest login
+```
+
+A sessão vale 14 dias sem uso, e cada uso renova. `whoami` mostra a conta e até quando a sessão vale; `logout` encerra a sessão e apaga o token desta máquina.
+
+Com a CLI logada, dentro da pasta, o `init` cria o espaço direto na sua conta (só pergunta o nome, que por padrão é o da pasta) e já oferece o primeiro envio:
+
+```
+npx -y omnispace@latest init .
+```
+
+Primeira vez no Omni? Comece pelo site: ele mostra o código de vínculo. Depois, dentro da pasta do espaço:
 
 ```
 npx -y omnispace@latest init . --link <código>
@@ -20,6 +34,12 @@ 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
+```
+
 Publicar uma nova versão do espaço no servidor:
 
 ```
@@ -54,4 +74,5 @@ No Windows, se o caminho tiver espaço ou apóstrofo, entre na pasta com aspas d
 - 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.
 - 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.
+- 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).

package/dist/config.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
 // Two places, on purpose:
@@ -10,6 +10,25 @@ const DEFAULT_API_URL = "https://omni.tzolkin.cloud";
 export function defaultApiUrl() {
     return process.env.OMNI_API_URL?.replace(/\/$/, "") || DEFAULT_API_URL;
 }
+/**
+ * Barrier 1 of pos-marco-conectores.md: tokens (and, later, credentials) only travel over HTTPS.
+ * Plain http is accepted only for a server on this machine (development). Returns the problem, or null.
+ */
+export function insecureApiUrl(url = defaultApiUrl()) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `OMNI_API_URL não é um endereço válido: ${url}`;
+    }
+    if (parsed.protocol === "https:")
+        return null;
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname) || parsed.hostname.endsWith(".localhost");
+    if (parsed.protocol === "http:" && local)
+        return null;
+    return `OMNI_API_URL precisa usar https (recebido ${parsed.protocol}//${parsed.host}). http só vale para um servidor nesta máquina.`;
+}
 // OMNI_HOME and OMNI_MACHINE_NAME exist to simulate two machines on one PC (fatia 3): each gets
 // its own credentials and its own row in `machines` (unique per account and hostname).
 export function machineHostname() {
@@ -29,18 +48,37 @@ async function readJson(path) {
         return null;
     }
 }
-async function writeJson(path, value) {
+/**
+ * Written to a temporary file next to the target and renamed over it: a kill in the middle never
+ * leaves a half-written credentials.json or space.json. `mode` 0o600 keeps the token readable only
+ * by the user (ignored on Windows, where the home folder is already private).
+ */
+async function writeJson(path, value, mode) {
     await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode });
+    await rename(tmp, path);
 }
-export async function saveToken(apiUrl, token, machineId) {
+export async function saveToken(apiUrl, token, machineId, email) {
     const all = (await readJson(credentialsPath())) ?? {};
-    all[apiUrl] = { token, machineId };
-    await writeJson(credentialsPath(), all);
+    all[apiUrl] = email ? { token, machineId, email } : { token, machineId };
+    await writeJson(credentialsPath(), all, 0o600);
+}
+export async function loadCredential(apiUrl) {
+    const all = await readJson(credentialsPath());
+    return all?.[apiUrl] ?? null;
 }
 export async function loadToken(apiUrl) {
+    return (await loadCredential(apiUrl))?.token ?? null;
+}
+/** `omnispace logout`: forgets this server's token (the other servers' entries stay). */
+export async function removeToken(apiUrl) {
     const all = await readJson(credentialsPath());
-    return all?.[apiUrl]?.token ?? null;
+    if (!all?.[apiUrl])
+        return false;
+    delete all[apiUrl];
+    await writeJson(credentialsPath(), all, 0o600);
+    return true;
 }
 export function readSpaceConfig(root) {
     return readJson(spaceConfigPath(root));

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/index.js

@@ -10,20 +10,28 @@ import { cloneSpace, CONFLICT_CHOICES, pullSpace } from "./pull.js";
 import { buildManifest } from "./include.js";
 import { printSyncPreview } from "./report.js";
 import { LockedError } from "./lock.js";
-import { defaultApiUrl } from "./config.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";
 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 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);
@@ -32,10 +40,23 @@ async function main(argv) {
         console.log(USAGE.trim());
         return 0;
     }
+    const insecure = insecureApiUrl();
+    if (insecure) {
+        console.error(insecure);
+        return 1;
+    }
+    if (command === "login")
+        return login({ openBrowser: !args.includes("--sem-navegador") && process.stdout.isTTY });
+    if (command === "logout")
+        return logout();
+    if (command === "whoami")
+        return printWhoami();
     if (command === "sync")
         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 !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());
@@ -44,18 +65,31 @@ async function main(argv) {
     const rest = args.slice(1);
     const linkIndex = rest.indexOf("--link");
     const linkCode = linkIndex >= 0 ? rest[linkIndex + 1] : undefined;
-    const positional = rest.filter((a, i) => !a.startsWith("-") && (linkIndex < 0 || i !== linkIndex + 1));
+    const nameIndex = rest.indexOf("--nome");
+    const nameArg = rest.find((a) => a.startsWith("--nome="))?.slice("--nome=".length) ?? (nameIndex >= 0 ? rest[nameIndex + 1] : undefined);
+    const positional = rest.filter((a, i) => !a.startsWith("-") && (linkIndex < 0 || i !== linkIndex + 1) && (nameIndex < 0 || i !== nameIndex + 1));
     const hasScanOnly = rest.includes("--scan-only");
     const target = resolve(positional[0] ?? process.cwd());
-    // Writing to disk is not implemented yet (Etapa técnica 1 segue em aberto), so a run that
-    // asked for neither mode must stop instead of pretending the full flow happened. A bare
-    // `npx omnispace init` is exactly what the LP shows, so it points to where the flow starts.
-    if (!hasScanOnly && !linkCode) {
-        const site = defaultApiUrl();
-        console.log(`
+    // Neither mode asked: with the CLI logged in to an account, the space is created straight there
+    // (fatia 1b). Without it, a bare `npx omnispace init` (what the LP shows) points to the funnel.
+    const accountMode = !hasScanOnly && !linkCode;
+    let me = null;
+    if (accountMode) {
+        const who = await whoami();
+        if (who.ok && who.me.hasAccount) {
+            me = who.me;
+        }
+        else {
+            if (!who.ok && !who.noToken)
+                console.error(`\n${who.error}`);
+            const site = defaultApiUrl();
+            console.log(`
 Omni CLI
 
-Para ligar uma pasta ao Omni, comece pelo navegador:
+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:
@@ -64,7 +98,8 @@ Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, ro
 Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
   npx -y omnispace@latest init . --scan-only
 `);
-        return 0;
+            return who.ok || who.noToken ? 0 : 1;
+        }
     }
     try {
         const info = await stat(target);
@@ -79,11 +114,13 @@ Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
     }
     // Linking the user's whole home folder happened for real on 2026-09-23 (a missing cd); a space
     // is a work folder inside it, never the home itself.
-    if (linkCode && resolve(target).toLowerCase() === resolve(homedir()).toLowerCase()) {
+    if ((linkCode || me) && resolve(target).toLowerCase() === resolve(homedir()).toLowerCase()) {
         console.error(`Essa é a pasta do seu usuário (${target}), não a de um projeto.`);
         console.error('Entre na pasta do espaço primeiro, com o caminho entre aspas duplas: cd "<caminho da pasta>"');
         return 1;
     }
+    if (me)
+        return initWithAccount(target, me, { name: nameArg, yes: rest.includes("--yes") });
     const scan = await scanFolder(target);
     printScanReport(scan, { linking: Boolean(linkCode) });
     if (linkCode && scan.truncated) {

package/dist/init-account.js

@@ -0,0 +1,83 @@
+import { basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callApi } from "./api.js";
+import { defaultApiUrl, loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
+import { printScanReport } from "./report.js";
+import { scanFolder } from "./scan.js";
+import { pushSpace } from "./sync.js";
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `omnispace init` with the CLI logged in (pós-marco, fatia 1b; decision of Lucas, 2026-09-25):
+ * the space is created straight in the account, no web funnel. Only the name is asked (the folder
+ * name is the default); icon, type and categories keep their defaults and are edited on the web.
+ * Writes only .omni/space.json in the folder, then offers the first push.
+ */
+export async function initWithAccount(root, me, opts) {
+    const existing = await readSpaceConfig(root);
+    if (existing?.spaceId) {
+        console.error("Esta pasta já é um espaço Omni. Para enviar mudanças: omnispace sync . --push");
+        return 1;
+    }
+    if (existing?.sessionId) {
+        console.error("Esta pasta está no meio da criação pelo navegador. Termine lá, ou apague .omni/space.json para começar de novo.");
+        return 1;
+    }
+    const scan = await scanFolder(root);
+    printScanReport(scan, { linking: true });
+    if (scan.truncated) {
+        console.error("A leitura parou antes do fim, então o espaço não foi criado. Aponte a pasta do espaço, não uma pasta acima dela.");
+        return 1;
+    }
+    const suggested = basename(root) || "Meu espaço";
+    let name = opts.name?.trim();
+    if (!name) {
+        if (opts.yes || !process.stdin.isTTY) {
+            name = suggested;
+        }
+        else {
+            name = (await ask(`Nome do espaço [${suggested}]: `)) || suggested;
+        }
+    }
+    if (name.length > 80) {
+        console.error("O nome do espaço pode ter até 80 caracteres.");
+        return 1;
+    }
+    if (!opts.yes) {
+        if (!process.stdin.isTTY) {
+            console.error('Sem terminal para confirmar. Rode de novo com --yes (e --nome "<nome>" se quiser outro nome).');
+            return 1;
+        }
+        const answer = (await ask(`Criar o espaço "${name}" na conta ${me.email ?? ""} e ligar esta pasta a ele? (s/n) `)).toLowerCase();
+        if (answer !== "s" && answer !== "sim") {
+            console.log("Nada foi criado.");
+            return 1;
+        }
+    }
+    const apiUrl = defaultApiUrl();
+    const token = await loadToken(apiUrl);
+    if (!token) {
+        console.error("A sessão da CLI sumiu no meio do caminho. Rode omnispace login.");
+        return 1;
+    }
+    // Not retried: creating a space twice would leave a duplicate in the account.
+    const created = await callApi(apiUrl, token, "/api/cli/spaces", { name, localPath: root, detectedStacks: scan.stacks });
+    if (!created.ok) {
+        console.error(`Falha ao criar o espaço: ${created.error}`);
+        return 1;
+    }
+    await writeSpaceConfig(root, { apiUrl, machineId: me.machineId, spaceId: created.spaceId, baseVersion: 0 });
+    console.log(`✓ Espaço "${created.name}" criado na sua conta. Vínculo gravado em .omni/space.json.`);
+    if (scan.stacks.length > 0) {
+        console.log(`  ${scan.stacks.length} conector(es) preparado(s), desligado(s) até você ligar as credenciais.`);
+    }
+    console.log("\n→ Primeiro envio desta pasta para o espaço:");
+    return pushSpace(root, { yes: opts.yes });
+}

package/dist/login.js

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { callApi } from "./api.js";
+import { defaultApiUrl, loadCredential, machineHostname, removeToken, saveToken } from "./config.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+// `omnispace login`, `logout` e `whoami` (pós-marco, fatia 1b; docs/plan/pos-marco-conectores.md).
+// Login pelo código no navegador: a senha nunca passa pelo terminal. A sessão vale 14 dias contados
+// do último uso; parada mais que isso, o servidor recusa e pede login de novo.
+/**
+ * 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) {
+    if (!/^https?:\/\//.test(url))
+        return;
+    const os = platform();
+    const [cmd, args] = os === "win32"
+        ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
+        : os === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // No browser here (server, container): the printed URL is enough.
+    }
+}
+export async function login(opts = {}) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const apiUrl = defaultApiUrl();
+    const previous = await loadCredential(apiUrl);
+    const start = await callApi(apiUrl, null, "/api/cli/login/start", { hostname: machineHostname(), os: platform(), machineId: previous?.machineId }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!start.ok) {
+        console.error(`Falha ao começar o login: ${start.error}`);
+        return 1;
+    }
+    const deviceCode = start.deviceCode;
+    const userCode = start.userCode;
+    const verifyUrl = start.verifyUrl;
+    const expiresAt = Date.now() + start.expiresIn * 1000;
+    const waitMs = opts.pollMs ?? start.interval * 1000;
+    log("");
+    log("Para entrar, abra no navegador:");
+    log(`  ${verifyUrl}`);
+    log("e digite este código:");
+    log(`  ${userCode}`);
+    log("");
+    if (opts.openBrowser)
+        openBrowser(verifyUrl);
+    log("→ Esperando a autorização no navegador (Ctrl+C cancela)...");
+    while (Date.now() < expiresAt) {
+        await new Promise((r) => setTimeout(r, waitMs));
+        const poll = await callApi(apiUrl, null, "/api/cli/login/poll", { deviceCode }, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (poll.ok && poll.state === "pending")
+            continue;
+        if (!poll.ok) {
+            console.error(poll.denied ? "Login recusado no navegador. Nada foi liberado." : `Falha no login: ${poll.error}`);
+            return 1;
+        }
+        await saveToken(apiUrl, poll.token, poll.machineId, poll.email ?? undefined);
+        log(`✓ Entrou como ${poll.email ?? "sua conta"}.`);
+        log("  A sessão vale 14 dias sem uso, e cada uso renova. Para sair: omnispace logout\n");
+        return 0;
+    }
+    console.error("O código expirou antes da autorização. Rode omnispace login de novo.");
+    return 1;
+}
+export async function logout() {
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    if (!credential) {
+        console.log("Nenhuma sessão da CLI nesta máquina.");
+        return 0;
+    }
+    // Revoked on the server first; the local copy goes either way (an expired or revoked token is
+    // useless anyway, and keeping it would only confuse the next command).
+    const res = await callApi(apiUrl, credential.token, "/api/cli/logout", {});
+    await removeToken(apiUrl);
+    if (res.ok)
+        console.log("✓ Sessão encerrada: o token foi revogado no servidor e apagado desta máquina.");
+    else
+        console.log(`✓ Token apagado desta máquina. (O servidor respondeu: ${res.error})`);
+    return 0;
+}
+/** The account behind this machine's token, or the server's refusal (expired, revoked, none). */
+export async function whoami() {
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    if (!credential)
+        return { ok: false, error: "Nenhuma sessão da CLI nesta máquina.", noToken: true };
+    const res = await callApi(apiUrl, credential.token, "/api/cli/whoami", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok)
+        return { ok: false, error: res.error ?? "falha", expired: Boolean(res.expired) };
+    return { ok: true, me: res };
+}
+export async function printWhoami() {
+    const result = await whoami();
+    if (!result.ok) {
+        console.log(result.error);
+        if (result.noToken || result.expired)
+            console.log("Para entrar: npx -y omnispace@latest login");
+        return 1;
+    }
+    const { me } = result;
+    const until = new Date(me.expiresAt).toLocaleDateString("pt-BR");
+    console.log(me.hasAccount ? `Conta: ${me.email ?? "(sem email)"}` : "Máquina vinculada pelo navegador, conta ainda não criada.");
+    console.log(`Máquina: ${me.machineName ?? me.machineId}`);
+    console.log(`Sessão: vale até ${until} se ficar sem uso (cada uso renova).`);
+    return 0;
+}

package/dist/status.js

@@ -0,0 +1,159 @@
+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 } 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) {
+    const config = await readSpaceConfig(root);
+    if (!config) {
+        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) {
+        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) {
+        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...");
+    const manifest = await buildManifest(root);
+    if (manifest.truncated) {
+        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) {
+        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;
+    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;
+    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));
+    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.`);
+    }
+    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) {
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.5.2",
+  "version": "0.7.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": {