@@ -73,8 +73,10 @@ xterm una sola vez y `useTerminalSocket` lleva el WebSocket.
   servidores y personas por día.
 - **Buscar en lo que ya pasó.** `Ctrl+Shift+F` abre la búsqueda sobre el
   historial de esa shell, con las coincidencias resaltadas.
-- **La cabecera dice cuánto tarda la red.** Junto a «Conectado», la ida y
-  vuelta de la última tecla, en tramos de 10 ms.
+- **La cabecera dice cuánto tarda la red.** Un ping cada dos segundos, y se
+  muestra el mínimo de los últimos cinco: el ruido del navegador solo suma.
+  Medir el eco de las teclas daba números falsos, porque el que llega suele
+  ser el de la tecla anterior.
 - **Arrastrar un archivo lo sube donde está parado.** El destino sale del
   `cd` de la shell, leído de lo que anuncia (OSC 7) o de su prompt; si no se
   sabe, la carpeta de trabajo de la credencial. Viaja en tramos por el mismo
@@ -99,6 +101,8 @@ xterm una sola vez y `useTerminalSocket` lleva el WebSocket.
   disimular; Enter tampoco la borra, que hacía parpadear la línea entera al
   enviarla. En vim o htop no adivina, y si la shell deja de repetir lo
   tecleado —pide una contraseña— borra lo adelantado y deja de adivinar.
+  Al borrar con retroceso tampoco se adelanta nada: el servidor hará eco de
+  la letra y mandará su propio borrado.
 
 ## Cabeceras de seguridad
 
 
@@ -37,12 +37,16 @@ export type MensajeDeCarpetas = {
   error?: string
 }
 
+/** Respuesta al ping: con su número se mide la ida y vuelta de verdad. */
+export type MensajeDePong = { type: 'pong'; ping: number }
+
 /** La shell vive en el servidor: su id permite volver a ella tras un corte. */
 export type MensajeEntrante =
   | { type: 'output' | 'error'; message: string }
   | { type: 'sesion'; id: string }
   | MensajeDeSubida
   | MensajeDeCarpetas
+  | MensajeDePong
 
 /** Token en la query: el handshake del navegador no admite cabeceras.
  *  Dura 30 minutos y produccion exige wss. Con `sesion`, retoma la shell
@@ -158,6 +162,7 @@ export function parseIncoming(raw: string): MensajeEntrante | null {
       id?: string
       estado?: string
       error?: string
+      ping?: number
       ruta?: string
       inicio?: string
       padre?: string
@@ -167,6 +172,9 @@ export function parseIncoming(raw: string): MensajeEntrante | null {
     if (dato.type === 'sesion') {
       return typeof dato.id === 'string' ? { type: 'sesion', id: dato.id } : null
     }
+    if (dato.type === 'pong') {
+      return typeof dato.ping === 'number' ? { type: 'pong', ping: dato.ping } : null
+    }
     if (dato.type === 'carpetas') {
       return {
         type: 'carpetas',
 
@@ -31,14 +31,14 @@ import type { Server, ServerUser } from '@/types/api'
 /** Por encima, la letra tarda en aparecer y conviene adelantarla. */
 const LATENCIA_PARA_ADELANTAR_MS = 90
 
-/** Media que sigue a la red sin saltar con una medida suelta. */
-const PESO_DE_LA_ULTIMA = 0.25
+/** Se mira el mínimo de estas: el ruido del navegador solo suma tiempo. */
+const MEDIDAS_A_RECORDAR = 5
 
 /** Se avisa por tramos: al ojo no le dice nada un milisegundo arriba. */
 const TRAMO_DE_LATENCIA_MS = 10
 
-/** Más tarde no es el eco de la tecla: falsearía la media. */
-const LATENCIA_CREIBLE_MS = 1500
+/** Cada cuánto se mide la ida y vuelta con el servidor. */
+const PING_CADA_MS = 2000
 
 /** Sin eco, la shell no repite lo tecleado: pide una contraseña. */
 const SIN_ECO_MS = 600
@@ -66,8 +66,9 @@ export function useTerminalSocket({
   const reconexiones = useRef(0)
   const [intento, setIntento] = useState(0)
   const eco = useRef(crearEcoPredictivo())
-  const tecleadoEn = useRef<number | null>(null)
   const esperaDeEco = useRef<number | undefined>(undefined)
+  const pings = useRef(new Map<number, number>())
+  const medidas = useRef<number[]>([])
   const latencia = useRef(0)
   const avisada = useRef(0)
   const [subida, setSubida] = useState<AvanceDeSubida | null>(null)
@@ -88,6 +89,26 @@ export function useTerminalSocket({
     }
   }, [])
 
+  /** Lo mejor de las últimas medidas; decide también si conviene adelantar. */
+  const anotarLatencia = (numero: number) => {
+    const salida = pings.current.get(numero)
+    if (salida === undefined) return
+    pings.current.delete(numero)
+
+    medidas.current = [...medidas.current, performance.now() - salida].slice(
+      -MEDIDAS_A_RECORDAR,
+    )
+    latencia.current = Math.min(...medidas.current)
+    eco.current.activar(latencia.current > LATENCIA_PARA_ADELANTAR_MS)
+
+    const tramo =
+      Math.round(latencia.current / TRAMO_DE_LATENCIA_MS) * TRAMO_DE_LATENCIA_MS
+    if (tramo !== avisada.current) {
+      avisada.current = tramo
+      avisar.current(tramo)
+    }
+  }
+
   const enviarTamano = useCallback(() => {
     const vista = terminal.current
     if (vista) enviar({ resize: { cols: vista.cols, rows: vista.rows } })
@@ -112,7 +133,6 @@ export function useTerminalSocket({
           }, SIN_ECO_MS)
         }
       }
-      if (tecleadoEn.current === null) tecleadoEn.current = performance.now()
       enviar({ command: datos })
     },
     [enviar, terminal],
@@ -234,6 +254,7 @@ export function useTerminalSocket({
   useEffect(() => {
     let vigente = true
     let reintento: number | undefined
+    let reloj: number | undefined
     let inicialPendiente = buildInitialCommand(rutaInicial)
 
     const escribir = (texto: string) => terminal.current?.write(texto)
@@ -293,12 +314,22 @@ export function useTerminalSocket({
       )
       socket.current = abierto
 
+      let numeroDePing = 0
+      const medirLatencia = () => {
+        if (abierto.readyState !== WebSocket.OPEN) return
+        numeroDePing += 1
+        pings.current.set(numeroDePing, performance.now())
+        abierto.send(JSON.stringify({ ping: numeroDePing }))
+      }
+      reloj = window.setInterval(medirLatencia, PING_CADA_MS)
+
       abierto.onopen = () => {
         if (reconexiones.current > 0) escribir('\r\n\x1b[2m— Reconectado —\x1b[0m\r\n')
         reconexiones.current = 0
         onEstado({ fase: 'conectada' })
         terminal.current?.focus()
         enviarTamano()
+        medirLatencia()
       }
 
       abierto.onmessage = (evento) => {
@@ -327,22 +358,11 @@ export function useTerminalSocket({
         window.clearTimeout(esperaDeEco.current)
         esperaDeEco.current = undefined
 
-        if (tecleadoEn.current !== null) {
-          const ida = performance.now() - tecleadoEn.current
-          tecleadoEn.current = null
-          if (ida <= LATENCIA_CREIBLE_MS) {
-            latencia.current =
-              latencia.current * (1 - PESO_DE_LA_ULTIMA) + ida * PESO_DE_LA_ULTIMA
-            eco.current.activar(latencia.current > LATENCIA_PARA_ADELANTAR_MS)
-
-            const tramo =
-              Math.round(latencia.current / TRAMO_DE_LATENCIA_MS) * TRAMO_DE_LATENCIA_MS
-            if (tramo !== avisada.current) {
-              avisada.current = tramo
-              avisar.current(tramo)
-            }
-          }
+        if (mensaje.type === 'pong') {
+          anotarLatencia(mensaje.ping)
+          return
         }
+
         escribir(eco.current.reconciliar(mensaje.message))
 
         // El cd espera a la primera salida (el prompt): en onopen la shell
@@ -355,7 +375,6 @@ export function useTerminalSocket({
 
       abierto.onclose = (evento) => {
         escribir(eco.current.limpiar())
-        tecleadoEn.current = null
         soltarTurnos()
         const contestar = respuesta.current
         respuesta.current = null
@@ -384,6 +403,7 @@ export function useTerminalSocket({
       document.removeEventListener('visibilitychange', reintentarYa)
       window.clearTimeout(apertura)
       window.clearTimeout(reintento)
+      window.clearInterval(reloj)
       window.clearTimeout(esperaDeEco.current)
 
       const abierto = socket.current