shilo-cli 0.9.0 → 0.11.0

package/README.md

@@ -186,6 +186,62 @@ shilo deploys -n 20 --json
 `--deploy` sólo agrega el trailer `[deploy: …]` al mensaje; escribirlo a mano en
 `-m` da lo mismo.
 
+### Propuestas (propuestas)
+
+Lo mismo que la pantalla de propuestas de la web, desde la terminal. Sirve
+también para que un agente (Claude Code) lea una propuesta y la resuelva.
+
+```bash
+shilo propuestas                        # las abiertas (--todas: también resueltas)
+shilo propuestas ver 451391aa --diff    # qué cambia y qué choca con la versión actual
+shilo propuestas ver 4513 --json --contenido   # todo en JSON, con el texto de cada versión
+shilo propuestas bajar 4513             # base/, propuesta/ y actual/ en .shilo/propuestas/4513…/
+shilo propuestas aplicar 4513 --propuesta src/a.js --actual README.md --yes
+shilo propuestas aplicar 4513 --todo ambas      # lo que falte decidir
+shilo propuestas descartar 4513 --yes
+```
+
+Aplicar es sólo del dueño; descartar, del dueño o de quien la propuso. En un
+conflicto la decisión es por archivo (`actual`, `propuesta` o `ambas`). Para
+combinar línea a línea: `bajar`, escribir el resultado en la carpeta,
+`shilo push` (entra limpio sobre la versión actual) y `descartar` la vieja.
+Exit code 3 = la propuesta sigue abierta.
+
+### Respaldar todas las carpetas (sync)
+
+```bash
+shilo sync                      # lista las carpetas conectadas y su último sync
+shilo sync --all                # sube todas, una tras otra
+shilo sync ./boda               # sólo esa carpeta
+shilo sync a4c2                 # o por id de proyecto (alcanza un prefijo)
+shilo sync --scan ~/proyectos   # registra las carpetas ya conectadas que haya ahí
+shilo sync --forget ./vieja     # la saca del registro (no toca el disco)
+shilo sync --all --dry-run      # qué subiría cada una, sin subir nada
+```
+
+El CLI lleva un registro de carpetas conectadas en `~/.shilo/carpetas.json`. Se llena
+solo: cada `init`, `push` o `pull` registra su carpeta. Las que se conectaron antes
+de esta versión se suman una vez con `--scan`, que busca `.shilo.json` hasta 6 niveles
+abajo (no entra en `node_modules`, `.git` ni `dist`).
+
+Sincronizar es **subir**: cada carpeta pasa por `shilo push --yes`, con sus mismas
+garantías (un conflicto queda como propuesta abierta, una carpeta con posibles
+secretos no sube nada). Cada push corre en su propio proceso, así que si una carpeta
+falla las demás siguen, y al final hay un resumen. **Un respaldo no despliega:**
+manda `--deploy off` salvo que pases otro `--deploy`.
+
+**Una carpeta sin `base` se saltea.** `base` es la versión del proyecto sobre la que
+está tu copia; la escriben `push` y `pull`. Sin ella, un push no puede saber si tu
+copia está vieja y subiría tus archivos como cambios, pisando lo más nuevo. Esas
+carpetas aparecen como "requiere atención": revisalas con `shilo status` y
+`shilo diff`, subilas a mano una vez con `shilo push` (o bajá lo nuevo con
+`shilo pull`) y desde ahí entran solas al respaldo.
+
+Exit code 1 = alguna carpeta falló o se salteó. Una propuesta que queda esperando
+aprobación (exit 3 de `push`) cuenta como respaldada. El plan de las etapas
+siguientes (respaldo programado, vista en la web) está en `PLAN_SINCRONIZAR.md` en la
+raíz del repo.
+
 ### Diferencias (diff)
 
 ```bash
@@ -326,6 +382,8 @@ SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natura
   `registerBlob` para binarios, camino viejo sólo como reserva.
 - **Fase 8 — deploys** *(hecho)*: `push --deploy <prod|preview|off>` y
   `shilo deploys` para el deploy automático a Vercel (PLAN_DEPLOY_VERCEL).
+- **Fase 9 — respaldo** *(Etapa 1 hecha)*: registro de carpetas conectadas y
+  `shilo sync [--all]`. Lo que sigue, en `PLAN_SINCRONIZAR.md`.
 
 ## Exit codes
 
@@ -335,4 +393,5 @@ SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natura
 | `diff`   | 1      | Hay diferencias entre local y remoto.        |
 | `pull`   | 1      | Quedaron conflictos sin bajar (o fallas).    |
 | `push`   | 1      | Se detectaron posibles secretos (nada subido). |
+| `sync`   | 1      | Alguna carpeta no se respaldó (falló o se salteó). |
 | cualquiera | 1    | Error.                                       |

package/bin/shilo.js

@@ -25,7 +25,9 @@ ${ui.c.bold('Comandos:')}
   review [versión]   Quién revisó una versión, o dejar tu revisión.
   export <carpeta>   Escribe la historia del proyecto como un repositorio Git.
   deploys            Destino e historial de deploys a Vercel del proyecto.
-  help               Muestra esta ayuda.
+  propuestas [sub]   Ver, bajar, aplicar o descartar propuestas (ver abajo).
+  sync [carpeta|uuid] Respalda las carpetas conectadas (--all: todas).
+  help              Muestra esta ayuda.
 
 ${ui.c.bold('Opciones de login:')}
   --email <e>        Email (si se omite, se pregunta).
@@ -117,6 +119,36 @@ ${ui.c.bold('Opciones de deploys:')}
   --json             Salida JSON.
   --project <uuid>   Proyecto (pisa el .shilo.json de la carpeta).
 
+${ui.c.bold('Propuestas:')}
+  propuestas                 Lista las abiertas (--todas: también las resueltas).
+  propuestas ver <id>        Qué cambia, qué choca con la versión actual y chequeos.
+    --diff                   Muestra las diferencias de cada archivo.
+    --contenido              Con --json, incluye el texto de cada versión (para IA).
+  propuestas bajar <id>      Deja base/, propuesta/ y actual/ de cada archivo en
+                             .shilo/propuestas/<id>/ (o --destino <carpeta>).
+  propuestas aplicar <id>    Aplica (sólo el dueño). En los archivos en conflicto:
+    --propuesta <ruta>       se queda la de la propuesta (repetible o a,b,c),
+    --actual <ruta>          se queda la versión actual,
+    --ambas <ruta>           quedan las dos (la propuesta al lado, con otro nombre),
+    --todo <decisión>        lo que falte decidir: actual | propuesta | ambas.
+    --forzar                 Aplica aunque hayan fallado chequeos o piezas USEE.
+  propuestas descartar <id>  La cierra sin aplicar (dueño o quien la propuso).
+  --yes  --json  --project <uuid>
+  ${ui.c.dim('El id puede ser un prefijo de 4+ caracteres. Exit code 3 = sigue abierta.')}
+  ${ui.c.dim('Combinar a mano: bajar, escribir el resultado, "shilo push" y descartar.')}
+
+${ui.c.bold('Opciones de sync:')}
+  (sin argumentos)   Lista las carpetas conectadas y su último sync.
+  --all              Sube todas las carpetas registradas, una tras otra.
+  --scan [raíz]      Registra las carpetas con .shilo.json bajo raíz (default: la actual).
+  --forget <carpeta> La saca del registro (no toca nada en disco).
+  -m, --message <m>  Mensaje de los commits (default: "Respaldo (shilo sync) <fecha>").
+  --deploy <d>       prod | preview | off (default off: un respaldo no despliega).
+  --dry-run          Muestra qué subiría cada carpeta, sin subir nada.
+  ${ui.c.dim('Se registran solas con init, push o pull. Una carpeta sin "base" en su')}
+  ${ui.c.dim('.shilo.json se saltea: subila a mano una vez con "shilo push".')}
+  ${ui.c.dim('Exit code 1 = alguna carpeta falló o se salteó.')}
+
 ${ui.c.bold('Globales:')}
   -v, --version      Versión del CLI.
   -h, --help         Ayuda.
@@ -135,6 +167,9 @@ const COMMANDS = {
   review: () => require('../src/commands/review'),
   export: () => require('../src/commands/export'),
   deploys: () => require('../src/commands/deploys'),
+  sync: () => require('../src/commands/sync'),
+  propuestas: () => require('../src/commands/propuestas'),
+  proposals: () => require('../src/commands/propuestas'),
 };
 
 async function main() {
@@ -146,13 +181,15 @@ async function main() {
     booleans: [
       'help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push', 'pull',
       'json', 'short', 'stat', 'files', 'allow-secrets', 'no-index', 'verbose',
-      'allow-failing-checks',
+      'allow-failing-checks', 'all',
       'show-ignored', 'include-ignored', 'aprobado', 'reparos', 'rechazado',
+      'todas', 'diff', 'contenido', 'forzar',
     ],
     aliases: { h: 'help', v: 'version', m: 'message' },
     // `--only` se repite (un selector por ruta): sin esto la última aparición
     // pisaría a las anteriores y un push de dos archivos subiría uno solo.
-    multiple: ['only'],
+    // Las decisiones de `propuestas aplicar` también: una ruta por aparición.
+    multiple: ['only', 'actual', 'propuesta', 'ambas'],
   });
 
   const cmd = parsed._[0];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shilo-cli",
-  "version": "0.9.0",
-  "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
+  "version": "0.11.0",
+  "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log, diff, sync y propuestas.",
   "keywords": [
     "shilo",
     "cli",
@@ -25,7 +25,8 @@
     "README.md"
   ],
   "scripts": {
-    "start": "node bin/shilo.js"
+    "start": "node bin/shilo.js",
+    "test": "node --test"
   },
   "engines": {
     "node": ">=18"

package/src/ShiloClient.js

@@ -848,6 +848,35 @@ class ShiloClient {
     };
   }
 
+  /**
+   * Detalle de una propuesta: `changes` (con los oids `base`/`head` de cada
+   * archivo en servidores que los mandan), `conflicts` contra la versión
+   * actual de ahora, `blocked_by`, `chequeos`, `usee` y `main`. No escribe nada.
+   */
+  async getProposal(projectId, id, credentials) {
+    const params = new URLSearchParams({ projectId, id });
+    const url = `${this.baseURL}/api/projects/proposals?${params.toString()}`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo leer la propuesta: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    return {
+      proposal: (data && data.proposal) || null,
+      main: (data && data.main) || null,
+      changes: data && Array.isArray(data.changes) ? data.changes : [],
+      resumen: (data && data.resumen) || '',
+      chequeos: (data && data.chequeos) || null,
+      conflicts: data && Array.isArray(data.conflicts) ? data.conflicts : [],
+      blockedBy: data && Array.isArray(data.blocked_by) ? data.blocked_by : [],
+      fastForward: !!(data && data.fast_forward),
+      usee: (data && data.usee) || null,
+      credentials: creds,
+    };
+  }
+
   /**
    * Abre una propuesta y deja que el servidor intente aplicarla.
    *

package/src/commands/propuestas.js

@@ -0,0 +1,467 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const prompt = require('../prompt');
+const textdiff = require('../textdiff');
+const { resolveContext } = require('../context');
+
+/**
+ * shilo propuestas [ver|bajar|aplicar|descartar] [id] [opciones]
+ *
+ * Las propuestas desde la terminal: lo que hasta ahora sólo se veía y se
+ * resolvía en la web. Pensado también para que un agente (Claude Code) pueda
+ * leer una propuesta abierta, ver dónde choca con la versión actual y
+ * resolverla:
+ *
+ *   - archivo por archivo con `aplicar` y --actual / --propuesta / --ambas, o
+ *   - combinando a mano: `bajar` deja las tres versiones de cada archivo en
+ *     `.shilo/propuestas/<id>/`, el agente escribe la combinación en la
+ *     carpeta, `shilo push` la guarda sobre la versión actual y `descartar`
+ *     cierra la propuesta vieja.
+ *
+ * El id es el que imprime el listado (alcanza un prefijo de 4+ caracteres).
+ * El contexto se resuelve siempre sobre el directorio actual, igual que `log`.
+ */
+
+const SUBCOMANDOS = new Set(['listar', 'ver', 'bajar', 'aplicar', 'descartar']);
+const DECISIONES = ['actual', 'propuesta', 'ambas'];
+const ACCIONES = { added: 'agrega', modified: 'modifica', deleted: 'borra' };
+const ESTADOS = {
+  abierta: (s) => ui.c.yellow(s),
+  aplicada: (s) => ui.c.green(s),
+  descartada: (s) => ui.c.dim(s),
+};
+// Un archivo más grande que esto no se mete en el JSON de `ver --contenido`:
+// para eso está `bajar`.
+const MAX_INLINE = 256 * 1024;
+
+async function propuestas(args) {
+  const [primero, ...resto] = args._;
+  const sub = SUBCOMANDOS.has(primero) ? primero : 'listar';
+  const posicionales = SUBCOMANDOS.has(primero) ? resto : args._;
+  const id = typeof posicionales[0] === 'string' ? posicionales[0].trim() : '';
+
+  if (sub !== 'listar' && !id) {
+    ui.error(`Falta el id de la propuesta: shilo propuestas ${sub} <id>`);
+    ui.info(ui.c.dim('Los ids salen de "shilo propuestas".'));
+    return 1;
+  }
+
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+
+  try {
+    if (sub === 'listar') return await listar(ctx, args);
+    const encontrada = await buscar(ctx, id);
+    if (!encontrada) return 1;
+    if (sub === 'ver') return await ver(ctx, encontrada, args);
+    if (sub === 'bajar') return await bajar(ctx, encontrada, args);
+    if (sub === 'aplicar') return await aplicar(ctx, encontrada, args);
+    return await descartar(ctx, encontrada, args);
+  } catch (e) {
+    ui.error(e.notSupported ? 'Este servidor de Shilo todavía no tiene propuestas.' : e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(ctx.cfg, ctx.mgr.current);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// listar
+// ---------------------------------------------------------------------------
+
+async function listar({ client, projectId, mgr, baseURL }, args) {
+  const state = args.todas ? null : 'abierta';
+  const listed = await client.listProposals(projectId, await mgr.valid(), { state });
+
+  if (args.json) {
+    console.log(JSON.stringify({
+      projectId, main: listed.main, viewer: listed.viewer, proposals: listed.proposals,
+    }, null, 2));
+    return 0;
+  }
+
+  ui.info(`Propuestas ${args.todas ? '' : 'abiertas '}— ${ui.c.cyan(baseURL)}`);
+  ui.info('');
+  if (listed.proposals.length === 0) {
+    ui.info(args.todas ? 'Este proyecto no tiene propuestas.' : 'No hay propuestas abiertas.');
+    return 0;
+  }
+  for (const p of listed.proposals) {
+    const estado = (ESTADOS[p.state] || ((s) => s))(p.state);
+    const conflictos = Array.isArray(p.conflicts) && p.conflicts.length > 0
+      ? ui.c.red(`  ${p.conflicts.length} en conflicto`)
+      : '';
+    ui.info(`${ui.c.yellow(p.id.slice(0, 8))}  ${estado}  ${ui.c.bold(p.title || '(sin título)')}${conflictos}`);
+    ui.info(ui.c.dim(`          ${sync.describeAuthor(p.author)} · ${sync.formatDate(p.created_at)}`));
+  }
+  ui.info('');
+  ui.info(ui.c.dim('Para verla: shilo propuestas ver <id> [--diff]'));
+  return 0;
+}
+
+/** La propuesta cuyo id empieza con `prefijo`, o null habiendo impreso por qué. */
+async function buscar({ client, projectId, mgr }, prefijo) {
+  const p = prefijo.toLowerCase();
+  if (p.length < 4) {
+    ui.error('El id tiene que tener al menos 4 caracteres.');
+    return null;
+  }
+  const listed = await client.listProposals(projectId, await mgr.valid());
+  const hits = listed.proposals.filter((pr) => pr.id.toLowerCase().startsWith(p));
+  if (hits.length === 0) {
+    ui.error(`No hay ninguna propuesta que empiece con "${prefijo}".`);
+    return null;
+  }
+  if (hits.length > 1) {
+    ui.error(`"${prefijo}" coincide con ${hits.length} propuestas; usá más caracteres.`);
+    return null;
+  }
+  return { proposal: hits[0], viewer: listed.viewer, project: listed.project };
+}
+
+// ---------------------------------------------------------------------------
+// ver
+// ---------------------------------------------------------------------------
+
+async function ver(ctx, { proposal: resumen, viewer }, args) {
+  const { client, projectId, mgr } = ctx;
+  const d = await client.getProposal(projectId, resumen.id, await mgr.valid());
+  const p = d.proposal || resumen;
+  const conContenido = !!(args.diff || args.contenido);
+  const contenidos = conContenido ? await bajarContenidos(ctx, oidsDe(d)) : new Map();
+
+  if (args.json) {
+    const texto = (oid) => (args.contenido ? textoInline(contenidos, oid) : undefined);
+    console.log(JSON.stringify({
+      projectId,
+      proposal: p,
+      main: d.main,
+      resumen: d.resumen,
+      fast_forward: d.fastForward,
+      chequeos: d.chequeos,
+      usee: d.usee,
+      blocked_by: d.blockedBy,
+      puedo_aplicar: !!(viewer && viewer.is_owner),
+      changes: d.changes.map((c) => ({
+        ...c,
+        ...(args.contenido ? { contenido_base: texto(c.base), contenido_propuesta: texto(c.head) } : {}),
+      })),
+      // ours = la propuesta, theirs = la versión actual (ver `mergeTrees`).
+      conflicts: d.conflicts.map((c) => ({
+        path: c.path,
+        kind: c.kind,
+        base: c.base,
+        propuesta: c.ours,
+        actual: c.theirs,
+        ...(args.contenido
+          ? { contenido_base: texto(c.base), contenido_propuesta: texto(c.ours), contenido_actual: texto(c.theirs) }
+          : {}),
+      })),
+    }, null, 2));
+    return 0;
+  }
+
+  const estado = (ESTADOS[p.state] || ((s) => s))(p.state);
+  ui.info(`${ui.c.yellow(p.id.slice(0, 8))}  ${estado}  ${ui.c.bold(p.title || '(sin título)')}`);
+  ui.info(ui.c.dim(`Propuesta por ${sync.describeAuthor(p.author)} · ${sync.formatDate(p.created_at)}`));
+  if (p.summary) ui.info(`\n${p.summary}`);
+  if (d.resumen) ui.info(`\n${d.resumen}`);
+
+  ui.info('');
+  ui.info(ui.c.bold(`Cambios (${d.changes.length}):`));
+  for (const c of d.changes) ui.info(`  ${ACCIONES[c.action] || c.action}  ${c.path}`);
+
+  if (d.chequeos) {
+    const ok = d.chequeos.ok !== false;
+    ui.info('');
+    ui.info(`Chequeos: ${ok ? ui.c.green('verificada') : ui.c.red('fallaron')} en la máquina que la propuso.`);
+  }
+  if (d.usee && d.usee.despues && d.usee.despues.ok === false) {
+    ui.warn('Aplicarla dejaría alguna pieza USEE sin pasar el Nivel 1.');
+  }
+  if (d.blockedBy.length > 0) {
+    ui.info('');
+    for (const b of d.blockedBy) {
+      ui.warn(`Se cruza con la propuesta ${b.id.slice(0, 8)} "${b.title || ''}" en: ${b.paths.join(', ')}`);
+    }
+  }
+
+  if (d.conflicts.length > 0) {
+    ui.info('');
+    ui.info(ui.c.red(ui.c.bold(`En conflicto con la versión actual (${d.conflicts.length}):`)));
+    for (const c of d.conflicts) ui.info(`  ${c.path}${c.kind === 'archivo-y-carpeta' ? ui.c.dim(' (archivo vs carpeta)') : ''}`);
+  } else if (p.state === 'abierta') {
+    ui.info('');
+    ui.info(ui.c.green(d.fastForward ? 'Entra tal cual sobre la versión actual.' : 'Combina limpio con la versión actual.'));
+  }
+
+  if (args.diff) {
+    const conflictivas = new Set(d.conflicts.map((c) => c.path));
+    // Un servidor anterior manda los cambios sin oids: sólo hay diff de los conflictos.
+    const conOids = d.changes.every((c) => 'head' in c);
+    if (!conOids && d.changes.some((c) => !conflictivas.has(c.path))) {
+      ui.info('');
+      ui.warn('Este servidor de Shilo no manda el contenido de los cambios: sólo se ven los conflictos.');
+    }
+    for (const c of conOids ? d.changes : []) {
+      if (conflictivas.has(c.path)) continue;
+      imprimirDiff(`${c.path} (base → propuesta)`, contenidos, c.base, c.head, args);
+    }
+    for (const c of d.conflicts) {
+      imprimirDiff(`${c.path} (versión actual → propuesta)`, contenidos, c.theirs, c.ours, args);
+    }
+  }
+
+  if (p.state === 'abierta') {
+    ui.info('');
+    const id8 = p.id.slice(0, 8);
+    if (!args.diff) ui.info(ui.c.dim(`Diferencias:  shilo propuestas ver ${id8} --diff`));
+    if (viewer && viewer.is_owner) {
+      ui.info(ui.c.dim(d.conflicts.length > 0
+        ? `Resolver:     shilo propuestas aplicar ${id8} --propuesta <ruta> --actual <ruta> (o --todo propuesta)`
+        : `Aplicar:      shilo propuestas aplicar ${id8}`));
+    }
+    ui.info(ui.c.dim(`Combinar a mano: shilo propuestas bajar ${id8}`));
+  }
+  return 0;
+}
+
+function imprimirDiff(titulo, contenidos, de, a, args) {
+  ui.info('');
+  ui.info(ui.c.bold(`── ${titulo}`));
+  const viejo = de ? contenidos.get(de) : Buffer.alloc(0);
+  const nuevo = a ? contenidos.get(a) : Buffer.alloc(0);
+  if (viejo === undefined || nuevo === undefined) {
+    ui.info(ui.c.dim('(no se pudo bajar el contenido de este archivo)'));
+    return;
+  }
+  if (esBinario(viejo) || esBinario(nuevo)) {
+    ui.info(ui.c.dim(`(binario: ${viejo.length} → ${nuevo.length} bytes)`));
+    return;
+  }
+  const context = Number.parseInt(args.context, 10);
+  const r = textdiff.diffText(viejo.toString('utf8'), nuevo.toString('utf8'), {
+    context: Number.isFinite(context) ? Math.min(20, Math.max(0, context)) : undefined,
+  });
+  const lineas = textdiff.renderDiff(r, { paint: ui.c });
+  if (!a) ui.info(ui.c.red('(se borra)'));
+  for (const l of lineas) ui.info(l);
+}
+
+// ---------------------------------------------------------------------------
+// bajar
+// ---------------------------------------------------------------------------
+
+/**
+ * Deja en disco las versiones de cada archivo que toca la propuesta:
+ *   propuesta/<ruta>, base/<ruta> y, si choca, actual/<ruta>.
+ * Por defecto en `.shilo/propuestas/<id8>/`, que el push ignora.
+ */
+async function bajar(ctx, { proposal: resumen }, args) {
+  const { client, projectId, mgr, dir } = ctx;
+  const d = await client.getProposal(projectId, resumen.id, await mgr.valid());
+  const destino = path.resolve(
+    typeof args.destino === 'string' ? args.destino : path.join(dir, '.shilo', 'propuestas', resumen.id.slice(0, 8))
+  );
+  const contenidos = await bajarContenidos(ctx, oidsDe(d));
+
+  const escritos = [];
+  const escribir = (lado, ruta, oid) => {
+    if (!oid) return;
+    const buf = contenidos.get(oid);
+    if (buf === undefined) return;
+    const abs = path.join(destino, lado, ...ruta.split('/'));
+    if (!abs.startsWith(destino + path.sep)) return; // ruta rara: no salir de destino
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, buf);
+    escritos.push(path.relative(destino, abs));
+  };
+  for (const c of d.changes) {
+    escribir('base', c.path, c.base);
+    escribir('propuesta', c.path, c.head);
+  }
+  for (const c of d.conflicts) {
+    escribir('base', c.path, c.base);
+    escribir('propuesta', c.path, c.ours);
+    escribir('actual', c.path, c.theirs);
+  }
+
+  const informe = {
+    id: resumen.id,
+    title: resumen.title,
+    main: d.main,
+    changes: d.changes.map((c) => ({ path: c.path, action: c.action })),
+    conflicts: d.conflicts.map((c) => ({ path: c.path, kind: c.kind })),
+  };
+  fs.mkdirSync(destino, { recursive: true });
+  fs.writeFileSync(path.join(destino, 'propuesta.json'), JSON.stringify(informe, null, 2));
+
+  if (args.json) {
+    console.log(JSON.stringify({ ...informe, destino, archivos: escritos }, null, 2));
+    return 0;
+  }
+  if (!d.changes.every((c) => 'head' in c)) {
+    ui.warn('Este servidor de Shilo no manda el contenido de los cambios: sólo se bajaron los conflictos.');
+  }
+  ui.success(`${escritos.length} archivo(s) en ${destino}`);
+  ui.info(ui.c.dim('  base/       como estaba cuando se propuso'));
+  ui.info(ui.c.dim('  propuesta/  lo que propone'));
+  if (d.conflicts.length > 0) ui.info(ui.c.dim('  actual/     la versión actual, en los archivos que chocan'));
+  ui.info('');
+  ui.info('Para combinar a mano: escribí el resultado en tu carpeta, "shilo push",');
+  ui.info(`y después "shilo propuestas descartar ${resumen.id.slice(0, 8)}".`);
+  return 0;
+}
+
+// ---------------------------------------------------------------------------
+// aplicar / descartar
+// ---------------------------------------------------------------------------
+
+/**
+ * Arma `{ ruta: decisión }` de --actual / --propuesta / --ambas (repetibles,
+ * también separados por coma) y --todo <decisión> para el resto. Devuelve
+ * `{ resolutions, faltan }` o `{ error }`.
+ */
+function armarDecisiones(args, conflicts) {
+  const resolutions = {};
+  for (const decision of DECISIONES) {
+    for (const v of args[decision] || []) {
+      for (const ruta of String(v).split(',').map((s) => s.trim().replace(/^\.?\//, '')).filter(Boolean)) {
+        if (resolutions[ruta] && resolutions[ruta] !== decision) {
+          return { error: `"${ruta}" tiene dos decisiones: ${resolutions[ruta]} y ${decision}.` };
+        }
+        resolutions[ruta] = decision;
+      }
+    }
+  }
+  const todo = typeof args.todo === 'string' ? args.todo : null;
+  if (args.todo !== undefined && !DECISIONES.includes(todo)) {
+    return { error: `--todo tiene que ser ${DECISIONES.join(', ')}.` };
+  }
+  const enConflicto = new Set(conflicts.map((c) => c.path));
+  const ajenas = Object.keys(resolutions).filter((r) => !enConflicto.has(r));
+  if (ajenas.length > 0) {
+    return { error: `No están en conflicto: ${ajenas.join(', ')}. Mirá "shilo propuestas ver".` };
+  }
+  for (const c of conflicts) {
+    if (!resolutions[c.path] && todo) resolutions[c.path] = todo;
+  }
+  const faltan = conflicts.map((c) => c.path).filter((r) => !resolutions[r]);
+  return { resolutions, faltan };
+}
+
+async function aplicar(ctx, { proposal: resumen, viewer }, args) {
+  const { client, projectId, mgr } = ctx;
+  if (resumen.state !== 'abierta') {
+    ui.error(`Esa propuesta ya está ${resumen.state}.`);
+    return 1;
+  }
+  if (viewer && !viewer.is_owner) {
+    ui.error('Sólo el dueño del proyecto puede aplicar una propuesta.');
+    return 1;
+  }
+
+  const d = await client.getProposal(projectId, resumen.id, await mgr.valid());
+  const armado = armarDecisiones(args, d.conflicts);
+  if (armado.error) {
+    ui.error(armado.error);
+    return 1;
+  }
+  if (armado.faltan.length > 0) {
+    ui.error(`Falta decidir ${armado.faltan.length} archivo(s) en conflicto:`);
+    for (const r of armado.faltan) ui.info(`  ${r}`);
+    ui.info(ui.c.dim('Usá --actual <ruta>, --propuesta <ruta>, --ambas <ruta> o --todo <decisión>.'));
+    return 1;
+  }
+
+  const id8 = resumen.id.slice(0, 8);
+  if (!args.yes) {
+    for (const [ruta, dec] of Object.entries(armado.resolutions)) ui.info(`  ${ruta}: ${dec}`);
+    if (!(await prompt.confirm(`¿Aplicar la propuesta ${id8} "${resumen.title || ''}"?`))) {
+      ui.info('No se aplicó nada.');
+      return 1;
+    }
+  }
+
+  const r = await client.resolveProposal(projectId, resumen.id, 'apply', await mgr.valid(), {
+    resolutions: Object.keys(armado.resolutions).length > 0 ? armado.resolutions : null,
+    force: !!args.forzar,
+  });
+
+  if (args.json) {
+    console.log(JSON.stringify({ projectId, applied: r.applied, proposal: r.proposal, conflicts: r.conflicts, piezas: r.piezas, main: r.main, message: r.message }, null, 2));
+    return r.applied ? 0 : 3;
+  }
+  if (r.applied) {
+    ui.success(`Propuesta ${id8} aplicada: ya es la versión actual.`);
+    ui.info(ui.c.dim('Traela a tu carpeta con "shilo pull".'));
+    return 0;
+  }
+  ui.warn(r.message || 'La propuesta sigue abierta.');
+  if (r.conflicts.length > 0) for (const c of r.conflicts) ui.info(`  ${c.path}`);
+  if (!args.forzar && (r.piezas.length > 0 || /forzar/.test(r.message))) {
+    ui.info(ui.c.dim('Para aplicarla igual: --forzar'));
+  }
+  return 3;
+}
+
+async function descartar(ctx, { proposal: resumen }, args) {
+  const { client, projectId, mgr } = ctx;
+  if (resumen.state !== 'abierta') {
+    ui.error(`Esa propuesta ya está ${resumen.state}.`);
+    return 1;
+  }
+  const id8 = resumen.id.slice(0, 8);
+  if (!args.yes && !(await prompt.confirm(`¿Descartar la propuesta ${id8} "${resumen.title || ''}"?`))) {
+    ui.info('No se descartó nada.');
+    return 1;
+  }
+  await client.resolveProposal(projectId, resumen.id, 'discard', await mgr.valid());
+  if (args.json) console.log(JSON.stringify({ projectId, id: resumen.id, discarded: true }));
+  else ui.success(`Propuesta ${id8} descartada.`);
+  return 0;
+}
+
+// ---------------------------------------------------------------------------
+// Contenido por oid
+// ---------------------------------------------------------------------------
+
+function oidsDe(d) {
+  const oids = new Set();
+  for (const c of d.changes) [c.base, c.head].forEach((o) => o && oids.add(o));
+  for (const c of d.conflicts) [c.base, c.ours, c.theirs].forEach((o) => o && oids.add(o));
+  return [...oids];
+}
+
+/** `oid → Buffer`, verificado contra su sha256. Los que no llegan, no están. */
+async function bajarContenidos({ client, projectId, mgr }, oids) {
+  const out = new Map();
+  if (oids.length === 0) return out;
+  const r = await client.graphBlobs(projectId, oids, await mgr.valid());
+  await sync.runPool(Object.entries(r.blobs), 6, async ([oid, { url }]) => {
+    const buf = url ? await client.downloadBinary(url) : Buffer.alloc(0);
+    if (crypto.createHash('sha256').update(buf).digest('hex') === oid) out.set(oid, buf);
+  });
+  return out;
+}
+
+function esBinario(buf) {
+  return buf.subarray(0, 8000).includes(0);
+}
+
+/** El texto de un oid para el JSON, o null si no hay, es binario o es grande. */
+function textoInline(contenidos, oid) {
+  if (!oid) return null;
+  const buf = contenidos.get(oid);
+  if (!buf || esBinario(buf) || buf.length > MAX_INLINE) return null;
+  return buf.toString('utf8');
+}
+
+module.exports = propuestas;
+module.exports.armarDecisiones = armarDecisiones;

package/src/commands/sync.js

@@ -0,0 +1,240 @@
+'use strict';
+
+/**
+ * `shilo sync` — respaldo de las carpetas conectadas (PLAN_SINCRONIZAR, Etapa 1).
+ *
+ *   shilo sync                  lista las carpetas registradas y su último sync
+ *   shilo sync --all            sube todas, una tras otra
+ *   shilo sync <carpeta|uuid>   sube sólo esa (por ruta o por id de proyecto)
+ *   shilo sync --scan [raíz]    registra las carpetas atadas que haya bajo raíz
+ *   shilo sync --forget <dir>   saca una carpeta del registro (no toca el disco)
+ *
+ * Sincronizar es SUBIR: cada carpeta pasa por `shilo push --yes`, con todas sus
+ * garantías — un conflicto queda como propuesta abierta sin pisar a nadie, y una
+ * carpeta con posibles secretos no sube nada. Cada push corre en su propio
+ * proceso: lo que falle en una carpeta no arrastra a las demás.
+ *
+ * Una carpeta sin `base` en su `.shilo.json` se saltea (ver `checkFolder`).
+ *
+ * Un respaldo no despliega: se manda `--deploy off` salvo que se pida otra cosa,
+ * porque con `auto_target = production` un respaldo nocturno iría a producción.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const folders = require('../folders');
+const remote = require('../remote');
+const ui = require('../ui');
+
+const BIN = path.join(__dirname, '..', '..', 'bin', 'shilo.js');
+// Un prefijo del id alcanza (como un hash corto de git), pero no menos de 4.
+const UUID_RE = /^[0-9a-f-]{4,36}$/i;
+
+async function sync(args) {
+  if (args.forget !== undefined) return forget(args.forget);
+  if (args.scan !== undefined) return scan(args.scan === true ? '.' : args.scan);
+
+  let entries;
+  try {
+    entries = folders.load();
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  const target = args._[0];
+  if (!args.all && !target) return list(entries);
+
+  let selected;
+  if (args.all) {
+    selected = entries;
+  } else {
+    selected = resolveTarget(target, entries);
+    if (!selected) return 1;
+  }
+
+  if (selected.length === 0) {
+    ui.warn('No hay carpetas registradas.');
+    ui.info('Corré "shilo sync --scan <carpeta>" para encontrar las que ya están conectadas.');
+    return 0;
+  }
+
+  const deploy = typeof args.deploy === 'string' ? args.deploy : 'off';
+  const message =
+    typeof args.message === 'string' && args.message.trim()
+      ? args.message.trim()
+      : `Respaldo (shilo sync) ${new Date().toLocaleString('es-AR')}`;
+
+  const results = [];
+  for (const [i, entry] of selected.entries()) {
+    ui.info('');
+    ui.info(ui.c.bold(`[${i + 1}/${selected.length}] ${entry.dir}`));
+
+    const check = checkFolder(entry);
+    if (check.problem) {
+      ui.warn(check.problem);
+      results.push({ dir: entry.dir, status: 'salteada', detail: check.problem });
+      continue;
+    }
+
+    const pushArgs = ['push', entry.dir, '--yes', '-m', message, '--deploy', deploy];
+    if (args['dry-run']) pushArgs.push('--dry-run');
+    const code = await runChild(pushArgs);
+    results.push(resultFor(entry.dir, code));
+  }
+
+  return summarize(results, !!args['dry-run']);
+}
+
+/** Código de salida de `push` → fila del resumen. */
+function resultFor(dir, code) {
+  if (code === 0) return { dir, status: 'ok', detail: '' };
+  // 3 = todo guardado, pero el proyecto exige aprobación: el respaldo está hecho.
+  if (code === 3) return { dir, status: 'ok', detail: 'guardado; la propuesta espera aprobación' };
+  return { dir, status: 'falló', detail: `push salió con código ${code} (ver arriba)` };
+}
+
+/** Lista el registro con el estado que dice cada `.shilo.json`. */
+function list(entries) {
+  if (entries.length === 0) {
+    ui.info('No hay carpetas registradas todavía.');
+    ui.info(
+      ui.c.dim(
+        'Se registran solas con init, push o pull; las ya conectadas se suman con "shilo sync --scan <carpeta>".'
+      )
+    );
+    return 0;
+  }
+  ui.info(ui.c.bold(`Carpetas conectadas (${entries.length}):`));
+  for (const entry of entries) {
+    const check = checkFolder(entry);
+    const when = check.remote && check.remote.lastSync
+      ? new Date(check.remote.lastSync).toLocaleString('es-AR')
+      : 'nunca';
+    const state = check.problem ? ui.c.yellow(check.problem) : ui.c.dim(`último sync: ${when}`);
+    ui.info(`  ${entry.dir}`);
+    ui.info(`    ${ui.c.dim(entry.projectId || '?')}  ${state}`);
+  }
+  ui.info('');
+  ui.info(ui.c.dim('"shilo sync --all" las sube todas; "shilo sync <carpeta|uuid>" sólo una.'));
+  return 0;
+}
+
+/**
+ * `<carpeta|uuid>` → lista de una entrada. Una carpeta existente que no estaba
+ * en el registro se registra (si está atada).
+ */
+function resolveTarget(target, entries) {
+  const abs = path.resolve(target);
+  if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+    const r = safeRead(abs);
+    if (!r || !r.projectId) {
+      ui.error(`La carpeta no está conectada a Shilo (no tiene .shilo.json): ${abs}`);
+      return null;
+    }
+    folders.add(abs, r.projectId);
+    return [{ dir: abs, projectId: r.projectId }];
+  }
+
+  if (UUID_RE.test(target)) {
+    const t = target.toLowerCase();
+    const matches = entries.filter((e) => e.projectId && e.projectId.toLowerCase().startsWith(t));
+    if (matches.length > 0) return matches; // un proyecto atado en dos carpetas: las dos
+  }
+
+  ui.error(`No encontré "${target}" ni como carpeta ni como proyecto registrado.`);
+  ui.info('Corré "shilo sync" para ver la lista.');
+  return null;
+}
+
+/** ¿Se puede sincronizar? Devuelve `{ remote, problem }`. */
+function checkFolder(entry) {
+  if (!fs.existsSync(entry.dir)) {
+    return { remote: null, problem: 'la carpeta ya no existe ("shilo sync --forget" para sacarla)' };
+  }
+  const r = safeRead(entry.dir);
+  if (!r || !r.projectId) {
+    return { remote: null, problem: 'ya no tiene .shilo.json (¿se desconectó?)' };
+  }
+  if (r.projectId !== entry.projectId) folders.addQuietly(entry.dir, r.projectId);
+  // Sin `base`, el push toma el main actual como base y trata como cambios
+  // todos los archivos locales que difieren: una copia vieja pisaría trabajo
+  // más nuevo (pasó el 2026-10-12). Eso no puede pasar sin que alguien mire.
+  if (!r.base) return { remote: r, problem: NO_BASE };
+  return { remote: r, problem: null };
+}
+
+const NO_BASE =
+  'requiere atención: sin "base" en .shilo.json no sé si está al día. Revisala con ' +
+  '"shilo status" y "shilo diff", y subila a mano una vez con "shilo push" (o "shilo pull" si está atrasada)';
+
+function safeRead(dir) {
+  try {
+    return remote.read(dir);
+  } catch (_) {
+    return null;
+  }
+}
+
+function scan(root) {
+  const abs = path.resolve(root);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${abs}`);
+    return 1;
+  }
+  ui.info(ui.c.dim(`Buscando carpetas conectadas bajo ${abs}…`));
+  const found = folders.scan(abs);
+  let added = 0;
+  for (const f of found) {
+    const isNew = folders.add(f.dir, f.projectId);
+    if (isNew) added++;
+    ui.info(`  ${isNew ? ui.c.green('+') : ui.c.dim('=')} ${f.dir}`);
+  }
+  if (found.length === 0) ui.info('No encontré ninguna carpeta con .shilo.json.');
+  else ui.success(`${found.length} encontrada(s), ${added} nueva(s) en el registro.`);
+  return 0;
+}
+
+function forget(dir) {
+  if (dir === true) {
+    ui.error('Falta la carpeta: shilo sync --forget <carpeta>');
+    return 1;
+  }
+  if (folders.remove(dir)) {
+    ui.success(`Sacada del registro: ${path.resolve(dir)}`);
+    ui.info(ui.c.dim('No se tocó nada en disco; un push o pull futuro la vuelve a registrar.'));
+    return 0;
+  }
+  ui.warn(`No estaba en el registro: ${path.resolve(dir)}`);
+  return 0;
+}
+
+function runChild(argv) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [BIN, ...argv], { stdio: 'inherit' });
+    child.on('error', (e) => {
+      ui.error(`No se pudo lanzar el push: ${e.message}`);
+      resolve(1);
+    });
+    child.on('close', (code) => resolve(typeof code === 'number' ? code : 1));
+  });
+}
+
+function summarize(results, dryRun) {
+  ui.info('');
+  ui.info(ui.c.bold('Resumen del respaldo:'));
+  for (const r of results) {
+    const mark =
+      r.status === 'ok' ? ui.c.green('✓') : r.status === 'salteada' ? ui.c.yellow('!') : ui.c.red('✗');
+    ui.info(`  ${mark} ${r.dir}${r.detail ? ui.c.dim(` — ${r.detail}`) : ''}`);
+  }
+  const ok = results.filter((r) => r.status === 'ok').length;
+  const bad = results.length - ok;
+  const verb = dryRun ? 'revisada(s) (--dry-run: no se subió nada)' : 'respaldada(s)';
+  if (bad === 0) ui.success(`${ok} carpeta(s) ${verb}.`);
+  else ui.warn(`${ok} ${verb}, ${bad} con problemas.`);
+  return bad === 0 ? 0 : 1;
+}
+
+module.exports = sync;

package/src/folders.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Registro local de carpetas conectadas: `~/.shilo/carpetas.json`.
+ *
+ * El servidor conoce los proyectos, pero no en qué carpetas de qué máquina
+ * está atado cada uno: eso sólo lo sabe el disco (cada `.shilo.json`). Este
+ * registro es la lista que `shilo sync --all` recorre (PLAN_SINCRONIZAR, Etapa 1).
+ *
+ * Se llena solo: `remote.write` —el único lugar donde se escribe un
+ * `.shilo.json`, lo usen `init`, `pull` o `push`— registra la carpeta. Las que
+ * se ataron antes de que existiera el registro se suman con `shilo sync --scan`.
+ *
+ * Estructura en disco:
+ * {
+ *   "version": 1,
+ *   "carpetas": [
+ *     { "dir": "C:\\...\\boda", "projectId": "<uuid>", "addedAt": "<ISO>" }
+ *   ]
+ * }
+ *
+ * No guarda credenciales ni el estado de sincronización: el estado vive en el
+ * `.shilo.json` de cada carpeta (`lastSync`), que es la fuente de verdad.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+const remote = require('./remote');
+
+const FILENAME = 'carpetas.json';
+
+// Lo que `--scan` no recorre: pesado y nunca contiene una carpeta atada propia.
+const SCAN_SKIP = new Set(['node_modules', '.git', '.shilo', '.vercel', 'dist', 'build']);
+
+function registryPath() {
+  return path.join(config.configDir(), FILENAME);
+}
+
+/** En Windows y macOS las rutas no distinguen mayúsculas: una carpeta, una entrada. */
+function keyOf(dir) {
+  const abs = path.resolve(dir);
+  return process.platform === 'linux' ? abs : abs.toLowerCase();
+}
+
+function load() {
+  const p = registryPath();
+  if (!fs.existsSync(p)) return [];
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(p, 'utf8').replace(/^/, ''));
+  } catch (e) {
+    throw new Error(`Registro de carpetas corrupto en ${p}: ${e.message}`);
+  }
+  return Array.isArray(raw.carpetas) ? raw.carpetas.filter((c) => c && typeof c.dir === 'string') : [];
+}
+
+function save(list) {
+  fs.mkdirSync(config.configDir(), { recursive: true });
+  const p = registryPath();
+  fs.writeFileSync(p, JSON.stringify({ version: 1, carpetas: list }, null, 2) + '\n', 'utf8');
+  return p;
+}
+
+/**
+ * Registra (o actualiza el proyecto de) una carpeta. Devuelve `true` si era nueva.
+ */
+function add(dir, projectId) {
+  const abs = path.resolve(dir);
+  const list = load();
+  const k = keyOf(abs);
+  const found = list.find((c) => keyOf(c.dir) === k);
+  if (found) {
+    if (projectId && found.projectId !== projectId) {
+      found.projectId = projectId;
+      save(list);
+    }
+    return false;
+  }
+  list.push({ dir: abs, projectId: projectId || null, addedAt: new Date().toISOString() });
+  save(list);
+  return true;
+}
+
+/**
+ * Versión para `remote.write`: registrar nunca puede romper un push o un pull
+ * (config de sólo lectura, registro corrupto, etc.).
+ */
+function addQuietly(dir, projectId) {
+  try {
+    add(dir, projectId);
+  } catch (_) {
+    /* el registro es una comodidad, no un requisito */
+  }
+}
+
+/** Saca una carpeta del registro. Devuelve `true` si estaba. */
+function remove(dir) {
+  const k = keyOf(dir);
+  const list = load();
+  const rest = list.filter((c) => keyOf(c.dir) !== k);
+  if (rest.length === list.length) return false;
+  save(rest);
+  return true;
+}
+
+/**
+ * Busca `.shilo.json` bajo `root` (incluida) hasta `maxDepth` niveles.
+ * No entra en una carpeta atada: un repo de Shilo no contiene otro.
+ * Devuelve `[{ dir, projectId }]`.
+ */
+function scan(root, { maxDepth = 6 } = {}) {
+  const found = [];
+  const walk = (dir, depth) => {
+    let info = null;
+    try {
+      info = remote.read(dir);
+    } catch (_) {
+      /* `.shilo.json` corrupto: no es una carpeta sincronizable */
+    }
+    if (info && info.projectId) {
+      found.push({ dir, projectId: info.projectId });
+      return;
+    }
+    if (depth >= maxDepth) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (_) {
+      return; // sin permiso de lectura
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || SCAN_SKIP.has(e.name)) continue;
+      walk(path.join(dir, e.name), depth + 1);
+    }
+  };
+  walk(path.resolve(root), 0);
+  return found;
+}
+
+module.exports = { registryPath, load, add, addQuietly, remove, scan, keyOf };

package/src/remote.js

@@ -72,6 +72,9 @@ function write(dir, { projectId, baseURL, lastSync, base }) {
   if (lastSync) onDisk.lastSync = lastSync;
   if (base) onDisk.base = base;
   fs.writeFileSync(p, JSON.stringify(onDisk, null, 2) + '\n', 'utf8');
+  // Toda carpeta atada queda en el registro de `shilo sync --all`. Require
+  // perezoso: `folders` ya depende de este módulo.
+  require('./folders').addQuietly(dir, projectId);
   return p;
 }