shilo-cli 0.8.0 → 0.9.0

package/src/commands/status.js

@@ -6,19 +6,29 @@ const sync = require('../sync');
 const remote = require('../remote');
 const { resolveContext } = require('../context');
 
+// A partir de cuántos días sin sincronizar se recuerda hacerlo.
+const STALE_DAYS = 30;
+
 /**
  * shilo status [carpeta] [--project <uuid>] [--base-url <url>] [--short] [--json]
  *
- * Comando de sólo lectura: compara la carpeta local contra el remoto SIN bajar
- * contenido y sin escribir nada, ni local ni remoto. Contesta las dos preguntas
- * que uno se hace antes de arrancar a trabajar:
+ * Compara la carpeta local contra el remoto SIN bajar contenido y sin escribir
+ * nada en el servidor. Contesta las preguntas que uno se hace antes de arrancar
+ * a trabajar:
  *
  *   - ¿el remoto tiene cambios que no tengo? (y de quién son)
  *   - ¿tengo cambios locales sin subir?
+ *   - ¿hay algo mío esperando aprobación?
+ *
+ * La comparación es por ruta + tamaño (un listado por carpeta, cero descargas)
+ * y, cuando el tamaño coincide, por el SHA-256 que el remoto publica en el
+ * listado (`sync.refineByHash`): sigue sin bajar nada.
  *
- * La comparación es por ruta + tamaño (un listado por carpeta, cero descargas).
- * Dos archivos del mismo tamaño se reportan como "iguales" aunque su contenido
- * pudiera diferir: para confirmar byte a byte están `shilo diff` y `push`.
+ * Lo único que escribe es `.shilo.json`, y sólo cuando la carpeta coincide
+ * entera con la versión actual: ahí anota la fecha y la `base`. Es el caso de
+ * una propuesta aprobada en la web, que si no dejaba "Al día" al lado de
+ * "última sincronización hace 2 meses" y al push siguiente partiendo de una
+ * base vieja.
  */
 async function status(args) {
   const ctx = resolveContext(args);
@@ -52,8 +62,25 @@ async function status(args) {
   const attribution = await sync.buildAuthorIndex(client, projectId, mgr, { commits: 50 });
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  const me = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
-  const cmp = sync.compareTrees(local.files, tree.files);
+  // 2b) Propuestas abiertas (best-effort: un servidor viejo no las tiene). De
+  //     paso dicen quién soy —con token personal la sesión no lo trae—, si soy
+  //     el dueño, y cuál es la versión actual.
+  let listed = null;
+  try {
+    listed = await client.listProposals(projectId, await mgr.valid(), { state: 'abierta' });
+    config.persistCredsIfChanged(cfg, mgr.current);
+  } catch (_) {
+    listed = null;
+  }
+  const viewer = (listed && listed.viewer) || null;
+
+  const me =
+    cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : viewer ? viewer.id : null;
+  const cmp = sync.refineByHash(sync.compareTrees(local.files, tree.files), {
+    dir,
+    projectId,
+    baseURL,
+  });
 
   // 3) "Detrás del remoto" = lo que otro subió y yo no tengo igual: archivos
   //    que faltan localmente, o que difieren y cambiaron después de mi lastSync.
@@ -99,6 +126,34 @@ async function status(args) {
     };
   };
 
+  // 4b) Propuestas abiertas: las mías (esperan aprobación) y, si soy el dueño,
+  //     las de los demás (esperan mi decisión).
+  const openProposals = listed ? listed.proposals : [];
+  const mineOpen = me ? openProposals.filter((p) => p.author_id === me) : [];
+  const othersOpen = viewer && viewer.is_owner ? openProposals.filter((p) => p.author_id !== me) : [];
+  const projectInfo = (listed && listed.project) || null;
+  const owner = projectInfo && projectInfo.owner;
+  const ownerName = owner ? owner.display_name || owner.username : null;
+  const linkTo = (p) =>
+    projectInfo && projectInfo.path
+      ? `${baseURL.replace(/\/+$/, '')}${projectInfo.path}?propuesta=${p.id.slice(0, 8)}`
+      : null;
+
+  // 4c) Carpeta idéntica a la versión actual → anotarlo (ver cabecera).
+  const aligned = behind.length === 0 && ahead.length === 0 && tree.errors.length === 0;
+  let syncedAt = lastSync;
+  if (aligned && listed && listed.main) {
+    const stale = !savedRemote || savedRemote.base !== listed.main || !lastSync;
+    if (stale && remote.touchSync(dir, { projectId, baseURL, base: listed.main })) {
+      syncedAt = new Date().toISOString();
+    }
+  }
+
+  // 4d) Hace cuánto que esta carpeta no se alinea con el proyecto.
+  const daysSinceSync = syncedAt
+    ? Math.floor((Date.now() - new Date(syncedAt).getTime()) / 86400000)
+    : null;
+
   if (asJson) {
     console.log(
       JSON.stringify(
@@ -106,7 +161,9 @@ async function status(args) {
           projectId,
           baseURL,
           dir,
-          lastSync: lastSync || null,
+          lastSync: syncedAt || null,
+          pendingProposals: mineOpen.map((p) => ({ id: p.id, title: p.title, createdAt: p.created_at, url: linkTo(p) })),
+          awaitingMyDecision: othersOpen.map((p) => ({ id: p.id, title: p.title, url: linkTo(p) })),
           remoteFiles: tree.files.length,
           localFiles: local.files.length,
           behind: behind.map((i) => ({ path: i.repoPath, kind: i.kind, lastCommit: decorate(i) })),
@@ -130,8 +187,8 @@ async function status(args) {
   }
 
   ui.info('');
-  if (lastSync) {
-    ui.info(ui.c.dim(`Última sincronización de esta carpeta: ${sync.formatDate(lastSync)}`));
+  if (syncedAt) {
+    ui.info(ui.c.dim(`Última sincronización de esta carpeta: ${sync.formatDate(syncedAt)}`));
   } else {
     ui.info(
       ui.c.dim(
@@ -157,8 +214,35 @@ async function status(args) {
     ui.info('');
   };
 
+  /** Propuestas abiertas: lo primero que hay que saber, antes que la lista de archivos. */
+  const reportProposals = () => {
+    if (mineOpen.length > 0) {
+      const who = viewer && viewer.is_owner ? 'tu aprobación' : ownerName ? `la aprobación de ${ownerName}` : 'aprobación';
+      ui.info(ui.c.bold(`Tenés ${mineOpen.length} propuesta(s) esperando ${who}:`));
+      for (const p of mineOpen) {
+        const link = linkTo(p);
+        ui.info(
+          `  ${ui.c.yellow('⧗')} ${p.title || p.id.slice(0, 8)} ${ui.c.dim(`— ${sync.formatDate(p.created_at)}`)}` +
+            (link ? `\n    ${ui.c.cyan(link)}` : '')
+        );
+      }
+      ui.info('');
+    }
+    if (othersOpen.length > 0) {
+      ui.info(ui.c.bold(`${othersOpen.length} propuesta(s) de otras personas esperan tu decisión:`));
+      for (const p of othersOpen) {
+        const by = p.author ? p.author.display_name || p.author.username : 'alguien';
+        const link = linkTo(p);
+        ui.info(`  ${ui.c.yellow('⧗')} ${p.title || p.id.slice(0, 8)} ${ui.c.dim(`— de ${by}`)}` + (link ? `\n    ${ui.c.cyan(link)}` : ''));
+      }
+      ui.info('');
+    }
+  };
+
+  reportProposals();
+
   if (behind.length === 0 && ahead.length === 0) {
-    ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el remoto.`);
+    ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el proyecto.`);
     ui.info('');
     reportIgnored();
     return 0;
@@ -182,7 +266,10 @@ async function status(args) {
   }
 
   if (ahead.length > 0) {
-    ui.info(ui.c.bold(`Tenés ${ahead.length} cambio(s) local(es) sin subir:`));
+    ui.info(
+      ui.c.bold(`Tenés ${ahead.length} cambio(s) local(es) que todavía no son parte del proyecto`) +
+        (mineOpen.length > 0 ? ui.c.bold(' (pueden estar en tu propuesta pendiente):') : ui.c.bold(':'))
+    );
     for (const item of ahead) {
       const mark = item.kind === 'nuevo local' ? ui.c.green('+') : ui.c.yellow('~');
       ui.info(`  ${mark} ${item.repoPath}`);
@@ -194,7 +281,7 @@ async function status(args) {
 
   ui.info(
     ui.c.dim(
-      `  ${cmp.same.length} sin cambios (por tamaño)   ` +
+      `  ${cmp.same.length} sin cambios   ` +
         `${local.ignored} ignorados   ${local.skipped.length} saltados`
     )
   );
@@ -211,10 +298,21 @@ async function status(args) {
     ui.info(ui.c.dim('Mirá "shilo diff <archivo>" antes de decidir.'));
   } else if (behind.length > 0) {
     ui.info(ui.c.dim('Sugerido: "shilo pull --dry-run" para ver qué bajaría.'));
+  } else if (mineOpen.length > 0) {
+    ui.info(ui.c.dim('Tus cambios ya están guardados: falta que se apruebe la propuesta de arriba.'));
   } else {
     ui.info(ui.c.dim('Sugerido: "shilo push --dry-run" para ver qué subiría.'));
   }
 
+  // Recordatorio: sincronizar seguido da propuestas chicas y fáciles de revisar.
+  if (ahead.length > 0 && daysSinceSync !== null && daysSinceSync >= STALE_DAYS) {
+    ui.info('');
+    ui.warn(
+      `Hace ${daysSinceSync} días que esta carpeta no se sincroniza. Subí seguido: ` +
+        'cuanto más chico el cambio, más fácil de revisar y menos choques con lo de otros.'
+    );
+  }
+
   // Exit code 2 = "estás desactualizado". Útil para encadenar en scripts:
   // `shilo status || echo "bajá antes de trabajar"`.
   return behind.length > 0 ? 2 : 0;

package/src/projectconfig.js

@@ -0,0 +1,76 @@
+/**
+ * `shilo.config.json` del lado del CLI (EP-S2): **espejo** de
+ * `backend/utils/projectConfig.js`, que es donde está explicado el porqué.
+ * El CLI no puede importar del backend; `backend/utils/__tests__/projectConfig.test.js`
+ * corre los dos sobre las mismas entradas para que no se separen.
+ *
+ * El CLI la lee de la carpeta local: los chequeos (MU-93) se corren antes de
+ * proponer, con lo que hay en disco.
+ */
+
+'use strict';
+
+const CONFIG_PATH = 'shilo.config.json';
+const UNIONES = ['archivo', 'lineas'];
+const MAX_CHEQUEOS = 10;
+const MAX_COMANDO = 500;
+
+/** Los comandos válidos de `chequeos`, anotando en `avisos` lo que se ignora. */
+function parseChequeos(raw, avisos) {
+  if (!Array.isArray(raw)) {
+    avisos.push('"chequeos" debe ser una lista de comandos');
+    return [];
+  }
+  const out = [];
+  for (const cmd of raw) {
+    if (typeof cmd !== 'string' || !cmd.trim() || cmd.length > MAX_COMANDO) {
+      avisos.push('Se ignoró un chequeo que no es un comando de texto');
+    } else if (out.length >= MAX_CHEQUEOS) {
+      avisos.push(`Más de ${MAX_CHEQUEOS} chequeos: se ignoran los demás`);
+      break;
+    } else {
+      out.push(cmd.trim());
+    }
+  }
+  return out;
+}
+
+/** El objeto de `shilo.config.json`, o null con el aviso de por qué no. */
+function parseObject(text, avisos) {
+  let raw;
+  try {
+    const clean = String(text);
+    // Sin BOM: JSON.parse no lo acepta y algunos editores de Windows lo ponen.
+    raw = JSON.parse(clean.charCodeAt(0) === 0xfeff ? clean.slice(1) : clean);
+  } catch (err) {
+    avisos.push(`${CONFIG_PATH} no es JSON válido: se usan los valores por defecto`);
+    return null;
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    avisos.push(`${CONFIG_PATH} debe ser un objeto: se usan los valores por defecto`);
+    return null;
+  }
+  return raw;
+}
+
+/**
+ * @param {string|null|undefined} text - contenido de `shilo.config.json`
+ * @returns {{ union: 'archivo'|'lineas', chequeos: string[], avisos: string[] }}
+ */
+function parseProjectConfig(text) {
+  const config = { union: 'archivo', chequeos: [], avisos: [] };
+  if (text === null || text === undefined || String(text).trim() === '') return config;
+
+  const raw = parseObject(text, config.avisos);
+  if (!raw) return config;
+
+  if (raw.union !== undefined) {
+    if (UNIONES.includes(raw.union)) config.union = raw.union;
+    else config.avisos.push(`"union" debe ser ${UNIONES.join(' o ')}: se usa "archivo"`);
+  }
+  if (raw.chequeos !== undefined) config.chequeos = parseChequeos(raw.chequeos, config.avisos);
+
+  return config;
+}
+
+module.exports = { CONFIG_PATH, UNIONES, MAX_CHEQUEOS, parseProjectConfig };

package/src/safelist.js

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Decisiones "esto no es un secreto" que la persona ya tomó en esta carpeta.
+ *
+ * Vive en `.shilo/secretos-seguros.json` (`.shilo/` está en los ignores por
+ * defecto: nunca se sube). Guarda la huella de la LÍNEA (ver
+ * `secrets.fingerprintOf`), nunca el valor: si la línea cambia, la huella deja
+ * de coincidir y se vuelve a preguntar. Así no hace falta `--allow-secrets` en
+ * cada push, y esa bandera —que apaga todos los avisos, también los reales—
+ * queda para casos excepcionales.
+ *
+ * {
+ *   "version": 1,
+ *   "seguros": [{ "path": "src/supabase.js", "fingerprint": "<sha256>", "label": "...", "at": "<ISO>" }]
+ * }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const FILE = path.join('.shilo', 'secretos-seguros.json');
+
+function load(dir) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(dir, FILE), 'utf8'));
+    return Array.isArray(raw.seguros) ? raw.seguros : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+const keyOf = (p, fp) => `${p}\n${fp}`;
+
+/**
+ * Separa los hallazgos ya marcados como seguros de los que siguen pendientes.
+ * Sólo los de contenido se pueden marcar: un `.env` no se "aprueba", se ignora.
+ */
+function partition(dir, findings) {
+  const known = new Set(load(dir).map((e) => keyOf(e.path, e.fingerprint)));
+  const pending = [];
+  const accepted = [];
+  for (const f of findings) {
+    if (f.kind === 'content' && f.fingerprint && known.has(keyOf(f.relPath, f.fingerprint))) {
+      accepted.push(f);
+    } else {
+      pending.push(f);
+    }
+  }
+  return { pending, accepted };
+}
+
+/** Anota hallazgos de contenido como seguros. Devuelve false si no pudo escribir. */
+function remember(dir, findings) {
+  const list = load(dir);
+  const known = new Set(list.map((e) => keyOf(e.path, e.fingerprint)));
+  const at = new Date().toISOString();
+  for (const f of findings) {
+    if (f.kind !== 'content' || !f.fingerprint) continue;
+    const k = keyOf(f.relPath, f.fingerprint);
+    if (known.has(k)) continue;
+    known.add(k);
+    list.push({ path: f.relPath, fingerprint: f.fingerprint, label: f.label, at });
+  }
+  try {
+    fs.mkdirSync(path.join(dir, '.shilo'), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, FILE),
+      JSON.stringify({ version: 1, seguros: list }, null, 2) + '\n',
+      'utf8'
+    );
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Agrega rutas a `.shiloignore` (lo crea si no existe). Devuelve false si no
+ * pudo escribir.
+ */
+function addToShiloignore(dir, relPaths) {
+  const p = path.join(dir, '.shiloignore');
+  try {
+    const current = fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+    const lines = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    const add = relPaths.map((r) => `/${r}`).filter((r) => !lines.has(r));
+    if (add.length === 0) return true;
+    const sep = current && !current.endsWith('\n') ? '\n' : '';
+    fs.writeFileSync(
+      p,
+      `${current}${sep}# Agregado por shilo push: posibles contraseñas\n${add.join('\n')}\n`,
+      'utf8'
+    );
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+module.exports = { FILE, load, partition, remember, addToShiloignore };

package/src/secrets.js

@@ -17,6 +17,8 @@
  * NUNCA se imprime el valor detectado, sólo archivo, línea y qué parece ser.
  */
 
+const crypto = require('crypto');
+
 // Patrones de nombre (mismo subconjunto glob que .gitignore, sobre el basename).
 const DENY_NAMES = [
   '.env',
@@ -75,6 +77,57 @@ function deniedByName(relPath) {
   return null;
 }
 
+const JWT_RE = /\bey[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/;
+const JWT_RE_ALL = new RegExp(JWT_RE.source, 'g');
+
+/**
+ * Qué es un JWT según su payload, sin verificar la firma (no hace falta: sólo
+ * se decide si avisar). Supabase pone el rol ahí:
+ *
+ *   - `anon`         la clave pública: está hecha para ir en el navegador.
+ *   - `service_role` la que saltea todas las reglas de acceso: secreta.
+ *
+ * Devuelve 'public', 'secret' o null (no se pudo leer, u otro JWT).
+ */
+function classifyJwt(token) {
+  const part = token.split('.')[1];
+  if (!part) return null;
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+  } catch (_) {
+    return null;
+  }
+  if (!payload || typeof payload !== 'object') return null;
+  if (payload.role === 'anon') return 'public';
+  if (payload.role === 'service_role') return 'secret';
+  return null;
+}
+
+/**
+ * La etiqueta del primer JWT de la línea que valga la pena avisar, o null si
+ * todos son claves públicas conocidas.
+ */
+function jwtLabel(line) {
+  let label = null;
+  for (const m of line.matchAll(JWT_RE_ALL)) {
+    const kind = classifyJwt(m[0]);
+    if (kind === 'public') continue;
+    if (kind === 'secret') return 'clave service_role de Supabase (secreta)';
+    label = 'token de Supabase / JWT';
+  }
+  return label;
+}
+
+/**
+ * Huella de una línea con un posible secreto: permite recordar "esto ya me
+ * dijeron que es seguro" sin guardar el valor. Si la línea cambia, la huella
+ * cambia y se vuelve a preguntar.
+ */
+function fingerprintOf(line) {
+  return crypto.createHash('sha256').update(line.trim(), 'utf8').digest('hex');
+}
+
 /**
  * Formas de credencial reconocibles por su prefijo/estructura. Se apunta a
  * precisión razonable: prefijos propietarios y claves PEM, no "cualquier string
@@ -88,7 +141,8 @@ const CONTENT_PATTERNS = [
   { label: 'clave de API de Google', re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
   { label: 'token de Slack', re: /\bxox[abprs]-[0-9A-Za-z-]{10,}/ },
   { label: 'clave de Stripe', re: /\b[sr]k_live_[0-9A-Za-z]{20,}/ },
-  { label: 'token de Supabase / JWT', re: /\bey[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
+  { label: 'clave secreta de Supabase', re: /\bsb_secret_[A-Za-z0-9_-]{20,}/ },
+  { label: 'token de Supabase / JWT', re: JWT_RE, jwt: true },
   { label: 'clave privada PEM', re: /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/ },
   { label: 'token de acceso personal de Shilo', re: /\bshilo_pat_[A-Za-z0-9_-]{20,}/ },
   { label: 'contraseña en una URL', re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]{6,}@/i },
@@ -99,7 +153,8 @@ const CONTENT_PATTERNS = [
 const SCAN_BYTES = 8192;
 
 /**
- * Escanea un fragmento de texto. Devuelve `[{ line, label }]` — sin el valor.
+ * Escanea un fragmento de texto. Devuelve `[{ line, label, fingerprint }]` —
+ * sin el valor.
  */
 function scanText(text) {
   const hits = [];
@@ -107,11 +162,14 @@ function scanText(text) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line.length > 4000) continue; // minificado/base64: ruido, no señal
-    for (const { label, re } of CONTENT_PATTERNS) {
-      if (re.test(line)) {
-        hits.push({ line: i + 1, label });
-        break; // un hallazgo por línea alcanza para avisar
-      }
+    for (const { label, re, jwt } of CONTENT_PATTERNS) {
+      if (!re.test(line)) continue;
+      // La clave `anon` de Supabase es pública por diseño. Avisar por ella
+      // empujaba a usar --allow-secrets, que apaga también los avisos reales.
+      const finalLabel = jwt ? jwtLabel(line) : label;
+      if (!finalLabel) continue;
+      hits.push({ line: i + 1, label: finalLabel, fingerprint: fingerprintOf(line) });
+      break; // un hallazgo por línea alcanza para avisar
     }
   }
   return hits;
@@ -132,7 +190,13 @@ function inspect(relPath, head) {
 
   if (typeof head === 'string' && head) {
     for (const hit of scanText(head.slice(0, SCAN_BYTES))) {
-      findings.push({ relPath, kind: 'content', line: hit.line, label: hit.label });
+      findings.push({
+        relPath,
+        kind: 'content',
+        line: hit.line,
+        label: hit.label,
+        fingerprint: hit.fingerprint,
+      });
     }
   }
 
@@ -151,7 +215,7 @@ function groupByFile(findings) {
     }
     const entry = byPath.get(f.relPath);
     if (f.kind === 'name') entry.name = f.pattern;
-    else entry.content.push({ line: f.line, label: f.label });
+    else entry.content.push({ line: f.line, label: f.label, fingerprint: f.fingerprint });
   }
   return [...byPath.values()];
 }
@@ -162,6 +226,8 @@ module.exports = {
   CONTENT_PATTERNS,
   SCAN_BYTES,
   deniedByName,
+  classifyJwt,
+  fingerprintOf,
   scanText,
   inspect,
   groupByFile,

package/src/sync.js

@@ -6,7 +6,7 @@
  * cambios a partir del historial de commits.
  *
  * Todo lo de acá es de sólo lectura: ninguna función escribe en disco ni en el
- * servidor. La idea es que un `shilo status` pueda contestar "¿estoy
+ * servidor (`refineByHash` lee archivos locales, nada más). La idea es que un `shilo status` pueda contestar "¿estoy
  * desactualizado?" sin bajar contenido.
  */
 
@@ -14,6 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const config = require('./config');
 const { walk, makePathMatcher } = require('./walk');
+const pushindex = require('./pushindex');
 
 const CONCURRENCY = 8; // pool para el N+1 de listar carpetas (el backend no tiene árbol recursivo)
 const MAX_CONCURRENCY = 32;
@@ -231,7 +232,7 @@ function walkLocal(dir) {
   const { files, skipped, ignored } = walk(dir);
   return {
     files: files
-      .map((f) => ({ repoPath: f.relPath, absPath: f.absPath, size: f.size }))
+      .map((f) => ({ repoPath: f.relPath, absPath: f.absPath, size: f.size, mtimeMs: f.mtimeMs }))
       .sort((a, b) => a.repoPath.localeCompare(b.repoPath)),
     skipped,
     ignored,
@@ -241,8 +242,8 @@ function walkLocal(dir) {
 /**
  * Compara los dos árboles por ruta y tamaño. NO baja contenido: por eso un
  * archivo con el mismo tamaño en ambos lados cae en `same` aunque su contenido
- * pudiera diferir (mismo largo, distinto texto). Esa es la concesión que hace
- * que `status` sea barato; `diff` y `push` sí confirman byte a byte.
+ * pudiera diferir (mismo largo, distinto texto). `refineByHash` lo confirma
+ * por contenido sin bajar nada; `diff` y `push` comparan byte a byte.
  *
  * Devuelve:
  *   {
@@ -285,6 +286,52 @@ function compareTrees(localFiles, remoteFiles) {
   return { onlyLocal, onlyRemote, differing, same };
 }
 
+/**
+ * Confirma por contenido los `same` de `compareTrees`: cambiar un número por
+ * otro deja el archivo del mismo tamaño, y sólo por tamaño pasaba como "sin
+ * cambios". El remoto publica el SHA-256 en el listado (`content_hash`), así que
+ * esto sigue sin bajar nada: sólo lee archivos locales, y ni eso si el índice
+ * del push (`.shilo/index.json`) dice que el archivo está intacto y su hash ya
+ * coincidía.
+ *
+ * Muta y devuelve `cmp`: lo que difiere pasa de `same` a `differing`. Un
+ * remoto sin hash (anterior a la migración 010) o un archivo ilegible quedan
+ * como estaban.
+ */
+function refineByHash(cmp, { dir, projectId, baseURL } = {}) {
+  const index = dir ? pushindex.read(dir, { projectId, baseURL }) : { entries: {} };
+
+  const same = [];
+  for (const item of cmp.same) {
+    const hash = item.remote && item.remote.content_hash;
+    if (!hash) {
+      same.push(item);
+      continue;
+    }
+    const { fresh, entry } = pushindex.isFresh(index, {
+      relPath: item.repoPath,
+      size: item.local.size,
+      mtimeMs: item.local.mtimeMs,
+    });
+    if (fresh && entry && entry.hash === hash) {
+      same.push(item);
+      continue;
+    }
+    let localHash;
+    try {
+      localHash = pushindex.hashContent(fs.readFileSync(item.local.absPath));
+    } catch (_) {
+      same.push(item);
+      continue;
+    }
+    if (localHash === hash) same.push(item);
+    else cmp.differing.push(item);
+  }
+  cmp.same = same;
+  cmp.differing.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
+  return cmp;
+}
+
 /**
  * Baja las últimas páginas del historial con sus archivos y arma un índice
  * `file_id -> { message, author, date, hash, action }` con el commit MÁS
@@ -413,6 +460,7 @@ module.exports = {
   // ignores que `walkLocal` aplica al local, sin importar `walk.js` aparte.
   makePathMatcher,
   compareTrees,
+  refineByHash,
   buildAuthorIndex,
   describeAuthor,
   formatDate,