omnispace 0.2.1 → 0.3.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 `init`, `sync --push`, `sync --pull` e `clone`. Quando a mesma parte de um arquivo muda nas duas máquinas, o `sync --pull` para sem mexer na pasta; juntar as duas versões automaticamente vem numa próxima versão.
+> Alpha. Existem `init`, `sync --push`, `sync --pull` e `clone`.
 
 Precisa do Node 20 ou mais novo.
 
@@ -32,6 +32,14 @@ Trazer para a pasta a versão mais nova do servidor:
 npx -y omnispace@latest sync . --pull
 ```
 
+Se o mesmo arquivo mudou aqui e na outra máquina, o Omni junta sozinho quando as mudanças estão em trechos diferentes. Quando o mesmo trecho mudou dos dois lados, ele pergunta, arquivo por arquivo:
+
+- **manter local**: fica a versão desta máquina, que sobe no próximo envio;
+- **mesclar**: o arquivo é gravado com as duas versões entre marcadores `<<<<<<<` e `>>>>>>>` para você editar; o envio fica bloqueado até os marcadores sumirem;
+- **backup**: entra a versão do servidor e a desta máquina fica guardada em `.omni/backups/`.
+
+Fora de um terminal interativo, escolha para todos com `--conflito=local`, `--conflito=mesclar` ou `--conflito=backup`.
+
 Baixar um espaço da sua conta em outra máquina (o código aparece no site, em "Baixar em outra máquina"; a pasta é criada):
 
 ```
@@ -46,4 +54,4 @@ 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 `.omni/tmp/` durante um download, apagada no fim). O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto.
+- Na pasta, o Omni grava só `.omni/space.json` (e `.omni/tmp/` durante um download, apagada no fim; `.omni/backups/` e `.omni/conflicts.json` quando há conflito). Nada disso sincroniza. O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto.

package/dist/conflicts.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { hasConflictMarkers } from "./merge.js";
+// Files a pull left with conflict markers (option "mesclar"), so push can refuse to publish them
+// until they are edited. Machine specific, never synced (include.ts, LOCAL_ONLY).
+function conflictsPath(root) {
+    return join(root, ".omni", "conflicts.json");
+}
+async function readList(root) {
+    try {
+        const list = JSON.parse(await readFile(conflictsPath(root), "utf8"));
+        return Array.isArray(list) ? list.filter((p) => typeof p === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function writeList(root, list) {
+    if (list.length === 0) {
+        await rm(conflictsPath(root), { force: true });
+        return;
+    }
+    await mkdir(join(root, ".omni"), { recursive: true });
+    await writeFile(conflictsPath(root), `${JSON.stringify([...new Set(list)].sort(), null, 2)}\n`, "utf8");
+}
+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) {
+    const list = await readList(root);
+    const pending = [];
+    for (const path of list) {
+        try {
+            if (hasConflictMarkers(await readFile(join(root, ...path.split("/")), "utf8")))
+                pending.push(path);
+        }
+        catch {
+            // file gone: nothing left to resolve
+        }
+    }
+    if (pending.length !== list.length)
+        await writeList(root, pending);
+    return pending;
+}

package/dist/include.js

@@ -10,11 +10,13 @@ export const SKIP_DIRS = new Set([
     ".turbo", ".cache", "venv", ".venv", "__pycache__", ".idea", ".vscode", "target",
 ]);
 // Local state of the Omni link itself: machine specific, never part of the space. `.omni/tmp/`
-// holds downloads of an unfinished pull (fatia 3).
-const LOCAL_ONLY = new Set([".omni/space.json"]);
+// holds downloads of an unfinished pull (fatia 3); `.omni/conflicts.json` and `.omni/backups/`
+// are the conflict resolution of this machine (fatia 4).
+const LOCAL_ONLY = new Set([".omni/space.json", ".omni/conflicts.json"]);
 export const LOCAL_TMP_DIR = ".omni/tmp";
+export const LOCAL_BACKUPS_DIR = ".omni/backups";
 function isLocalOnly(path) {
-    return LOCAL_ONLY.has(path) || path.startsWith(`${LOCAL_TMP_DIR}/`);
+    return LOCAL_ONLY.has(path) || path.startsWith(`${LOCAL_TMP_DIR}/`) || path.startsWith(`${LOCAL_BACKUPS_DIR}/`);
 }
 const TEXT_EXTENSIONS = new Set([
     ".md", ".mdx", ".txt", ".csv", ".tsv", ".json", ".jsonc", ".yaml", ".yml", ".toml", ".xml",

package/dist/index.js

@@ -6,7 +6,7 @@ import { scanFolder } from "./scan.js";
 import { printScanReport } from "./report.js";
 import { linkAndSubmit } from "./link.js";
 import { pushSpace } from "./sync.js";
-import { cloneSpace, pullSpace } from "./pull.js";
+import { cloneSpace, CONFLICT_CHOICES, pullSpace } from "./pull.js";
 import { buildManifest } from "./include.js";
 import { printSyncPreview } from "./report.js";
 const USAGE = `
@@ -17,10 +17,11 @@ Uso:
   omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
   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
 
-Gravar a estrutura padrão na pasta entra num próximo passo da Etapa técnica 1 —
-por enquanto quem decide o que fazer com o que foi varrido é a tela de revisão.
+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.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -90,8 +91,18 @@ async function runSync(rest) {
         console.error("Use omni sync --push (enviar) ou omni sync --pull (baixar).");
         return 1;
     }
+    let conflito;
+    const conflictArg = rest.find((a) => a.startsWith("--conflito"));
+    if (conflictArg) {
+        const value = conflictArg.slice("--conflito=".length);
+        if (!conflictArg.startsWith("--conflito=") || !CONFLICT_CHOICES.includes(value)) {
+            console.error("Use --conflito=local, --conflito=mesclar ou --conflito=backup.");
+            return 1;
+        }
+        conflito = value;
+    }
     const target = resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd());
-    return push ? pushSpace(target, { yes: rest.includes("--yes") }) : pullSpace(target);
+    return push ? pushSpace(target, { yes: rest.includes("--yes") }) : pullSpace(target, { conflito });
 }
 async function runClone(rest) {
     const [code, folder] = rest.filter((a) => !a.startsWith("-"));

package/dist/link.js

@@ -64,5 +64,5 @@ export async function linkAndSubmit(code, root, scan) {
         process.exitCode = 1;
         return;
     }
-    console.log("✓ Enviado. Volte pro navegador — a próxima tela é a de revisão.\n");
+    console.log("✓ Enviado. Volte pro navegador: a próxima tela é a de revisão.\n");
 }

package/dist/merge.js

@@ -0,0 +1,144 @@
+// Three-way merge of text files (Proof of Core Sync, fatia 4; ADR 002). Line based, the same idea
+// as diff3: each side is compared with the base, regions only one side touched are taken from
+// that side, and regions both sides touched differently become a conflict. No dependency on
+// purpose (ADR 005: the CLI brings nothing into the person's project).
+export const MARK_LOCAL = "<<<<<<< esta máquina";
+export const MARK_SEP = "=======";
+export const MARK_REMOTE_PREFIX = ">>>>>>> servidor";
+export function markRemote(version) {
+    return `${MARK_REMOTE_PREFIX} (versão ${version})`;
+}
+/** True when the text still has a conflict block written by `mesclar`. */
+export function hasConflictMarkers(text) {
+    const plain = text.replace(/\r/g, "");
+    return /^<<<<<<< esta máquina$/m.test(plain) || /^>>>>>>> servidor/m.test(plain);
+}
+/**
+ * Lines without their endings, so a file saved with CRLF on one machine and LF on the other
+ * still lines up. The endings come back on output (local style wins).
+ */
+export function splitLines(text) {
+    const crlf = (text.match(/\r\n/g) ?? []).length;
+    const lf = (text.match(/\n/g) ?? []).length - crlf;
+    const eol = crlf > lf ? "\r\n" : "\n";
+    if (text === "")
+        return { lines: [], eol, finalNewline: false };
+    const lines = text.split(/\r?\n/);
+    const finalNewline = lines[lines.length - 1] === "";
+    if (finalNewline)
+        lines.pop();
+    return { lines, eol, finalNewline };
+}
+// Above this many cells the full LCS table is not built; only the common prefix and suffix are
+// matched, which is still a correct (just coarser) merge: more of the middle becomes one region.
+const MAX_LCS_CELLS = 4_000_000;
+/** base index → other index for the lines kept in common, strictly increasing on both sides. */
+export function matchLines(base, other) {
+    const matches = new Map();
+    let start = 0;
+    while (start < base.length && start < other.length && base[start] === other[start]) {
+        matches.set(start, start);
+        start++;
+    }
+    let endBase = base.length;
+    let endOther = other.length;
+    const suffix = [];
+    while (endBase > start && endOther > start && base[endBase - 1] === other[endOther - 1]) {
+        endBase--;
+        endOther--;
+        suffix.push([endBase, endOther]);
+    }
+    const n = endBase - start;
+    const m = endOther - start;
+    if (n > 0 && m > 0 && (n + 1) * (m + 1) <= MAX_LCS_CELLS) {
+        // lcs[i][j] = LCS length of base[start+i..endBase) and other[start+j..endOther). Uint16 is
+        // enough: with the cell cap, the shorter side has at most 2000 lines.
+        const width = m + 1;
+        const lcs = new Uint16Array((n + 1) * width);
+        for (let i = n - 1; i >= 0; i--) {
+            for (let j = m - 1; j >= 0; j--) {
+                lcs[i * width + j] =
+                    base[start + i] === other[start + j]
+                        ? lcs[(i + 1) * width + j + 1] + 1
+                        : Math.max(lcs[(i + 1) * width + j], lcs[i * width + j + 1]);
+            }
+        }
+        let i = 0;
+        let j = 0;
+        while (i < n && j < m) {
+            if (base[start + i] === other[start + j]) {
+                matches.set(start + i, start + j);
+                i++;
+                j++;
+            }
+            else if (lcs[(i + 1) * width + j] >= lcs[i * width + j + 1]) {
+                i++;
+            }
+            else {
+                j++;
+            }
+        }
+    }
+    for (const [b, o] of suffix)
+        matches.set(b, o);
+    return matches;
+}
+function sameLines(a, b) {
+    return a.length === b.length && a.every((line, i) => line === b[i]);
+}
+/**
+ * Merges `local` and `remote`, both descended from `base`. `conflicts` counts the regions both
+ * sides changed differently; those are written between markers, local first.
+ */
+export function mergeText(base, local, remote, remoteVersion) {
+    const b = splitLines(base);
+    const l = splitLines(local);
+    const r = splitLines(remote);
+    const toLocal = matchLines(b.lines, l.lines);
+    const toRemote = matchLines(b.lines, r.lines);
+    const out = [];
+    let conflicts = 0;
+    let i = 0;
+    let j = 0;
+    let k = 0;
+    for (;;) {
+        // Next base line both sides kept: the end of the current region.
+        let o = i;
+        while (o < b.lines.length && !(toLocal.has(o) && toRemote.has(o)))
+            o++;
+        const localEnd = o < b.lines.length ? toLocal.get(o) : l.lines.length;
+        const remoteEnd = o < b.lines.length ? toRemote.get(o) : r.lines.length;
+        if (o === i && localEnd === j && remoteEnd === k) {
+            if (o === b.lines.length)
+                break;
+            out.push(l.lines[j]);
+            i++;
+            j++;
+            k++;
+            continue;
+        }
+        const basePart = b.lines.slice(i, o);
+        const localPart = l.lines.slice(j, localEnd);
+        const remotePart = r.lines.slice(k, remoteEnd);
+        if (sameLines(localPart, basePart))
+            out.push(...remotePart);
+        else if (sameLines(remotePart, basePart) || sameLines(localPart, remotePart))
+            out.push(...localPart);
+        else {
+            conflicts++;
+            out.push(MARK_LOCAL, ...localPart, MARK_SEP, ...remotePart, markRemote(remoteVersion));
+        }
+        i = o;
+        j = localEnd;
+        k = remoteEnd;
+        if (o === b.lines.length)
+            break;
+    }
+    // Trailing newline: same three-way rule as the lines.
+    const finalNewline = l.finalNewline === r.finalNewline ? l.finalNewline : l.finalNewline === b.finalNewline ? r.finalNewline : l.finalNewline;
+    const eol = local === "" ? r.eol : l.eol;
+    // A file ending in a conflict block always gets a newline after the closing marker.
+    const endsInMarker = out[out.length - 1]?.startsWith(MARK_REMOTE_PREFIX) ?? false;
+    const text = out.length === 0 ? "" : out.join(eol) + (finalNewline || endsInMarker ? eol : "");
+    return { text, conflicts };
+}

package/dist/pull.js

@@ -1,9 +1,13 @@
 import { createHash } from "node:crypto";
-import { copyFile, mkdir, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
 import { homedir, platform } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { callApi } from "./api.js";
-import { buildManifest, hashFile, LOCAL_TMP_DIR } from "./include.js";
+import { buildManifest, hashFile, LOCAL_BACKUPS_DIR, LOCAL_TMP_DIR } from "./include.js";
+import { mergeText } from "./merge.js";
+import { addConflicts } from "./conflicts.js";
+import { pushSpace } from "./sync.js";
 import { defaultApiUrl, loadToken, machineHostname, readSpaceConfig, saveToken, writeSpaceConfig, } from "./config.js";
 /**
  * Three-way comparison per path (ADR 002): local, base (the version this folder last synced) and
@@ -123,13 +127,121 @@ function listSome(paths, max = 20) {
     if (paths.length > max)
         console.error(`  ... e mais ${paths.length - max}`);
 }
+export const CONFLICT_CHOICES = ["local", "mesclar", "backup"];
+/** The question for each kind of conflict, with one label per choice (local, mesclar, backup). */
+function promptFor(conflict) {
+    switch (conflict.kind) {
+        case "both":
+            return {
+                title: `${conflict.path}: ${conflict.regions} trecho(s) mudaram aqui e no servidor.`,
+                labels: [
+                    "manter a versão desta máquina (ela sobe no próximo envio)",
+                    "mesclar: gravar o arquivo com marcadores <<<<<<< e >>>>>>> para você editar",
+                    "backup: usar a versão do servidor e guardar a desta máquina em .omni/backups",
+                ],
+            };
+        case "deletedHere":
+            return {
+                title: `${conflict.path}: foi apagado aqui e alterado no servidor.`,
+                labels: [
+                    "manter apagado (a remoção sobe no próximo envio)",
+                    "trazer de volta a versão do servidor",
+                    "trazer de volta a versão do servidor",
+                ],
+            };
+        case "deletedThere":
+            return {
+                title: `${conflict.path}: foi alterado aqui e apagado no servidor.`,
+                labels: [
+                    "manter o arquivo (ele volta para o servidor no próximo envio)",
+                    "manter o arquivo (ele volta para o servidor no próximo envio)",
+                    "apagar e guardar a versão desta máquina em .omni/backups",
+                ],
+            };
+    }
+}
+export function resolveConflict(conflict, choice) {
+    const path = conflict.path;
+    switch (conflict.kind) {
+        case "both":
+            if (choice === "local")
+                return { path, pendingPush: true };
+            if (choice === "mesclar")
+                return { path, text: conflict.marked, markers: true, pendingPush: true };
+            return { path, hash: conflict.headHash, backup: true, pendingPush: false };
+        case "deletedHere":
+            if (choice === "local")
+                return { path, pendingPush: true };
+            return { path, hash: conflict.headHash, pendingPush: false };
+        case "deletedThere":
+            if (choice === "backup")
+                return { path, remove: true, backup: true, pendingPush: false };
+            return { path, pendingPush: true };
+    }
+}
 /**
- * Brings the folder to the server's head (Proof of Core Sync, fatia 3). Order matters for
- * interruptions: every object is downloaded and verified into .omni/tmp first, then files are
- * written, and only at the very end .omni/space.json gets the new base. A run killed anywhere
- * before that simply runs again.
+ * One reader for every question of a run. Lines come from an async iterator, which buffers them:
+ * `rl.question` drops answers that arrive before it is called (pasted or piped input). A closed
+ * input answers "c", which every question treats as cancel/no.
  */
-async function pullInto(root, config, token) {
+function makeAsker() {
+    let rl = null;
+    let lines = null;
+    return {
+        async ask(question) {
+            if (!rl) {
+                rl = createInterface({ input: process.stdin, terminal: false });
+                lines = rl[Symbol.asyncIterator]();
+            }
+            process.stdout.write(question);
+            const next = await lines.next();
+            return next.done ? "c" : next.value.trim().toLowerCase();
+        },
+        close() {
+            rl?.close();
+        },
+    };
+}
+async function chooseFor(conflict, asker) {
+    const { title, labels } = promptFor(conflict);
+    // Kinds where two choices mean the same thing show that option once.
+    const options = labels
+        .map((label, i) => ({ label, choice: CONFLICT_CHOICES[i] }))
+        .filter((o, i) => labels.indexOf(o.label) === i);
+    console.log(`\n${title}`);
+    options.forEach((o, i) => console.log(`  [${i + 1}] ${o.label}`));
+    for (;;) {
+        const answer = await asker.ask(`Escolha (${options.map((_, i) => i + 1).join("/")}, ou c para cancelar): `);
+        if (answer === "c")
+            return null;
+        const picked = options[Number(answer) - 1];
+        if (picked)
+            return picked.choice;
+    }
+}
+function backupStamp() {
+    return new Date().toISOString().slice(0, 19).replace(/:/g, "-");
+}
+/**
+ * Brings the folder to the server's head (Proof of Core Sync, fatias 3 e 4). Order matters for
+ * interruptions: every object is downloaded and verified into .omni/tmp first, every conflict is
+ * decided before anything is written, and only at the very end .omni/space.json gets the new base.
+ * A run killed anywhere before that simply runs again.
+ *
+ * Files changed on both sides are merged line by line against the base; what still collides is
+ * settled with one of the three options of ADR 002 (manter local, mesclar, backup), asked per file
+ * in a terminal or given once with --conflito.
+ */
+async function pullInto(root, config, token, opts = {}) {
+    const asker = makeAsker();
+    try {
+        return await pullWith(root, config, token, opts, asker);
+    }
+    finally {
+        asker.close();
+    }
+}
+async function pullWith(root, config, token, opts, asker) {
     if (!config.spaceId) {
         console.error("Esta pasta ainda não tem espaço publicado. Termine a conta no navegador e rode omni sync --push.");
         return 1;
@@ -167,20 +279,20 @@ async function pullInto(root, config, token) {
         }
         return 0;
     }
-    if (plan.conflicts.length > 0) {
-        console.error(`\nO servidor está na versão ${head} e estes arquivos mudaram aqui e lá desde a versão ${config.baseVersion}:`);
-        listSome(plan.conflicts);
-        console.error("\nNada foi alterado na pasta. Juntar as duas mudanças automaticamente ainda não existe nesta versão da CLI.");
-        return 1;
+    // Every object needed ends up in .omni/tmp: the head content of what gets written, plus base and
+    // head of each conflicting file (the merge needs both). Downloaded, or copied from a local file
+    // that already has that content (a rename on the other machine costs no download).
+    const neededSet = new Set(plan.writes.map((w) => w.hash));
+    for (const path of plan.conflicts) {
+        for (const hash of [base.get(path), headMap.get(path)])
+            if (hash)
+                neededSet.add(hash);
     }
-    // Every object the writes need ends up in .omni/tmp: downloaded, or copied from a local file that
-    // already has that content (a rename on the other machine costs no download).
     await mkdir(tmpDir, { recursive: true });
     const localByHash = new Map(manifest.files.map((f) => [f.hash, f.abs]));
     const urlByHash = new Map(pull.downloads.map((d) => [d.hash, d.url]));
-    const needed = [...new Set(plan.writes.map((w) => w.hash))].filter((h) => !cached.has(h));
     const toDownload = [];
-    for (const hash of needed) {
+    for (const hash of [...neededSet].filter((h) => !cached.has(h))) {
         const localAbs = localByHash.get(hash);
         if (localAbs)
             await copyFile(localAbs, join(tmpDir, hash));
@@ -211,6 +323,51 @@ async function pullInto(root, config, token) {
         }
         console.log(process.stdout.isTTY ? "" : `  Baixados ${done}/${toDownload.length}`);
     }
+    // Conflicts: automatic merge first, then one decision per file that still collides. Nothing is
+    // written until every decision is made, so cancelling leaves the folder as it was.
+    const resolutions = [];
+    const open = [];
+    const readObject = (hash) => (hash ? readFile(join(tmpDir, hash), "utf8") : Promise.resolve(""));
+    for (const path of plan.conflicts) {
+        const l = local.get(path);
+        const h = headMap.get(path);
+        if (l && h) {
+            const merged = mergeText(await readObject(base.get(path)), await readFile(toAbs(root, path), "utf8"), await readObject(h), head);
+            if (merged.conflicts === 0)
+                resolutions.push({ path, text: merged.text, pendingPush: true });
+            else
+                open.push({ path, kind: "both", marked: merged.text, regions: merged.conflicts, headHash: h });
+        }
+        else if (h) {
+            open.push({ path, kind: "deletedHere", headHash: h });
+        }
+        else {
+            open.push({ path, kind: "deletedThere" });
+        }
+    }
+    const autoMerged = resolutions.length;
+    if (open.length > 0) {
+        if (!opts.conflito && !process.stdin.isTTY) {
+            console.error(`\nO servidor está na versão ${head} e estes arquivos mudaram aqui e lá no mesmo trecho:`);
+            listSome(open.map((c) => c.path));
+            console.error("\nNada foi alterado na pasta. Rode num terminal para escolher arquivo por arquivo,");
+            console.error("ou escolha para todos com --conflito=local, --conflito=mesclar ou --conflito=backup.");
+            return 1;
+        }
+        if (!opts.conflito) {
+            console.log(`\nO servidor está na versão ${head}. ${open.length} arquivo(s) mudaram aqui e lá no mesmo trecho.`);
+        }
+        for (const conflict of open) {
+            const choice = opts.conflito ?? (await chooseFor(conflict, asker));
+            if (!choice) {
+                console.log("\nCancelado. Nada foi alterado na pasta.");
+                return 1;
+            }
+            resolutions.push(resolveConflict(conflict, choice));
+        }
+    }
+    const stamp = backupStamp();
+    const backedUp = [];
     try {
         for (const { path, hash } of plan.writes) {
             const abs = toAbs(root, path);
@@ -221,26 +378,66 @@ async function pullInto(root, config, token) {
             await rm(toAbs(root, path), { force: true });
             await pruneEmptyDirs(root, path);
         }
+        for (const r of resolutions) {
+            const abs = toAbs(root, r.path);
+            if (r.backup) {
+                const copy = toAbs(root, `${LOCAL_BACKUPS_DIR}/${stamp}/${r.path}`);
+                await mkdir(dirname(copy), { recursive: true });
+                await copyFile(abs, copy);
+                backedUp.push(r.path);
+            }
+            if (r.remove) {
+                await rm(abs, { force: true });
+                await pruneEmptyDirs(root, r.path);
+            }
+            else if (r.hash) {
+                await mkdir(dirname(abs), { recursive: true });
+                await copyFile(join(tmpDir, r.hash), abs);
+            }
+            else if (r.text !== undefined) {
+                await mkdir(dirname(abs), { recursive: true });
+                await writeFile(abs, r.text, "utf8");
+            }
+        }
     }
     catch (err) {
         console.error(`\nNão deu para gravar um arquivo: ${err.message}`);
         console.error("Se ele estiver aberto em outro programa, feche e rode de novo. O que já foi gravado não se perde.");
         return 1;
     }
+    const marked = resolutions.filter((r) => r.markers).map((r) => r.path);
+    await addConflicts(root, marked);
     await writeSpaceConfig(root, { ...config, baseVersion: head });
     await rm(tmpDir, { recursive: true, force: true });
     const ack = await callApi(config.apiUrl, token, "/api/cli/sync/ack", { spaceId: config.spaceId, version: head });
     if (!ack.ok)
         console.error(`(aviso) A pasta está na versão ${head}, mas o servidor não registrou: ${ack.error}`);
     console.log(`✓ Pasta na versão ${head}: ${plan.writes.length} arquivo(s) gravado(s), ${plan.deletes.length} apagado(s).`);
-    if (plan.localOnly.length > 0) {
-        console.log(`  ${plan.localOnly.length} mudança(s) local(is) mantida(s). Envie com omni sync --push.`);
+    if (autoMerged > 0)
+        console.log(`  ${autoMerged} arquivo(s) mudaram dos dois lados e foram juntados sozinhos.`);
+    if (backedUp.length > 0) {
+        console.log(`  Versão desta máquina guardada em ${LOCAL_BACKUPS_DIR}/${stamp}/ (${backedUp.length} arquivo(s)).`);
+    }
+    if (marked.length > 0) {
+        console.log("  Arquivos com marcadores para editar à mão (o envio fica bloqueado até eles sumirem):");
+        for (const path of marked)
+            console.log(`    ${path}`);
+    }
+    const pendingPush = plan.localOnly.length + resolutions.filter((r) => r.pendingPush && !r.markers).length;
+    if (pendingPush > 0 && marked.length === 0) {
+        console.log(`  ${pendingPush} mudança(s) desta máquina ainda não estão no servidor.`);
+        if (process.stdin.isTTY && !opts.conflito) {
+            const answer = await asker.ask("Enviar agora? (s/n) ");
+            if (answer === "s" || answer === "sim")
+                return pushSpace(root, { yes: true });
+        }
+        console.log("  Envie com omni sync --push.");
     }
     console.log("");
     return 0;
 }
 /** `omni sync --pull` in a folder that is already a space. */
-export async function pullSpace(root) {
+export async function pullSpace(root, opts = {}) {
     const config = await readSpaceConfig(root);
     if (!config) {
         console.error("Esta pasta não está vinculada a um espaço. Para baixar um espaço, use omni clone <código> <pasta>.");
@@ -251,7 +448,7 @@ export async function pullSpace(root) {
         console.error(`Nenhum token da CLI para ${config.apiUrl}. Vincule esta máquina de novo.`);
         return 1;
     }
-    return pullInto(root, config, token);
+    return pullInto(root, config, token, opts);
 }
 async function isEmptyDir(path) {
     try {

package/dist/report.js

@@ -1,9 +1,9 @@
 import { basename } from "node:path";
 import { MAX_SPACE_BYTES } from "./include.js";
 const TRUNCATION_MESSAGES = {
-    "max-files": "pasta grande demais (mais de 20.000 arquivos) — aponte uma subpasta",
-    "max-depth": "pasta funda demais (mais de 12 níveis) — aponte uma subpasta mais interna",
-    timeout: "a varredura passou de 60s e foi interrompida — aponte uma subpasta",
+    "max-files": "pasta grande demais (mais de 20.000 arquivos), aponte uma subpasta",
+    "max-depth": "pasta funda demais (mais de 12 níveis), aponte uma subpasta mais interna",
+    timeout: "a varredura passou de 60s e foi interrompida, aponte uma subpasta",
 };
 export function humanSize(bytes) {
     const units = ["B", "KB", "MB", "GB"];
@@ -46,7 +46,7 @@ export function printSyncPreview(manifest) {
 export function printScanReport(scan, opts = {}) {
     const lines = [];
     lines.push("");
-    lines.push(`Omni CLI v0.1.0 — leitura, nada foi alterado na pasta`);
+    lines.push(`Omni CLI: leitura, nada foi alterado na pasta`);
     lines.push("");
     lines.push(`→ Varrendo "${basename(scan.root)}"...`);
     lines.push(`  ${scan.fileCount} arquivos${scan.truncated ? " (varredura parcial)" : ""}` +
@@ -66,7 +66,7 @@ export function printScanReport(scan, opts = {}) {
         lines.push("→ Nenhuma estrutura de cérebro encontrada na raiz (CLAUDE.md, index.md, log.md, wiki/, raw/)");
     }
     if (scan.alreadyInstalled) {
-        lines.push("  Esta pasta já tem .omni/ — é um espaço Omni existente.");
+        lines.push("  Esta pasta já tem .omni/, é um espaço Omni existente.");
     }
     lines.push("");
     if (scan.envFiles.length === 0) {

package/dist/sync.js

@@ -4,6 +4,7 @@ import { buildManifest, MAX_SPACE_BYTES } from "./include.js";
 import { humanSize, printSyncPreview } from "./report.js";
 import { loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
 import { callApi } from "./api.js";
+import { unresolvedConflicts } from "./conflicts.js";
 async function confirm(question) {
     if (!process.stdin.isTTY)
         return false;
@@ -40,6 +41,14 @@ export async function pushSpace(root, opts) {
         console.error(`Nenhum token da CLI para ${config.apiUrl}. Rode omni init --link <código> de novo.`);
         return 1;
     }
+    // A file left with conflict markers by `sync --pull` (option mesclar) is not publishable yet.
+    const pendingConflicts = await unresolvedConflicts(root);
+    if (pendingConflicts.length > 0) {
+        console.error("Estes arquivos ainda têm marcadores de conflito (<<<<<<< esta máquina). Edite e rode de novo:");
+        for (const path of pendingConflicts)
+            console.error(`  ${path}`);
+        return 1;
+    }
     console.log("\n→ Montando o manifesto...");
     const manifest = await buildManifest(root);
     if (manifest.truncated) {

package/package.json

@@ -1,39 +1,39 @@
-{
-  "name": "omnispace",
-  "version": "0.2.1",
-  "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
-  "type": "module",
-  "bin": {
-    "omni": "dist/index.js",
-    "omnispace": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "omni": "node dist/index.js",
-    "test": "tsc -p tsconfig.test.json && node --test \".test-build/test/**/*.test.js\""
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "keywords": [
-    "omni",
-    "tzolkin",
-    "ai",
-    "agent",
-    "sync",
-    "knowledge-base",
-    "cli"
-  ],
-  "homepage": "https://omni.tzolkin.cloud",
-  "license": "UNLICENSED",
-  "author": "Tzolkin",
-  "devDependencies": {
-    "@types/node": "^20",
-    "typescript": "^5"
-  }
-}
+{
+  "name": "omnispace",
+  "version": "0.3.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": {
+    "omni": "dist/index.js",
+    "omnispace": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "omni": "node dist/index.js",
+    "test": "tsc -p tsconfig.test.json && node --test \".test-build/test/**/*.test.js\""
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "omni",
+    "tzolkin",
+    "ai",
+    "agent",
+    "sync",
+    "knowledge-base",
+    "cli"
+  ],
+  "homepage": "https://omni.tzolkin.cloud",
+  "license": "UNLICENSED",
+  "author": "Tzolkin",
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5"
+  }
+}