shilo-cli 0.7.0 → 0.9.0

package/src/commands/push.js

@@ -8,7 +8,10 @@ const prompt = require('../prompt');
 const ui = require('../ui');
 const sync = require('../sync');
 const secrets = require('../secrets');
+const safelist = require('../safelist');
 const pushindex = require('../pushindex');
+const projectconfig = require('../projectconfig');
+const { runChecks } = require('../checks');
 const { walk } = require('../walk');
 const {
   classifyContent,
@@ -36,6 +39,11 @@ const PROPOSAL_MAX_BYTES = 4 * 1024 * 1024; // el server corta en 5 MB; margen
 const HEAD_BYTES = 8192;
 
 // Cuántos ejemplos se muestran por cada motivo de salteo.
+// Techo por campo del bloque `agent` y del prompt (Etapa 4, puntos 1 y 2). El
+// del prompt es el mismo que aplica el servidor: avisar acá ahorra el viaje.
+const AGENT_FIELD_MAX = 200;
+const PROMPT_MAX_BYTES = 64 * 1024;
+
 const SKIP_EXAMPLES = 5;
 // A partir de cuántos salteos en una misma carpeta de primer nivel sugerimos
 // ignorarla entera.
@@ -149,6 +157,61 @@ function preflight(dir) {
   return { uploads, skipped: skips, ignored, gitDirs, findings };
 }
 
+/**
+ * Aplica los selectores de `--only` sobre los archivos que dejó el preflight.
+ *
+ * Cada selector se normaliza con `sync.toRepoPath`, que ya blinda contra salir
+ * de la carpeta, y matchea por igualdad exacta o como prefijo de carpeta
+ * (`Documentacion/` alcanza todo lo de adentro).
+ *
+ * Un selector que no matchea nada es ERROR, no un push silencioso de todo:
+ * confundir "no subí nada de lo que pedí" con "subí el repo entero" es
+ * exactamente el fallo que arruinaría la confianza en el flag.
+ *
+ * Devuelve `{ uploads, leftOut }` o `{ error }`.
+ */
+function selectUploads(dir, allUploads, only) {
+  const selectors = (Array.isArray(only) ? only : only ? [only] : [])
+    .map((s) => String(s).trim())
+    .filter(Boolean);
+
+  if (selectors.length === 0) return { uploads: allUploads, leftOut: [] };
+
+  const normalized = [];
+  for (const raw of selectors) {
+    const repoPath = sync.toRepoPath(dir, raw);
+    if (!repoPath) return { error: `--only "${raw}" queda fuera de la carpeta del push.` };
+    normalized.push({ raw, repoPath });
+  }
+
+  const matched = new Set();
+  const uploads = [];
+  const leftOut = [];
+
+  for (const u of allUploads) {
+    const hit = normalized.find(
+      (s) => u.relPath === s.repoPath || u.relPath.startsWith(`${s.repoPath}/`)
+    );
+    if (hit) {
+      matched.add(hit.repoPath);
+      uploads.push(u);
+    } else {
+      leftOut.push(u);
+    }
+  }
+
+  const misses = normalized.filter((s) => !matched.has(s.repoPath));
+  if (misses.length > 0) {
+    return {
+      error:
+        `--only no encontró nada para: ${misses.map((s) => `"${s.raw}"`).join(', ')}. ` +
+        `Puede estar ignorado, salteado, o escrito distinto; nada se subió.`,
+    };
+  }
+
+  return { uploads, leftOut };
+}
+
 /**
  * Reporte agrupado de salteos. Un repo con un `venv/` adentro generaba miles de
  * líneas "saltado …" que tapaban todo lo demás; acá se resume por motivo, con
@@ -206,23 +269,98 @@ function suggestIgnore(skips) {
   }
 }
 
-/** Muestra los hallazgos de secretos. Nunca imprime el valor detectado. */
-function reportSecrets(findings) {
-  const groups = secrets.groupByFile(findings);
-  ui.error(`Posibles secretos en ${groups.length} archivo(s):`);
-  for (const g of groups) {
-    if (g.name) {
-      ui.info(`  ${ui.c.red('!')} ${g.relPath} ${ui.c.dim(`(coincide con "${g.name}")`)}`);
-    }
-    for (const hit of g.content) {
-      ui.info(`  ${ui.c.red('!')} ${g.relPath}:${hit.line} ${ui.c.dim(`— parece ${hit.label}`)}`);
+/**
+ * Decide qué hacer con los posibles secretos de lo que se va a subir. Nunca
+ * imprime el valor detectado. Devuelve true si el push puede seguir.
+ *
+ * Dos tipos de hallazgo, dos salidas distintas:
+ *   - por NOMBRE (`.env`, `*.pem`…): el archivo entero es de contraseñas, así
+ *     que lo que corresponde es no subirlo → se ofrece sumarlo a `.shiloignore`.
+ *   - por CONTENIDO (una línea parece una clave): puede ser un falso positivo →
+ *     se ofrece marcar esas líneas como seguras, y la decisión queda anotada en
+ *     `.shilo/` para no volver a preguntar mientras la línea no cambie.
+ *
+ * Sin terminal interactiva (o con --yes / --dry-run) no se pregunta nada: se
+ * explica y se frena, como antes.
+ */
+async function resolveSecrets(dir, findings, { interactive }) {
+  const { pending, accepted } = safelist.partition(dir, findings);
+  if (accepted.length > 0) {
+    ui.info(
+      ui.c.dim(
+        `${accepted.length} línea(s) con posibles claves ya las marcaste como seguras antes: se suben.`
+      )
+    );
+  }
+  if (pending.length === 0) return true;
+
+  const byName = pending.filter((f) => f.kind === 'name');
+  const byContent = pending.filter((f) => f.kind === 'content');
+  const nameFiles = [...new Set(byName.map((f) => f.relPath))];
+
+  ui.info('');
+  ui.warn('Antes de subir: encontramos algo que podría ser una contraseña o clave.');
+  if (nameFiles.length > 0) {
+    ui.info('');
+    ui.info('Estos archivos suelen guardar contraseñas, y no conviene subirlos:');
+    for (const p of nameFiles) ui.info(`  ${ui.c.red('!')} ${p}`);
+  }
+  if (byContent.length > 0) {
+    ui.info('');
+    ui.info('Estas líneas parecen claves:');
+    for (const g of secrets.groupByFile(byContent)) {
+      for (const hit of g.content) {
+        ui.info(`  ${ui.c.red('!')} ${g.relPath}:${hit.line} ${ui.c.dim(`— parece ${hit.label}`)}`);
+      }
     }
   }
   ui.info('');
-  ui.info('No se subió nada. Opciones:');
-  ui.info('  · agregar esos archivos a .shiloignore (lo más común)');
-  ui.info('  · sacar el secreto del contenido y volver a intentar');
-  ui.info('  · si es un falso positivo, repetir con --allow-secrets');
+
+  const canAsk = interactive && process.stdin.isTTY;
+  if (!canAsk) {
+    ui.info('No se subió nada. Para seguir:');
+    if (nameFiles.length > 0) {
+      ui.info(`  · Agregá ${nameFiles.length === 1 ? 'ese archivo' : 'esos archivos'} a .shiloignore para no subirlos.`);
+    }
+    if (byContent.length > 0) {
+      ui.info('  · Si esas claves son públicas (están hechas para verse), corré "shilo push" en una');
+      ui.info('    terminal y respondé que sí cuando pregunte: la decisión queda guardada.');
+      ui.info('  · Si son secretas, sacalas del archivo antes de subir.');
+    }
+    return false;
+  }
+
+  if (nameFiles.length > 0) {
+    const ignore = await prompt.confirm(
+      `¿Dejamos ${nameFiles.length === 1 ? 'ese archivo' : `esos ${nameFiles.length} archivos`} afuera ` +
+        '(se agregan a .shiloignore y no se suben nunca)?',
+      true
+    );
+    if (!ignore) {
+      ui.info('No se subió nada. Si de verdad hay que subirlos, usá --allow-secrets (no recomendado).');
+      return false;
+    }
+    if (!safelist.addToShiloignore(dir, nameFiles)) {
+      ui.error('No pudimos escribir .shiloignore. No se subió nada.');
+      return false;
+    }
+    ui.success(`Listo: ${nameFiles.length} archivo(s) agregados a .shiloignore. Volvé a correr "shilo push".`);
+    // El plan ya está armado con esos archivos adentro: rearmarlo acá sería
+    // duplicar el paso 5 entero. Más simple y más claro: frenar y repetir.
+    return false;
+  }
+
+  ui.info('Algunas claves son públicas a propósito (por ejemplo, las que usa una página web para');
+  ui.info('conectarse a su base de datos). Otras dan acceso total y nunca deberían subirse.');
+  const safe = await prompt.confirm('¿Estas son públicas y es seguro subirlas?', false);
+  if (!safe) {
+    ui.info('No se subió nada. Sacá esas claves del archivo (o ignoralo en .shiloignore) y volvé a intentar.');
+    return false;
+  }
+  if (safelist.remember(dir, byContent)) {
+    ui.info(ui.c.dim('Anotado: no te lo volvemos a preguntar por estas líneas mientras no cambien.'));
+  }
+  return true;
 }
 
 /** Todas las carpetas ancestro de un conjunto de rutas de archivo. */
@@ -243,6 +381,7 @@ function neededFolders(relPaths) {
 /**
  * shilo push [carpeta] [--project <uuid>] [-m <msg>] [--dry-run] [--yes]
  *            [--allow-secrets] [--concurrency <n>] [--no-index] [--verbose]
+ *            [--allow-failing-checks]
  *
  * Replica una carpeta local a un repo de Shilo: crea archivos nuevos y actualiza
  * los que cambiaron. Desde la Etapa 3 lo hace como PROPUESTA: el servidor la
@@ -292,8 +431,35 @@ async function push(args) {
     return 1;
   }
 
+  // --deploy sólo agrega el trailer [deploy: …]; quien decide es el servidor
+  // (PLAN_DEPLOY_VERCEL, Etapa 2). Sin --deploy, manda el destino automático.
+  const deploy = parseDeploy(args.deploy);
+  if (deploy === undefined) {
+    ui.error('--deploy tiene que ser prod, preview u off.');
+    return 1;
+  }
+  const trailers = [card && `[card: ${card}]`, deploy && `[deploy: ${deploy}]`].filter(Boolean);
+
+  // Procedencia (Etapa 4, punto 1). Sin --agent no se manda bloque alguno y el
+  // guardado queda como escrito por una persona, que es la verdad.
+  const agent = buildAgent(args);
+  if (agent && agent.error) {
+    ui.error(agent.error);
+    return 1;
+  }
+
+  const promptRead = readPrompt(args, agent);
+  if (promptRead.error) {
+    ui.error(promptRead.error);
+    return 1;
+  }
+  for (const w of promptRead.warnings) ui.warn(w);
+  const promptText = promptRead.prompt;
+
   // 3) PREFLIGHT: todo offline. Recién después de esto se toca la red.
-  const { uploads, skipped, ignored, gitDirs, findings } = preflight(dir);
+  //    `allUploads` es la carpeta entera; `--only` recorta DESPUÉS (ver 3b),
+  //    para que los ignores y el escáner de secretos corran igual siempre.
+  const { uploads: allUploads, skipped, ignored, gitDirs, findings } = preflight(dir);
 
   if (gitDirs.length > 0) {
     ui.warn(
@@ -308,24 +474,27 @@ async function push(args) {
 
   reportSkipped(skipped, { verbose });
 
-  if (findings.length > 0 && !args['allow-secrets']) {
-    ui.info('');
-    reportSecrets(findings);
-    return 1;
-  }
-  if (findings.length > 0) {
-    ui.warn(
-      `${secrets.groupByFile(findings).length} archivo(s) con posibles secretos ` +
-        `se van a subir igual (--allow-secrets).`
-    );
-  }
+  // Los hallazgos de secretos se deciden después de planificar (ver 6b): sólo
+  // importan los archivos que este push va a escribir. Uno que ya está en el
+  // proyecto tal cual no gana nada con frenar el push.
 
-  if (uploads.length === 0) {
+  if (allUploads.length === 0) {
     ui.info('No hay archivos para subir.');
     ui.info(ui.c.dim(`(${ignored} ignorados, ${skipped.length} salteados)`));
     return 0;
   }
 
+  // 3b) `--only`: recorta QUÉ se sube, no qué se mira. El push nunca borra
+  //     archivos remotos (su plan es added/modified/unchanged/failed), así que
+  //     subir un subconjunto es seguro por construcción: no hay semántica nueva.
+  const selection = selectUploads(dir, allUploads, args.only);
+  if (selection.error) {
+    ui.error(selection.error);
+    return 1;
+  }
+  const uploads = selection.uploads;
+  const leftOut = selection.leftOut;
+
   // 4) Cliente + control de ritmo. `onThrottle` baja la concurrencia sola si el
   //    servidor empieza a responder 429, en vez de insistir hasta que corte.
   const limit = sync.resolveConcurrency(args);
@@ -513,9 +682,44 @@ async function push(args) {
 
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  // Con token de acceso personal no sabemos el id del usuario; sólo importa
-  // para reconocer propuestas propias que este push reemplaza.
-  const myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  // Quién soy importa para reconocer propuestas propias que este push
+  // reemplaza. Con token de acceso personal la sesión no trae el id: lo dice el
+  // listado de propuestas (`viewer`). Sin eso, cada push repetido dejaba una
+  // propuesta duplicada al lado de la anterior.
+  let myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  let viewer = null;
+  let projectInfo = null;
+  const noteListing = (listed) => {
+    if (listed.viewer) {
+      viewer = listed.viewer;
+      if (!myId) myId = listed.viewer.id || null;
+    }
+    if (listed.project) projectInfo = listed.project;
+  };
+
+  /**
+   * Si la carpeta coincide entera con la versión actual, anotarlo: fecha de
+   * sincronización y `base`. Sin esto, después de aprobar una propuesta en la
+   * web la carpeta seguía diciendo "última sincronización hace 2 meses" y, peor,
+   * el push siguiente partía de una base vieja y veía como conflicto lo que
+   * eran tus propios cambios ya aplicados.
+   */
+  async function markAlignedIfClean() {
+    if (dryRun || !treeComplete || leftOut.length > 0) return;
+    const isIgnoredPath = sync.makePathMatcher(dir);
+    const localPaths = new Set(allUploads.map((u) => u.relPath));
+    const missing = tree.files.some(
+      (f) => !localPaths.has(f.repoPath) && !isIgnoredPath(f.repoPath)
+    );
+    if (missing) return; // el proyecto tiene cosas que acá no están: no es "igual"
+    try {
+      const listed = await client.listProposals(projectId, await mgr.valid());
+      config.persistCredsIfChanged(cfg, mgr.current);
+      if (listed.main) remote.touchSync(dir, { projectId, baseURL, base: listed.main });
+    } catch (_) {
+      // Best-effort: servidor viejo o sin red. No cambia el resultado del push.
+    }
+  }
 
   // 6) Reporte del plan.
   ui.info('');
@@ -533,16 +737,33 @@ async function push(args) {
       for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
       return 1;
     }
-    if (useIndex && !dryRun) saveIndex(dir, index, plan, uploads);
+    if (useIndex && !dryRun) saveIndex(dir, index, plan, allUploads);
+    await markAlignedIfClean();
     ui.success('Todo al día. Nada para subir.');
+    reportLeftOut(leftOut, remoteByPath);
     return 0;
   }
 
+  // 6b) Secretos: sólo en lo que se va a escribir, y sin lo que la persona ya
+  //     marcó como seguro en esta carpeta.
+  const writing = new Set([...plan.added, ...plan.modified].map((u) => u.relPath));
+  const relevant = findings.filter((f) => writing.has(f.relPath));
+  if (relevant.length > 0 && !args['allow-secrets']) {
+    const ok = await resolveSecrets(dir, relevant, { interactive: !dryRun && !args.yes });
+    if (!ok) return 1;
+  } else if (relevant.length > 0) {
+    ui.warn(
+      `${secrets.groupByFile(relevant).length} archivo(s) con posibles secretos ` +
+        `se van a subir igual (--allow-secrets).`
+    );
+  }
+
   if (dryRun) {
     for (const u of plan.added) ui.info(`  ${ui.c.green('+')} ${u.relPath}`);
     for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}`);
     for (const f of plan.failed) ui.info(`  ${ui.c.red('!')} ${f.relPath} — ${f.reason}`);
     ui.info('');
+    reportLeftOut(leftOut, remoteByPath);
     ui.info(ui.c.dim('(--dry-run: no se subió nada)'));
     return plan.failed.length ? 1 : 0;
   }
@@ -558,6 +779,20 @@ async function push(args) {
     }
   }
 
+  // 7b) Chequeos del proyecto (MU-93): los de `shilo.config.json` de esta
+  //     carpeta. Sin chequeos declarados no se corre nada y el push es el de
+  //     siempre. Si uno falla, no se propone nada salvo --allow-failing-checks:
+  //     entonces la propuesta viaja marcada como fallida y aplicarla exige forzar.
+  const checks = runProjectChecks(dir);
+  if (checks && checks.resultado !== 'ok') {
+    if (!args['allow-failing-checks']) {
+      ui.error('Un chequeo del proyecto falló: no se subió nada.');
+      ui.info(ui.c.dim('Arreglalo y volvé a subir, o usá --allow-failing-checks para proponer igual (queda marcada como fallida).'));
+      return 1;
+    }
+    ui.warn('Un chequeo falló: se propone igual (--allow-failing-checks) y queda marcada como fallida.');
+  }
+
   const pushedAt = Date.now();
 
   /** Log por archivo: en TTY lo tapa la barra de progreso, así que va sólo con --verbose. */
@@ -594,6 +829,7 @@ async function push(args) {
       throw e;
     }
     config.persistCredsIfChanged(cfg, mgr.current);
+    noteListing(listed);
 
     const knownBase = savedRemote && savedRemote.base ? savedRemote.base : null;
     let base = knownBase || listed.main;
@@ -642,6 +878,7 @@ async function push(args) {
     const failedWrites = [];
     const uploaded = [];
     const open = [];
+    const lineMerged = [];
     let applied = 0;
     let appliedCount = 0;
     let stale = 0;
@@ -711,10 +948,15 @@ async function push(args) {
       upProg.update(upDone);
       if (changes.length === 0) continue;
 
-      const title = buildMessage(message, changes.length, toSend.length, bi + 1, batches.length, card);
+      const title = buildMessage(message, changes.length, toSend.length, bi + 1, batches.length, trailers);
       let result;
       try {
-        result = await client.propose(projectId, { base, title, summary: '', changes }, await mgr.valid());
+        result = await client.propose(
+          projectId,
+          { base, title, summary: '', changes, agent, prompt: promptText, card, chequeos: checks },
+          await mgr.valid()
+        );
+        for (const w of result.warnings || []) ui.warn(w);
         config.persistCredsIfChanged(cfg, mgr.current);
       } catch (e) {
         // Una base que el servidor no conoce (proyecto recreado, historial
@@ -740,6 +982,7 @@ async function push(args) {
       } else if (result.applied) {
         applied += sent.length;
         appliedCount += 1;
+        lineMerged.push(...(result.lineas || []));
         for (const u of sent) {
           logFile(upProg, `${u.remote ? ui.c.yellow('~') : ui.c.green('+')} ${u.relPath}`);
         }
@@ -751,7 +994,7 @@ async function push(args) {
     }
     upProg.clear();
 
-    return { failedWrites, committed: applied, commitCount: appliedCount, uploaded, open, stale, main, base };
+    return { failedWrites, committed: applied, commitCount: appliedCount, uploaded, open, stale, main, base, lineMerged };
   }
 
   /**
@@ -1127,11 +1370,11 @@ async function push(args) {
           toUpload.length,
           partNo,
           batches.length,
-          card
+          trailers
         );
         try {
           const creds = await mgr.valid();
-          await client.createCommit(projectId, msg, batchChanges, creds);
+          await client.createCommit(projectId, msg, batchChanges, creds, { card });
           committed += batchChanges.length;
           commitCount += 1;
           config.persistCredsIfChanged(cfg, mgr.current);
@@ -1163,8 +1406,33 @@ async function push(args) {
     );
     outcome = await pushLegacy();
   }
-  const { failedWrites, committed, commitCount, uploaded, open, stale, main } = outcome;
+  const { failedWrites, commitCount, uploaded, open, stale } = outcome;
+  let { committed, main } = outcome;
+  const lineMerged = outcome.lineMerged || [];
+
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 9b) Si quien sube es el dueño, lo que quedó abierto lo puede aplicar ahora
+  //     mismo en vez de ir a la web a aprobarse a sí mismo.
+  const failures = failedWrites.length + plan.failed.length;
+  let openShown = false;
+  if (open.length > 0 && failures === 0 && viewer && viewer.is_owner && !args.yes && process.stdin.isTTY) {
+    const res = await offerOwnerApply(open);
+    if (res.applied.length > 0) {
+      committed += res.applied.reduce((n, o) => n + o.paths.length, 0);
+      if (res.main) main = res.main;
+      for (const o of res.applied) open.splice(open.indexOf(o), 1);
+      lineMerged.push(...res.lineas);
+    }
+  }
 
+  // 9c) Unión por líneas (MU-92): el servidor combinó tu versión con la de otra
+  //     persona. Tu carpeta tiene que quedar con la combinada ANTES de mover la
+  //     base: si no, el push siguiente propondría tu versión sobre la nueva base
+  //     y desharía en silencio el cambio ajeno. Sólo se pisa un archivo que
+  //     sigue byte a byte como se subió; si lo tocaste mientras tanto, queda
+  //     como está y la base no se mueve, así el próximo push lo vuelve a combinar.
+  const broughtIn = await bringLineMerged(lineMerged, uploaded, { client, projectId, mgr, dir });
   config.persistCredsIfChanged(cfg, mgr.current);
 
   // 10) Índice local: lo que subimos bien y lo que ya estaba igual. El próximo
@@ -1175,21 +1443,27 @@ async function push(args) {
     for (const u of uploaded) {
       pushindex.record(index, u, pushedAt);
     }
-    saveIndex(dir, index, plan, uploads, pushedAt);
+    for (const u of broughtIn.written) {
+      pushindex.record(index, u, pushedAt);
+    }
+    saveIndex(dir, index, plan, allUploads, pushedAt);
   }
 
   // 11) Anotar la sincronización y la base nueva. Sólo si TODO quedó en la
   //     versión actual: con archivos fallados o propuestas abiertas, la carpeta
   //     no está alineada, y mover la base haría que el push siguiente proponga
-  //     esos mismos archivos como si nadie más los hubiera tocado.
-  const clean = failedWrites.length === 0 && plan.failed.length === 0 && open.length === 0;
-  if (clean) {
+  //     esos mismos archivos como si nadie más los hubiera tocado. Lo mismo con
+  //     una versión combinada que no se pudo traer (9c).
+  const clean = failures === 0 && open.length === 0;
+  reportLineMerged(broughtIn);
+  if (clean && broughtIn.left.length === 0) {
     remote.touchSync(dir, { projectId, baseURL, base: legacy ? null : main });
   }
 
   // 12) Resumen final.
   ui.info('');
-  for (const o of open) reportOpen(o);
+  reportLeftOut(leftOut, remoteByPath);
+  if (!openShown) for (const o of open) reportOpen(o);
   if (stale > 0) {
     ui.warn(
       `${stale} archivo(s) ya no cambian nada: la versión actual avanzó y lo que tenés ` +
@@ -1204,18 +1478,91 @@ async function push(args) {
     } else {
       ui.success(`Push completo: ${committed} archivo(s) ya son parte de la versión actual.`);
     }
+    if (committed > 0 && deploy !== 'off') await reportDeploy(client, projectId, mgr, cfg);
     return 0;
   }
   for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
-  if (failedWrites.length + plan.failed.length > 0) {
-    ui.warn(`Push con problemas: ${failedWrites.length + plan.failed.length} archivo(s) fallaron.`);
-  } else {
-    ui.warn(
-      `${committed} archivo(s) subieron; ${open.reduce((n, o) => n + o.paths.length, 0)} quedaron en ` +
-        `${open.length} propuesta(s) abierta(s).`
-    );
+  if (failures > 0) {
+    ui.warn(`Push con problemas: ${failures} archivo(s) fallaron.`);
+    return 1;
+  }
+
+  // Quedó todo guardado, pero falta una aprobación. No es un error, y el
+  // mensaje empieza por eso: "0 archivo(s) subieron" se leía como un fallo.
+  const pendingFiles = open.reduce((n, o) => n + o.paths.length, 0);
+  const owner = projectInfo && projectInfo.owner;
+  const ownerName = owner ? owner.display_name || owner.username : null;
+  const approver = viewer && viewer.is_owner ? 'tu aprobación' : ownerName ? `la aprobación de ${ownerName}` : 'la aprobación del dueño del proyecto';
+  ui.success(
+    `Tus ${pendingFiles} cambio(s) están guardados en Shilo y esperan ${approver}.` +
+      (committed > 0 ? ` (Otros ${committed} ya son parte de la versión actual.)` : '')
+  );
+  for (const o of open) {
+    const link = proposalLink(baseURL, projectInfo, o.proposal);
+    if (link) ui.info(`  Revisalos acá: ${ui.c.cyan(link)}`);
+  }
+  // Exit 3 = "guardado, falta aprobar": distinto de 1 (falló algo) para que un
+  // script pueda distinguirlos, y distinto de 0 porque todavía no es la versión actual.
+  return 3;
+
+  /**
+   * Ofrece al dueño aplicar lo que quedó abierto. En los archivos en conflicto
+   * se queda la versión de esta carpeta (`propuesta`), y se dice antes de
+   * preguntar. Devuelve `{ applied: [open...], main }`.
+   */
+  async function offerOwnerApply(list) {
+    const files = list.reduce((n, o) => n + o.paths.length, 0);
+    const conflicted = list.reduce((n, o) => n + o.conflicts.length, 0);
+    ui.info('');
+    for (const o of list) reportOpen(o);
+    openShown = true;
+    ui.info(`Sos el dueño del proyecto: podés aplicar estos ${files} cambio(s) ahora, sin pasar por la web.`);
+    if (conflicted > 0) {
+      ui.info(
+        `En ${conflicted} archivo(s) que también cambiaron en el proyecto se va a quedar ` +
+          `${ui.c.bold('la versión de esta carpeta')}. Lo anterior queda en el historial.`
+      );
+    }
+    const failedChecks = list.some(needsForce);
+    if (failedChecks) {
+      ui.info(`Sus chequeos o piezas ${ui.c.red('fallaron')}: aplicarlos ahora es forzarlos, sabiendo eso.`);
+    }
+    const ok = await prompt.confirm('¿Aplicarlos ahora?', conflicted === 0 && !failedChecks);
+    const out = { applied: [], main: null, lineas: [] };
+    if (!ok) return out;
+    for (const o of list) {
+      if (!o.proposal) continue;
+      const resolutions =
+        o.conflicts.length > 0 ? Object.fromEntries(o.conflicts.map((c) => [c.path, 'propuesta'])) : null;
+      try {
+        const r = await client.resolveProposal(projectId, o.proposal.id, 'apply', await mgr.valid(), {
+          resolutions,
+          force: needsForce(o),
+        });
+        config.persistCredsIfChanged(cfg, mgr.current);
+        if (r.applied) {
+          out.applied.push(o);
+          if (r.main) out.main = r.main;
+          out.lineas.push(...(r.lineas || []));
+        } else {
+          ui.warn(`No se pudo aplicar la propuesta ${o.proposal.id.slice(0, 8)}: ${r.message || 'sigue abierta'}.`);
+        }
+      } catch (e) {
+        ui.warn(`No se pudo aplicar la propuesta ${o.proposal.id.slice(0, 8)}: ${e.message}`);
+      }
+    }
+    ui.info('');
+    return out;
   }
-  return 1;
+}
+
+/**
+ * Link web a una propuesta: `<base>/<usuario>/<proyecto>?propuesta=<id>`.
+ * null si el servidor no dijo la ruta del proyecto (servidor anterior).
+ */
+function proposalLink(baseURL, projectInfo, proposal) {
+  if (!projectInfo || !projectInfo.path || !proposal) return null;
+  return `${baseURL.replace(/\/+$/, '')}${projectInfo.path}?propuesta=${proposal.id.slice(0, 8)}`;
 }
 
 /**
@@ -1240,6 +1587,10 @@ function reportOpen(o) {
               : 'las dos versiones son distintas';
       ui.info(`  ${ui.c.red('!')} ${c.path} ${ui.c.dim(`— ${why}`)}`);
     }
+  } else if (checksFailed(o)) {
+    ui.warn('Los chequeos del proyecto fallaron: la propuesta no se aplica sola, hace falta que el dueño la fuerce.');
+  } else if (piecesFailed(o)) {
+    reportPieces(o.piezas);
   } else if (o.blockedBy.length > 0) {
     ui.warn('Otra propuesta abierta toca los mismos archivos:');
     for (const b of o.blockedBy) {
@@ -1248,15 +1599,104 @@ function reportOpen(o) {
   } else {
     ui.warn(o.message || 'La propuesta quedó abierta.');
   }
-  ui.info(
-    `  Tus ${o.paths.length} archivo(s) no se perdieron: quedaron como propuesta ${ui.c.bold(id)}, ` +
-      'abierta para que el dueño del proyecto decida.'
-  );
-  ui.info(
-    ui.c.dim('  Para resolverlo vos: "shilo pull" trae la versión actual (no pisa lo tuyo sin --force), ') +
-      ui.c.dim('ajustá y volvé a "shilo push".')
-  );
+  ui.info(`  Tus ${o.paths.length} archivo(s) no se perdieron: quedaron guardados como propuesta ${ui.c.bold(id)}.`);
+  ui.info('');
+}
+
+const checksFailed = (o) => Boolean(o.chequeos && o.chequeos.resultado === 'fallido');
+const piecesFailed = (o) => Array.isArray(o.piezas) && o.piezas.length > 0;
+/** Lo que el servidor sólo aplica si el dueño fuerza (MU-93, MU-94). */
+const needsForce = (o) => checksFailed(o) || piecesFailed(o);
+
+/**
+ * Las piezas USEE que dejarían de pasar el Nivel 1 (MU-94), con sus errores.
+ * El detalle completo lo da `verificar.js` sobre la carpeta de la pieza.
+ */
+function reportPieces(piezas) {
+  ui.warn('Estas piezas USEE no pasarían el Nivel 1; la propuesta no se aplica sola, hace falta que el dueño la fuerce:');
+  for (const p of piezas) {
+    const donde = p.raiz || '(raíz del proyecto)';
+    ui.info(`  ${ui.c.red('✗')} ${donde}${p.nueva ? ui.c.dim(' — pieza nueva') : ''}`);
+    for (const e of p.errores) ui.info(ui.c.dim(`      (${e.codigo}) ${e.mensaje}`));
+  }
+}
+
+/**
+ * Corre los chequeos de `shilo.config.json` de la carpeta (MU-93). Devuelve el
+ * resultado que viaja con la propuesta, o null si el proyecto no declara
+ * ninguno (y entonces el push es el de siempre).
+ */
+function runProjectChecks(dir) {
+  let text = null;
+  try {
+    text = fs.readFileSync(path.join(dir, projectconfig.CONFIG_PATH), 'utf8');
+  } catch (_) {
+    return null;
+  }
+  const cfgFile = projectconfig.parseProjectConfig(text);
+  for (const aviso of cfgFile.avisos) ui.warn(aviso);
+  if (cfgFile.chequeos.length === 0) return null;
+
+  ui.info('');
+  const result = runChecks(dir, cfgFile.chequeos, {
+    onStart: (cmd, i, n) => ui.info(ui.c.bold(`Chequeo ${i}/${n}: ${cmd}`)),
+  });
   ui.info('');
+  for (const c of result.comandos) {
+    const mark = c.ok ? ui.c.green('✓') : ui.c.red('✗');
+    const code = c.ok || c.codigo === undefined ? '' : ` (salió con ${c.codigo})`;
+    ui.info(`  ${mark} ${c.comando}${code} ${ui.c.dim(`${(c.ms / 1000).toFixed(1)} s`)}`);
+  }
+  const notRun = cfgFile.chequeos.length - result.comandos.length;
+  if (notRun > 0) ui.info(ui.c.dim(`  ${notRun} chequeo(s) más no se corrieron.`));
+  return result;
+}
+
+/**
+ * Trae a la carpeta las versiones que el servidor combinó por líneas (MU-92).
+ *
+ * Un archivo se pisa sólo si sigue siendo exactamente lo que se subió: la
+ * combinada contiene esos cambios, así que no se pierde nada. Si se tocó
+ * durante el push, o no se pudo leer, queda en `left` y no se escribe.
+ *
+ * @returns {Promise<{ written: Array<{relPath,size,mtimeMs,hash}>, left: string[] }>}
+ */
+async function bringLineMerged(paths, uploaded, { client, projectId, mgr, dir }) {
+  const out = { written: [], left: [] };
+  for (const relPath of [...new Set(paths)]) {
+    const u = uploaded.find((x) => x.relPath === relPath);
+    const absPath = u ? u.absPath : path.join(dir, ...relPath.split('/'));
+    try {
+      const now = fs.readFileSync(absPath);
+      if (!u || pushindex.hashContent(now) !== u.hash) throw new Error('cambió durante el push');
+      const read = await client.readFile(projectId, relPath, await mgr.valid());
+      const content = read.file && read.file.content != null ? read.file.content : null;
+      if (content === null || read.file.is_binary) throw new Error('el servidor no devolvió el texto');
+      fs.writeFileSync(absPath, content, 'utf8');
+      const st = fs.statSync(absPath);
+      out.written.push({ relPath, size: st.size, mtimeMs: st.mtimeMs, hash: pushindex.hashContent(content) });
+    } catch (_) {
+      out.left.push(relPath);
+    }
+  }
+  return out;
+}
+
+function reportLineMerged({ written, left }) {
+  if (written.length > 0) {
+    ui.info(
+      `${written.length} archivo(s) también los había cambiado otra persona, en otras líneas: ` +
+        'se combinaron y tu carpeta ya tiene la versión combinada.'
+    );
+    for (const u of written) ui.info(`  ${ui.c.cyan('≈')} ${u.relPath}`);
+  }
+  if (left.length > 0) {
+    ui.warn(
+      `${left.length} archivo(s) se combinaron con cambios de otra persona, pero no se pudieron traer ` +
+        'a tu carpeta. Tu versión sigue intacta; revisalos con "shilo diff" y el próximo push los vuelve a combinar.'
+    );
+    for (const p of left) ui.info(`  ${ui.c.yellow('≈')} ${p}`);
+  }
 }
 
 /**
@@ -1291,35 +1731,194 @@ async function loadContent(u) {
   return u.content;
 }
 
+/**
+ * Lo que `--only` dejó afuera. "Una pieza = una tarjeta" sólo funciona si la
+ * CLI te recuerda lo que quedó atrás.
+ *
+ * "Cambiado" se decide contra el ÁRBOL REMOTO —falta allá, o está con otro
+ * tamaño—, que es el mismo criterio de `shilo status` y no cuesta un request
+ * extra: el árbol ya se recorrió para planificar. El índice local no sirve acá:
+ * `pull` no lo escribe, así que en una carpeta que se bajó de nuevo queda viejo
+ * y daría por cambiado medio repo.
+ *
+ * Misma concesión que `status`: dos archivos del mismo tamaño se dan por
+ * iguales aunque difieran byte a byte.
+ */
+function reportLeftOut(leftOut, remoteByPath) {
+  if (!leftOut || leftOut.length === 0) return;
+
+  const changed = leftOut.filter((u) => {
+    const r = remoteByPath.get(u.relPath);
+    if (!r) return true; // nunca subido
+    return typeof r.size === 'number' && r.size !== u.size;
+  });
+  if (changed.length === 0) {
+    ui.info(
+      ui.c.dim(
+        `${leftOut.length} archivo(s) quedaron fuera de este push (--only); ninguno tiene cambios sin subir.`
+      )
+    );
+    return;
+  }
+
+  ui.warn(`${changed.length} archivo(s) con cambios locales quedaron fuera de este push (--only):`);
+  for (const u of changed.slice(0, SKIP_EXAMPLES)) ui.info(`      ${ui.c.dim(u.relPath)}`);
+  if (changed.length > SKIP_EXAMPLES) {
+    ui.info(ui.c.dim(`      … y ${changed.length - SKIP_EXAMPLES} más`));
+  }
+}
+
 /**
  * Registra en el índice los archivos que ya estaban idénticos (para no volver a
  * compararlos), saca los que ya no existen y lo escribe.
+ *
+ * `presentUploads` es lo que EXISTE en la carpeta, no lo que se subió en esta
+ * corrida: con `--only` son cosas distintas. Podar con la selección borraría del
+ * índice las entradas del resto del repo, y el push completo siguiente tendría
+ * que recompararlo todo — lento, no incorrecto, pero evitable. Las entradas
+ * nuevas se fusionan sobre el índice ya leído de disco, no lo reemplazan.
  */
-function saveIndex(dir, index, plan, uploads, pushedAt = Date.now()) {
+function saveIndex(dir, index, plan, presentUploads, pushedAt = Date.now()) {
   for (const u of plan.unchanged) {
     if (u.content != null) {
       pushindex.record(index, { ...u, hash: pushindex.hashContent(u.content) }, pushedAt);
     }
   }
-  pushindex.prune(index, new Set(uploads.map((u) => u.relPath)));
+  pushindex.prune(index, new Set(presentUploads.map((u) => u.relPath)));
   pushindex.write(dir, index);
 }
 
 /**
- * Arma el mensaje del commit. Si vino `--card`, se agrega como trailer
- * `[card: <id>]` al final: queda visible en el historial y es fácil de grepear
- * para cruzar un cambio con la tarjeta que lo pidió (Metrónomo u otro tablero).
+ * El bloque `agent` que se declara al proponer, o null si nadie lo declaró.
+ *
+ * `--model` y `--session` sin `--agent` son un error y no un descuido que se
+ * pueda completar solo: decir qué modelo escribió algo sin decir qué
+ * herramienta lo corrió deja una procedencia que no se puede rastrear hasta
+ * ningún lado.
+ */
+function buildAgent(args) {
+  const name = typeof args.agent === 'string' && args.agent.trim() ? args.agent.trim() : null;
+  const model = typeof args.model === 'string' && args.model.trim() ? args.model.trim() : null;
+  const session = typeof args.session === 'string' && args.session.trim() ? args.session.trim() : null;
+
+  if (!name) {
+    if (model || session) {
+      return { error: 'Para declarar procedencia hace falta --agent <nombre>; --model y --session solos no alcanzan.' };
+    }
+    return null;
+  }
+
+  return {
+    name: name.slice(0, AGENT_FIELD_MAX),
+    ...(model ? { model: model.slice(0, AGENT_FIELD_MAX) } : {}),
+    ...(session ? { session_id: session.slice(0, AGENT_FIELD_MAX) } : {}),
+    tool: 'push',
+  };
+}
+
+/**
+ * El prompt que se sube, si quien llama lo pidió explícitamente.
+ *
+ * No se infiere del entorno ni se lee de ningún archivo por convención: un
+ * prompt puede llevar adentro cualquier cosa que alguien haya pegado en su
+ * terminal, y subir eso sin que nadie lo haya decidido es lo mismo que
+ * filtrarlo.
+ *
+ * Un prompt más largo que el techo se descarta con aviso, no se trunca: medio
+ * prompt es peor que ninguno porque parece completo.
+ */
+function readPrompt(args, agent) {
+  const file = typeof args['prompt-file'] === 'string' ? args['prompt-file'].trim() : '';
+  const inline = typeof args.prompt === 'string' ? args.prompt : '';
+
+  if (!file && !inline) return { prompt: null, warnings: [] };
+  if (file && inline) {
+    return { error: 'Elegí uno: --prompt o --prompt-file, no los dos.' };
+  }
+  if (!agent || agent.error) {
+    return { error: 'El prompt se guarda dentro de la procedencia del agente: agregá --agent <nombre>.' };
+  }
+
+  let text = inline;
+  if (file) {
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+      return { error: `No encontramos el archivo del prompt: ${resolved}` };
+    }
+    try {
+      text = fs.readFileSync(resolved, 'utf8');
+    } catch (e) {
+      return { error: `No se pudo leer el prompt: ${e.message}` };
+    }
+  }
+
+  if (!text.trim()) return { prompt: null, warnings: [] };
+
+  const bytes = Buffer.byteLength(text, 'utf8');
+  if (bytes > PROMPT_MAX_BYTES) {
+    return {
+      prompt: null,
+      warnings: [
+        `El prompt pesa ${Math.round(bytes / 1024)} KB y el techo es ` +
+          `${PROMPT_MAX_BYTES / 1024} KB: se guarda el cambio sin él.`,
+      ],
+    };
+  }
+
+  return { prompt: text, warnings: [] };
+}
+
+/**
+ * Arma el mensaje del commit. Los trailers (`[card: <id>]` de `--card`,
+ * `[deploy: …]` de `--deploy`) van al final: quedan visibles en el historial,
+ * se grepean fácil para cruzar un cambio con la tarjeta que lo pidió, y el
+ * servidor lee `[deploy: …]` para elegir el destino del deploy.
  * El backend corta en 500 caracteres, así que recortamos el mensaje del usuario
- * antes que el trailer.
+ * antes que los trailers.
+ *
+ * Desde la Etapa 4 la tarjeta viaja ADEMÁS aparte, en `provenance.card`, que es
+ * lo que se puede consultar (`GET /api/commits/<id>?card=…`). El trailer no se
+ * saca ni se va a sacar: es el formato de todo lo ya guardado, y la procedencia
+ * entra en el oid del commit, así que lo viejo no se puede completar.
  */
-function buildMessage(userMsg, batchCount, total, partNo, nBatches, card) {
+function buildMessage(userMsg, batchCount, total, partNo, nBatches, trailers = []) {
   let base = userMsg || `shilo push: ${total} archivo(s)`;
   if (nBatches > 1) base = `${base} (${partNo}/${nBatches})`;
-  if (!card) return base.slice(0, 500);
+  if (!trailers.length) return base.slice(0, 500);
+
+  const tail = ` ${trailers.join(' ')}`;
+  const room = 500 - tail.length;
+  return `${base.slice(0, room)}${tail}`;
+}
 
-  const trailer = ` [card: ${card}]`;
-  const room = 500 - trailer.length;
-  return `${base.slice(0, room)}${trailer}`;
+/** `--deploy` → 'prod' | 'preview' | 'off'; null si no vino; undefined si es inválido. */
+function parseDeploy(raw) {
+  if (raw === undefined || raw === null || raw === false) return null;
+  const v = String(raw).trim().toLowerCase();
+  if (v === 'prod' || v === 'production') return 'prod';
+  if (v === 'preview' || v === 'off') return v;
+  return undefined;
+}
+
+/**
+ * Después de un push que cambió algo: si el proyecto despliega a Vercel, avisa
+ * que el deploy quedó en cola. Nunca hace fallar el push — un servidor sin
+ * deploys o un error de red sólo se callan.
+ */
+async function reportDeploy(client, projectId, mgr, cfg) {
+  try {
+    const info = await client.getDeploys(projectId, await mgr.valid());
+    if (info.target && info.connected) {
+      ui.info(ui.c.dim('Deploy en cola → "shilo deploys" para ver el estado.'));
+    }
+  } catch {
+    // sin deploys en el servidor, o sin red: no es asunto del push
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
 }
 
 module.exports = push;
+// Para los tests de backend/utils/__tests__/pushLineMerged.test.js.
+module.exports.bringLineMerged = bringLineMerged;
+module.exports.runProjectChecks = runProjectChecks;