v1.9.0: el sensor tambien anota la inactividad

Cada tramo sin ninguna entrada (mas alla del umbral de 3 min, que sigue contando como trabajo
igual que siempre) queda registrado como {desde, segundos} y viaja en el lote como `idles`,
aparte de los bloques. Sin app, sin titulo, sin contenido: la inactividad no tiene nada que
mirar. La bandeja lo dice: «inactivo (se anota aparte)».

Decisiones que importan, salidas de una revision adversaria previa (11 hallazgos, todos
atendidos):

- Tope de 4 h por tramo: una torre que nunca se suspende, bloqueada toda la noche, anotaba
  «14 h inactivo» en el dia anterior. Mas de 4 h sin tocar el equipo es ausencia, no descanso;
  pasado el tope no se reabre nada hasta que vuelva la entrada. El servidor ademas rechaza
  cualquier tramo de mas de 6 h como red de seguridad.
- La suspension corta el tramo (la noche del portatil es una laguna, no un dato) y al
  despertar el reloj queda EN el umbral: sin eso, los despertares automaticos de Windows a las
  3 a. m. contaban hasta 3 min de trabajo fantasma y fabricaban jornadas de madrugada.
- El tramo en curso se persiste a disco (rastreador-encurso.json, un latido por minuto): un
  apagado, el cierre de la app o la auto-actualizacion —que reinicia a todo el equipo a la
  vez— lo cierran en su ultimo latido en vez de perderlo entero.
- La subida se acota a 12 lotes por ciclo y el tiempo de subida no cuenta como suspension:
  al volver la red tras dias sin ella, los cientos de POST seguidos bloqueaban el hilo del
  sensor y el siguiente tic diagnosticaba un «dormido» falso que cortaba el tramo abierto.
- La cola en disco lee el formato viejo (Vec<Vec<Bloque>>) ademas del nuevo: lo pendiente de
  subir en la 1.8 no se pierde al actualizar.
- En pausa no se anota nada, y reanudar no retro-anota la pausa como ocio.

El servidor (labstream-os 453a640) ya acepta `idles` y enseña la columna «Inactivo» en las
jornadas de /rastreo; los sensores 1.8 siguen funcionando sin cambios.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

README.md

@@ -39,6 +39,37 @@ NAS. Esto le da al equipo un cliente nativo de verdad en Windows y Mac:
   resultado. Es un popup nativo del sistema, igual en Windows y macOS, y vive
   solo en el shell (la web app no se toca).
 
+- **Rastreador de trabajo efectivo** (v1.9.0, `src-tauri/src/tracker.rs`): mide
+  cuánto tiempo se trabaja de verdad y en qué aplicación, y lo publica en el
+  panel **/rastreo** del servidor. Cada 5 s mira la ventana al frente y si
+  hubo entrada de ratón/teclado; **con 3 minutos sin entrada deja de contar**
+  (eso cubre también pantalla bloqueada y suspensión). Sube lotes cada 5 min a
+  `POST /api/tracker`; sin red, la cola espera en disco y reintenta.
+  - **Desde la 1.9 también ANOTA la inactividad**: cuando se cruza el umbral de
+    3 min, el tramo quieto queda registrado aparte (solo desde/hasta — sin app,
+    sin título, sin contenido) y el panel lo enseña junto a cada jornada. La
+    bandeja lo dice («inactivo (se anota aparte)»). Suspender o apagar el
+    equipo NO cuenta como inactividad: el tramo se corta ahí — la noche con el
+    portátil cerrado es una laguna, no un dato (el tramo en curso se guarda a
+    disco cada minuto, así que un apagado o la auto-actualización lo cierran en
+    su último latido en vez de perderlo). Y un tramo se cierra solo a las 4 h:
+    más que eso sin tocar el equipo es ausencia, no descanso frente a la
+    pantalla. En pausa no se anota nada.
+  - **Qué NO registra, a propósito:** ni qué teclas se pulsan (solo compara una
+    huella de posición del ratón y cuántas teclas hay presionadas), ni
+    pantallazos, ni el contenido de nada, ni los procesos de fondo.
+  - **Se ve y se pausa**: el menú de la bandeja dice el estado («registrando»,
+    «inactivo», «en pausa») y pausa/reanuda de un toque.
+  - **Se vincula** desde el servidor: Ajustes ▸ Perfil ▸ *Vincular este equipo*,
+    **estando dentro de esta app**. El servidor genera el token del equipo y se
+    lo entrega al sensor por el evento `ls-tracker-token`; el secreto nunca se
+    enseña ni se copia a mano. Revocar el equipo (misma pantalla) lo corta al
+    instante: el siguiente lote recibe 401, el sensor tira el token y la bandeja
+    vuelve a «sin vincular».
+  - En **macOS** el sistema pide permiso de *Accesibilidad* la primera vez (para
+    leer el título de la ventana al frente); sin él, el sensor mide tiempo pero
+    no sabe decir en qué app.
+
 La barra de pestañas vive en `dist/index.html` (webview local «chrome»); las
 pestañas son webviews hijos `tab-*`. Shell ↔ Rust se hablan por eventos `ls-*`.
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "labstream-desktop",
-  "version": "1.6.1",
+  "version": "1.9.0",
   "private": true,
   "description": "App de escritorio (Windows) que envuelve Labstream OS — cliente del servidor del NAS.",
   "scripts": {

src-tauri/Cargo.lock

@@ -2062,7 +2062,7 @@ dependencies = [
 
 [[package]]
 name = "labstream-desktop"
-version = "1.6.1"
+version = "1.7.1"
 dependencies = [
  "serde",
  "serde_json",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "labstream-desktop"
-version = "1.6.1"
+version = "1.9.0"
 description = "Cliente de escritorio de Labstream OS"
 authors = ["Labstream SAS"]
 edition = "2021"
@@ -28,3 +28,12 @@ tauri-plugin-updater = "2"
 tauri-plugin-single-instance = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+# ── Rastreador de trabajo efectivo (src/tracker.rs) ──
+# active-win-pos-rs: la ventana al frente (app + título) en Win/Mac.
+# device_query: ¿hubo entrada? (huella de mouse/teclas presionadas; NUNCA qué se tecleó).
+# ureq: subir los lotes a /api/tracker (bloqueante, corre en su propio hilo).
+# gethostname: el nombre del equipo, que bautiza al device en el servidor.
+active-win-pos-rs = "0.11"
+device_query = "4"
+ureq = { version = "2", features = ["json"] }
+gethostname = "0.5"

src-tauri/src/lib.rs

@@ -32,6 +32,8 @@
 // `core:default` también para el origen remoto (capabilities/default.json). Así no hace falta
 // declarar comandos propios en el ACL para páginas remotas.
 
+mod tracker;
+
 use std::sync::Mutex;
 
 use serde::{Deserialize, Serialize};
@@ -221,16 +223,39 @@ const INIT_JS_TPL: &str = r#"
   }
   function newTab(url) { emit('ls-new-tab', { url: url }); }
 
+  // ── ¿La página se VE oscura? ──
+  // Señales, de la más directa a la más física: la clase `dark` (next-themes) y, si no
+  // está, el color de fondo REALMENTE pintado (luminancia del body) — vale sea cual sea
+  // el mecanismo de tema. Devuelve null con el documento a medio crear (los scripts de
+  // inicio corren antes de que exista <html>): entonces el campo NO viaja y Rust conserva
+  // el último valor bueno. La v1.7.0 leía la clase a secas y sin red: en WebView2 eso
+  // podía reventar en frío y dejar `dark` mintiendo en estado.json (barra clara sobre
+  // app oscura — el bug al revés).
+  function temaOscuro() {
+    try {
+      var doc = document.documentElement, cuerpo = document.body;
+      if (!doc) return null;
+      if (doc.classList.contains('dark') || (cuerpo && cuerpo.classList.contains('dark'))) return true;
+      if (!cuerpo) return null;
+      var fondo = getComputedStyle(cuerpo).backgroundColor || '';
+      var m = fondo.match(/rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,\s\/]+([\d.]+))?/);
+      if (m && (m[4] === undefined || parseFloat(m[4]) > 0.5)) {
+        return 0.2126 * m[1] + 0.7152 * m[2] + 0.0722 * m[3] < 128;
+      }
+      var esquema = getComputedStyle(doc).colorScheme || '';
+      if (esquema.indexOf('dark') >= 0 && esquema.indexOf('light') < 0) return true;
+      return false;
+    } catch (e) { return null; }
+  }
+
   // Título, URL y TEMA → barra de pestañas (y para restaurar la sesión al reabrir).
-  // El tema viaja aquí porque la web decide su modo con su propio botón (next-themes,
-  // clase `dark` en <html>) y NO sigue al sistema: la barra tiene que copiarle a ella.
+  // El tema viaja aquí porque la web decide su modo con su propio botón y NO sigue al
+  // sistema: la barra tiene que copiarle a ELLA.
   function report() {
-    emit('ls-title', {
-      label: LABEL,
-      title: document.title || 'Labstream OS',
-      url: location.href,
-      dark: document.documentElement.classList.contains('dark')
-    });
+    var carga = { label: LABEL, title: document.title || 'Labstream OS', url: location.href };
+    var oscuro = temaOscuro();
+    if (oscuro !== null) carga.dark = oscuro;
+    emit('ls-title', carga);
   }
   function watchTitle() {
     var el = document.querySelector('title');
@@ -249,11 +274,18 @@ const INIT_JS_TPL: &str = r#"
     history[k] = function () { var r = o.apply(this, arguments); setTimeout(report, 0); return r; };
   });
   addEventListener('popstate', function () { setTimeout(report, 0); });
-  // Pulsar la luna cambia la clase de <html> sin navegar: se observa para que la barra
-  // se entere al instante.
-  if (window.MutationObserver) {
-    new MutationObserver(report).observe(document.documentElement, { attributes: true, attributeFilter: ['class'] });
+  // Pulsar la luna cambia clases/estilos sin navegar: se vigilan <html> y <body> (cuando
+  // existan — a document-start aún no hay), y tras la carga se re-reporta un par de veces
+  // por si el tema aterriza tarde con la hidratación.
+  function vigilarTema() {
+    if (!window.MutationObserver) return;
+    var conf = { attributes: true, attributeFilter: ['class', 'style', 'data-theme'] };
+    if (document.documentElement) new MutationObserver(report).observe(document.documentElement, conf);
+    if (document.body) new MutationObserver(report).observe(document.body, conf);
   }
+  if (document.body) vigilarTema();
+  else document.addEventListener('DOMContentLoaded', vigilarTema);
+  addEventListener('load', function () { setTimeout(report, 800); setTimeout(report, 2500); });
 
   // Clics en enlaces.
   document.addEventListener('click', function (e) {
@@ -1364,10 +1396,13 @@ pub fn run() {
                 }
             });
 
-            // Icono en la bandeja del sistema con menú Abrir / Salir.
+            // Icono en la bandeja: Abrir / estado del rastreador + pausa / Salir.
             let abrir = MenuItem::with_id(app, "abrir", "Abrir Labstream", true, None::<&str>)?;
             let salir = MenuItem::with_id(app, "salir", "Salir", true, None::<&str>)?;
-            let menu = Menu::with_items(app, &[&abrir, &salir])?;
+            let (trk_estado, trk_toggle) = tracker::armar_menu(app.handle())?;
+            let sep1 = PredefinedMenuItem::separator(app)?;
+            let sep2 = PredefinedMenuItem::separator(app)?;
+            let menu = Menu::with_items(app, &[&abrir, &sep1, &trk_estado, &trk_toggle, &sep2, &salir])?;
 
             TrayIconBuilder::with_id("main-tray")
                 .icon(app.default_window_icon().unwrap().clone())
@@ -1380,6 +1415,7 @@ pub fn run() {
                         save_persisted(app);
                         app.exit(0);
                     }
+                    id if tracker::menu_event(app, id) => {}
                     _ => {}
                 })
                 .on_tray_icon_event(|tray, event| {
@@ -1395,6 +1431,9 @@ pub fn run() {
                 })
                 .build(app)?;
 
+            // El sensor del rastreador: listener de vinculación + hilo de medición.
+            tracker::iniciar(app.handle());
+
             Ok(())
         })
         .on_window_event(|window, event| {

src-tauri/src/tracker.rs

@@ -0,0 +1,590 @@
+// ── Rastreador de trabajo efectivo (Fase 1) ──
+//
+// Mide TIEMPO CON EL EQUIPO ACTIVO y en qué app: cada 5 s mira la ventana al frente
+// (active-win-pos-rs) y si hubo entrada de mouse/teclado (device_query). Con 3 minutos sin
+// entrada deja de contar (ocio profundo); bloquear la pantalla o suspender cae en lo mismo
+// porque tampoco hay entrada. Acumula bloques {app, título, segundos, segundos activos} y los
+// sube cada 5 min a POST /api/tracker con el token del equipo (ltk_). Sin red, la cola
+// persiste en disco y reintenta.
+//
+// LO QUE NO HACE, a propósito: no registra teclas ni posiciones (solo "hubo entrada"), no
+// toma pantallazos, no lista procesos de fondo. El estado es VISIBLE en el menú de la
+// bandeja, con pausa de un toque — medición transparente, no spyware.
+//
+// La vinculación llega por el evento `ls-tracker-token`: la página de Ajustes → Perfil
+// (dentro de la app, con la sesión del usuario) genera el token en el servidor y lo emite;
+// aquí se guarda en rastreador.json y el sensor arranca. Un 401 del servidor = token
+// revocado → se descarta y la bandeja vuelve a «sin vincular».
+
+use std::{
+    collections::HashMap,
+    sync::Mutex,
+    thread,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use tauri::{menu::MenuItem, AppHandle, Emitter, Listener, Manager, Runtime};
+
+const API: &str = "https://os.labstreamsas.com/api/tracker";
+const TICK_SEG: u64 = 5;
+const OCIO_PROFUNDO_SEG: u64 = 180; // 3 min sin entrada → deja de contar
+const LOTE_SEG: u64 = 300; // subir cada 5 min
+const MAX_COLA_LOTES: usize = 2000; // ~1 semana sin red; después se pierde lo más viejo
+// Un tramo de ocio se cierra SOLO a las 4 h: más que eso sin tocar el equipo no es un descanso
+// frente a la pantalla, es ausencia — y sin este tope, una torre que nunca se suspende anotaría
+// «14 h inactivo» por una noche con la pantalla bloqueada. Pasado el tope no se reabre nada
+// hasta que vuelva la entrada.
+const OCIO_MAX_TRAMO_SEG: u64 = 4 * 3600;
+// Lotes por intento de subida. Sin tope, al volver la red tras días sin ella los cientos de
+// POST seguidos bloquean el hilo del sensor más de un minuto y el siguiente tic diagnostica
+// una «suspensión» que nunca ocurrió. La cola se drena en varios ciclos de 5 min.
+const MAX_LOTES_POR_ENVIO: usize = 12;
+const PAUSA_MANUAL: u64 = u64::MAX;
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+struct Config {
+    token: Option<String>,
+    // Instante unix (seg) hasta el que está pausado; PAUSA_MANUAL = hasta reanudar a mano.
+    #[serde(default)]
+    pausado_hasta: Option<u64>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+struct Bloque {
+    s: u64, // inicio en ms unix
+    d: u32, // segundos del bloque
+    a: u32, // segundos con entrada real
+    app: String,
+    t: String, // título de ventana (truncado; puede ir vacío)
+}
+
+// Un tramo de INACTIVIDAD: desde que se cruzó el umbral de 3 min sin entrada hasta que volvió
+// a haberla. Los primeros 3 min siguen contando como trabajo (igual que siempre); esto anota
+// lo de ahí en adelante. Sin app ni título a propósito: la inactividad no tiene contenido.
+#[derive(Serialize, Deserialize, Clone)]
+struct Ocio {
+    s: u64, // inicio en ms unix
+    d: u32, // segundos quieto (más allá del umbral)
+}
+
+// Un lote: bloques de trabajo + tramos de ocio del mismo intervalo.
+#[derive(Serialize, Deserialize, Clone, Default)]
+struct Lote {
+    b: Vec<Bloque>,
+    #[serde(default)]
+    i: Vec<Ocio>,
+}
+
+// La cola en disco de la 1.8 era `Vec<Vec<Bloque>>` (solo bloques). Este enum lee AMBOS
+// formatos: al actualizar, lo que quedó pendiente de subir no se pierde.
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum LoteEnDisco {
+    Nuevo(Lote),
+    Viejo(Vec<Bloque>),
+}
+
+// Estado compartido sensor ↔ menú. Los items de menú viven aparte (son genéricos en R).
+struct Nucleo {
+    cfg: Config,
+    cola: Vec<Lote>, // lotes pendientes de subir
+}
+
+struct NucleoState(Mutex<Nucleo>);
+struct MenuUi<R: Runtime> {
+    estado: MenuItem<R>,
+    toggle: MenuItem<R>,
+}
+struct MenuState<R: Runtime>(Mutex<MenuUi<R>>);
+
+fn ahora_seg() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0)
+}
+fn ahora_ms() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0)
+}
+
+fn ruta_cfg<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
+    app.path().app_config_dir().ok().map(|d| d.join("rastreador.json"))
+}
+fn ruta_cola<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
+    app.path().app_config_dir().ok().map(|d| d.join("rastreador-cola.json"))
+}
+// El tramo de ocio EN CURSO, persistido para sobrevivir a apagados y a la auto-actualización
+// (que reinicia la app de todo el equipo a la vez). La suspensión no lo necesita —el mismo
+// proceso despierta y lo cierra—, pero si el proceso MUERE con un tramo abierto, sin esto el
+// descanso se perdía entero. Contiene {t: último tic (seg), o: inicio del tramo (ms)}.
+fn ruta_encurso<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
+    app.path().app_config_dir().ok().map(|d| d.join("rastreador-encurso.json"))
+}
+fn guardar_encurso<R: Runtime>(app: &AppHandle<R>, tic: u64, inicio_ms: u64) {
+    let Some(p) = ruta_encurso(app) else { return };
+    if let Some(dir) = p.parent() {
+        let _ = std::fs::create_dir_all(dir);
+    }
+    let _ = std::fs::write(p, format!("{{\"t\":{tic},\"o\":{inicio_ms}}}"));
+}
+fn borrar_encurso<R: Runtime>(app: &AppHandle<R>) {
+    if let Some(p) = ruta_encurso(app) {
+        let _ = std::fs::remove_file(p);
+    }
+}
+
+fn cargar_cfg<R: Runtime>(app: &AppHandle<R>) -> Config {
+    ruta_cfg(app)
+        .and_then(|p| std::fs::read_to_string(p).ok())
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_default()
+}
+fn guardar_cfg<R: Runtime>(app: &AppHandle<R>, cfg: &Config) {
+    let Some(p) = ruta_cfg(app) else { return };
+    if let Some(dir) = p.parent() {
+        let _ = std::fs::create_dir_all(dir);
+    }
+    if let Ok(txt) = serde_json::to_string(cfg) {
+        let _ = std::fs::write(p, txt);
+    }
+}
+fn cargar_cola<R: Runtime>(app: &AppHandle<R>) -> Vec<Lote> {
+    let crudo: Vec<LoteEnDisco> = ruta_cola(app)
+        .and_then(|p| std::fs::read_to_string(p).ok())
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_default();
+    crudo
+        .into_iter()
+        .map(|l| match l {
+            LoteEnDisco::Nuevo(x) => x,
+            LoteEnDisco::Viejo(b) => Lote { b, i: Vec::new() },
+        })
+        .collect()
+}
+fn guardar_cola<R: Runtime>(app: &AppHandle<R>, cola: &[Lote]) {
+    let Some(p) = ruta_cola(app) else { return };
+    if cola.is_empty() {
+        let _ = std::fs::remove_file(p);
+        return;
+    }
+    if let Ok(txt) = serde_json::to_string(cola) {
+        let _ = std::fs::write(p, txt);
+    }
+}
+
+// ── Menú de bandeja ──
+// Crea los dos items del rastreador (estado informativo + pausar/reanudar) YA con el texto
+// correcto: `set_text` de Tauri despacha al hilo principal y BLOQUEA esperándolo, así que
+// llamarlo desde `setup()` —que corre en ese mismo hilo, antes de que el bucle de eventos
+// empiece a atender— colgaría la app al abrir. Por eso el texto inicial se decide aquí y
+// todos los repintados posteriores salen de hilos secundarios (ver `pintar_en_hilo`).
+pub fn armar_menu<R: Runtime>(app: &AppHandle<R>) -> tauri::Result<(MenuItem<R>, MenuItem<R>)> {
+    let cfg = cargar_cfg(app);
+    let estado = MenuItem::with_id(app, "trk-estado", texto_estado(&cfg, "registrando"), false, None::<&str>)?;
+    let toggle = MenuItem::with_id(app, "trk-toggle", texto_toggle(&cfg), cfg.token.is_some(), None::<&str>)?;
+    app.manage(MenuState(Mutex::new(MenuUi { estado: estado.clone(), toggle: toggle.clone() })));
+    Ok((estado, toggle))
+}
+
+// Maneja los clics del menú del rastreador. Devuelve true si el id era nuestro.
+pub fn menu_event<R: Runtime>(app: &AppHandle<R>, id: &str) -> bool {
+    match id {
+        "trk-toggle" => {
+            let nucleo = app.state::<NucleoState>();
+            let mut n = nucleo.0.lock().unwrap();
+            let pausado = esta_pausado(&n.cfg);
+            n.cfg.pausado_hasta = if pausado { None } else { Some(PAUSA_MANUAL) };
+            let cfg = n.cfg.clone();
+            drop(n);
+            guardar_cfg(app, &cfg);
+            // El clic del menú llega EN el hilo principal: repintar aquí se bloquearía a sí
+            // mismo. Se delega a un hilo suelto, que además responde al instante.
+            pintar_en_hilo(app, if esta_pausado(&cfg) { "en pausa" } else { "registrando" }, cfg);
+            true
+        }
+        _ => false,
+    }
+}
+
+fn pintar_en_hilo<R: Runtime>(app: &AppHandle<R>, estado: &str, cfg: Config) {
+    let h = app.clone();
+    let estado = estado.to_string();
+    thread::spawn(move || pintar_menu(&h, &estado, &cfg));
+}
+
+fn esta_pausado(cfg: &Config) -> bool {
+    match cfg.pausado_hasta {
+        Some(h) => h == PAUSA_MANUAL || h > ahora_seg(),
+        None => false,
+    }
+}
+
+fn texto_estado(cfg: &Config, estado: &str) -> String {
+    if cfg.token.is_none() {
+        "Rastreador: sin vincular (Ajustes → Perfil)".to_string()
+    } else {
+        format!("Rastreador: {estado}")
+    }
+}
+fn texto_toggle(cfg: &Config) -> &'static str {
+    if esta_pausado(cfg) { "Reanudar el rastreador" } else { "Pausar el rastreador" }
+}
+
+// OJO: solo desde hilos secundarios (ver `armar_menu`).
+fn pintar_menu<R: Runtime>(app: &AppHandle<R>, estado: &str, cfg: &Config) {
+    let Some(menu) = app.try_state::<MenuState<R>>() else { return };
+    let ui = menu.0.lock().unwrap();
+    let _ = ui.estado.set_text(texto_estado(cfg, estado));
+    let _ = ui.toggle.set_text(texto_toggle(cfg));
+    let _ = ui.toggle.set_enabled(cfg.token.is_some());
+}
+
+// ── Normalización ──
+fn normaliza(s: &str, max: usize) -> String {
+    let limpio = s.split_whitespace().collect::<Vec<_>>().join(" ");
+    limpio.chars().take(max).collect()
+}
+
+// ── Envío ──
+// Sube la cola entera; deja en la cola lo que no pudo. Un 401 = token revocado → se descarta
+// el token (la bandeja pasa a «sin vincular») y la cola se vacía: ya nadie la quiere.
+fn enviar<R: Runtime>(app: &AppHandle<R>) {
+    let (token, lotes) = {
+        let nucleo = app.state::<NucleoState>();
+        let n = nucleo.0.lock().unwrap();
+        let Some(t) = n.cfg.token.clone() else { return };
+        if n.cola.is_empty() {
+            return;
+        }
+        // Con tope por llamada: la cola grande (días sin red) se drena a lo largo de varios
+        // ciclos en vez de bloquear el hilo del sensor con cientos de POST seguidos.
+        (t, n.cola.iter().take(MAX_LOTES_POR_ENVIO).cloned().collect::<Vec<Lote>>())
+    };
+    let hostname = gethostname::gethostname().to_string_lossy().to_string();
+    let version = app.package_info().version.to_string();
+    let mut enviados = 0usize;
+    let mut revocado = false;
+    for lote in &lotes {
+        let r = ureq::post(API)
+            .set("Authorization", &format!("Bearer {token}"))
+            .timeout(Duration::from_secs(20))
+            .send_json(json!({
+                "device": { "hostname": hostname, "platform": std::env::consts::OS, "version": version },
+                "blocks": lote.b,
+                "idles": lote.i,
+            }));
+        match r {
+            Ok(_) => enviados += 1,
+            Err(ureq::Error::Status(401, _)) => {
+                revocado = true;
+                break;
+            }
+            Err(_) => break, // sin red o error del servidor: se reintenta en el próximo ciclo
+        }
+    }
+    let nucleo = app.state::<NucleoState>();
+    let mut n = nucleo.0.lock().unwrap();
+    if revocado {
+        n.cfg.token = None;
+        n.cola.clear();
+        let cfg = n.cfg.clone();
+        drop(n);
+        guardar_cfg(app, &cfg);
+        guardar_cola(app, &[]);
+        pintar_menu(app, "sin vincular", &cfg);
+        return;
+    }
+    // El largo se calcula ANTES del drain: dentro del argumento sería un préstamo inmutable
+    // mientras `n.cola` ya está prestado mutable — a través del MutexGuard (un deref
+    // explícito) el two-phase borrow no lo cubre, y no compila.
+    let hasta = enviados.min(n.cola.len());
+    n.cola.drain(0..hasta);
+    if n.cola.len() > MAX_COLA_LOTES {
+        let sobra = n.cola.len() - MAX_COLA_LOTES;
+        n.cola.drain(0..sobra); // sin red por semanas: se suelta lo más viejo, no lo nuevo
+    }
+    let cola = n.cola.clone();
+    drop(n);
+    guardar_cola(app, &cola);
+}
+
+/// Manda un evento a la página SIN bloquear el hilo del que sale. Mismo motivo que
+/// `pintar_en_hilo`: un listener puede correr en el hilo principal, y cualquier cosa que
+/// espere a ese hilo desde ahí cuelga la app.
+fn avisar<R: Runtime>(app: &AppHandle<R>, evento: &'static str, payload: serde_json::Value) {
+    let h = app.clone();
+    thread::spawn(move || {
+        let _ = h.emit(evento, payload);
+    });
+}
+
+// ── Arranque: listener de vinculación + hilo del sensor ──
+pub fn iniciar<R: Runtime>(app: &AppHandle<R>) {
+    let cfg = cargar_cfg(app);
+    let cola = cargar_cola(app);
+    app.manage(NucleoState(Mutex::new(Nucleo { cfg, cola })));
+    // El menú ya nació con el texto correcto (armar_menu); repintarlo aquí bloquearía el
+    // hilo principal. De aquí en adelante lo repinta el sensor cuando cambia el estado.
+
+    // La página de Ajustes (dentro de la app) entrega el token recién generado.
+    let h = app.clone();
+    app.listen_any("ls-tracker-token", move |e| {
+        #[derive(Deserialize)]
+        struct P {
+            token: String,
+        }
+        let Ok(p) = serde_json::from_str::<P>(e.payload()) else { return };
+        if !p.token.starts_with("ltk_") {
+            return;
+        }
+        let nucleo = h.state::<NucleoState>();
+        let cfg = {
+            let mut n = nucleo.0.lock().unwrap();
+            n.cfg.token = Some(p.token);
+            n.cfg.pausado_hasta = None;
+            n.cfg.clone()
+        };
+        guardar_cfg(&h, &cfg);
+        // ACUSE de recibo. Sin esto la página no puede distinguir «el sensor lo guardó» de
+        // «esta app es vieja y no había nadie escuchando», y cantaba éxito en falso dejando
+        // un equipo registrado que jamás reporta. Si no llega este evento, la página revoca.
+        avisar(&h, "ls-tracker-listo", json!({ "ok": true }));
+        // Sin repintar aquí: el evento puede llegar en el hilo principal. El sensor ve el
+        // token en su próximo tic (≤5 s) y actualiza la bandeja solo.
+    });
+
+    // La página pregunta cómo está ESTE equipo (¿ya vinculado? ¿en pausa?) para no ofrecer
+    // vincular lo que ya está vinculado y para poder avisar cuando falta hacerlo.
+    let h = app.clone();
+    app.listen_any("ls-tracker-consulta", move |_| {
+        let nucleo = h.state::<NucleoState>();
+        let cfg = nucleo.0.lock().unwrap().cfg.clone();
+        avisar(
+            &h,
+            "ls-tracker-estado",
+            json!({
+                "vinculado": cfg.token.is_some(),
+                "pausado": esta_pausado(&cfg),
+                "version": env!("CARGO_PKG_VERSION"),
+            }),
+        );
+    });
+
+    // El sensor: un hilo con tic de 5 s. Nada de esto toca la interfaz salvo el menú del tray.
+    let h = app.clone();
+    thread::spawn(move || {
+        let device_state = device_query::DeviceState::new();
+        let mut ultimo_input = ahora_seg();
+        let mut huella_anterior: (i32, i32, usize) = (0, 0, 0);
+        let mut acumulado: HashMap<(String, String), Bloque> = HashMap::new();
+        let mut ocios_pendientes: Vec<Ocio> = Vec::new();
+        // Inicio (ms) del tramo de inactividad en curso, si lo hay.
+        let mut ocio_abierto: Option<u64> = None;
+        let mut ocioso_antes = false;
+        let mut tic_previo = ahora_seg();
+        let mut ultimo_envio = ahora_seg();
+        let mut ultimo_estado = String::new();
+        let mut encurso_guardado: u64 = 0;
+
+        // ¿La sesión anterior murió con un tramo de ocio abierto (apagado, cierre de la app,
+        // auto-actualización)? Se cierra en su último latido y se encola: el descanso fue
+        // real y medido — perderlo entero hacía mentir al README.
+        {
+            #[derive(Deserialize)]
+            struct EnCurso {
+                t: u64,
+                o: u64,
+            }
+            let previo: Option<EnCurso> = ruta_encurso(&h)
+                .and_then(|p| std::fs::read_to_string(p).ok())
+                .and_then(|s| serde_json::from_str(&s).ok());
+            if let Some(e) = previo {
+                let fin = (e.t + TICK_SEG) * 1000;
+                if fin > e.o {
+                    let d = ((fin - e.o) / 1000).min(OCIO_MAX_TRAMO_SEG) as u32;
+                    if d >= 60 {
+                        let nucleo = h.state::<NucleoState>();
+                        let cola = {
+                            let mut n = nucleo.0.lock().unwrap();
+                            n.cola.push(Lote { b: Vec::new(), i: vec![Ocio { s: e.o, d }] });
+                            n.cola.clone()
+                        };
+                        guardar_cola(&h, &cola);
+                    }
+                }
+            }
+            borrar_encurso(&h);
+        }
+
+        loop {
+            thread::sleep(Duration::from_secs(TICK_SEG));
+            let ahora = ahora_seg();
+
+            let (token_ok, pausado) = {
+                let nucleo = h.state::<NucleoState>();
+                let n = nucleo.0.lock().unwrap();
+                (n.cfg.token.is_some(), esta_pausado(&n.cfg))
+            };
+
+            // ¿Se SUSPENDIÓ el equipo? Sin tics durante mucho más que un tic = la máquina
+            // durmió (suspensión, hibernación, tapa cerrada). La noche del portátil NO es
+            // inactividad: el tramo abierto se CIERRA en el último tic visto y el reloj de
+            // entrada arranca de cero al despertar — si no, el sensor anotaría «12 h quieto»
+            // por una noche apagado, y al despertar abriría tramos que empiezan ayer.
+            let dormido = ahora.saturating_sub(tic_previo) > TICK_SEG * 12; // > 1 min sin tics
+            if dormido {
+                if let Some(ini) = ocio_abierto.take() {
+                    let fin = (tic_previo + TICK_SEG) * 1000;
+                    if fin > ini {
+                        ocios_pendientes.push(Ocio { s: ini, d: ((fin - ini) / 1000) as u32 });
+                    }
+                    borrar_encurso(&h);
+                }
+                // Al despertar, el reloj de entrada queda EXACTAMENTE en el umbral: seguimos
+                // ociosos hasta que alguien toque algo de verdad. Dejarlo en `ahora` parecía
+                // más natural, pero hacía que los 3 min siguientes contaran como TRABAJO sin
+                // una sola entrada — y los despertares automáticos de Windows (mantenimiento,
+                // wake timers a las 3 a. m.) fabricaban jornadas fantasma de madrugada.
+                ultimo_input = ahora.saturating_sub(OCIO_PROFUNDO_SEG);
+                ocioso_antes = false;
+            }
+            tic_previo = ahora;
+
+            // ¿Hubo entrada desde el último tic? Solo se compara una huella (posición del
+            // mouse + cuántas teclas hay presionadas): nunca se registra QUÉ se tecleó.
+            use device_query::DeviceQuery;
+            let mouse = device_state.get_mouse();
+            let teclas = device_state.get_keys().len();
+            let huella = (mouse.coords.0, mouse.coords.1, teclas);
+            let hubo_input = huella != huella_anterior || teclas > 0;
+            huella_anterior = huella;
+            if hubo_input {
+                ultimo_input = ahora;
+            }
+            let ocioso = ahora.saturating_sub(ultimo_input) >= OCIO_PROFUNDO_SEG;
+
+            // ── El tramo de inactividad ──
+            // Abre cuando se cruza el umbral (retrocedido al minuto exacto en que se dejó de
+            // contar trabajo: ultimo_input + umbral) y cierra cuando vuelve la entrada. En
+            // pausa o sin vincular no se anota nada: pausar es «no me midas», y eso incluye
+            // la inactividad.
+            if token_ok && !pausado {
+                if ocioso && !ocioso_antes {
+                    let ini = (ultimo_input + OCIO_PROFUNDO_SEG) * 1000;
+                    ocio_abierto = Some(ini);
+                    guardar_encurso(&h, ahora, ini);
+                    encurso_guardado = ahora;
+                } else if !ocioso && ocioso_antes {
+                    if let Some(ini) = ocio_abierto.take() {
+                        let fin = ahora * 1000;
+                        if fin > ini {
+                            ocios_pendientes.push(Ocio { s: ini, d: ((fin - ini) / 1000) as u32 });
+                        }
+                        borrar_encurso(&h);
+                    }
+                }
+            } else {
+                if let Some(ini) = ocio_abierto.take() {
+                    // Se pausó o se desvinculó a mitad de un tramo: lo quieto HASTA ese
+                    // momento fue real y medido — se cierra aquí; de la pausa en adelante ya
+                    // no es asunto del sensor. Sin token (desvinculado) se descarta.
+                    if token_ok {
+                        let fin = ahora * 1000;
+                        if fin > ini {
+                            ocios_pendientes.push(Ocio { s: ini, d: ((fin - ini) / 1000) as u32 });
+                        }
+                    }
+                    borrar_encurso(&h);
+                }
+                ocioso_antes = false;
+                // El reloj de ocio parte de cero mientras dure la pausa: sin esto, reanudar
+                // estando quieto abriría un tramo retrocedido hasta DENTRO de la pausa —
+                // anotando como inactividad un rato que el editor pidió expresamente no medir.
+                ultimo_input = ahora;
+            }
+            if token_ok && !pausado {
+                ocioso_antes = ocioso;
+            }
+
+            // El tope del tramo: a las 4 h se cierra y NO se reabre (ocioso_antes queda en
+            // true, así que la transición de apertura no vuelve a disparar hasta que haya
+            // entrada real). Más de eso no es descanso frente al equipo, es ausencia.
+            if let Some(ini) = ocio_abierto {
+                if (ahora * 1000).saturating_sub(ini) >= OCIO_MAX_TRAMO_SEG * 1000 {
+                    ocio_abierto = None;
+                    ocios_pendientes.push(Ocio { s: ini, d: OCIO_MAX_TRAMO_SEG as u32 });
+                    borrar_encurso(&h);
+                } else if ahora.saturating_sub(encurso_guardado) >= 60 {
+                    // Latido del tramo abierto (1/min): si el proceso muere, al arrancar se
+                    // cierra en el último latido en vez de perderse entero.
+                    guardar_encurso(&h, ahora, ini);
+                    encurso_guardado = ahora;
+                }
+            }
+
+            let estado = if !token_ok {
+                "sin vincular"
+            } else if pausado {
+                "en pausa"
+            } else if ocioso {
+                // Desde la 1.9 el tramo quieto SÍ queda anotado (aparte de las horas
+                // efectivas); la bandeja lo dice para que la medición siga siendo transparente.
+                "inactivo (se anota aparte)"
+            } else {
+                "registrando"
+            };
+            if estado != ultimo_estado {
+                let cfg = {
+                    let nucleo = h.state::<NucleoState>();
+                    let n = nucleo.0.lock().unwrap();
+                    n.cfg.clone()
+                };
+                pintar_menu(&h, estado, &cfg);
+                ultimo_estado = estado.to_string();
+            }
+
+            if token_ok && !pausado && !ocioso {
+                if let Ok(v) = active_win_pos_rs::get_active_window() {
+                    let app_name = normaliza(&v.app_name, 80);
+                    let titulo = normaliza(&v.title, 140);
+                    if !app_name.is_empty() {
+                        let b = acumulado.entry((app_name.clone(), titulo.clone())).or_insert_with(|| Bloque {
+                            s: ahora_ms(),
+                            d: 0,
+                            a: 0,
+                            app: app_name,
+                            t: titulo,
+                        });
+                        b.d += TICK_SEG as u32;
+                        if hubo_input {
+                            b.a += TICK_SEG as u32;
+                        }
+                    }
+                }
+            }
+
+            // Cada 5 min: el acumulado (trabajo + ocio cerrado) pasa a la cola y se intenta
+            // subir todo. Un tramo de ocio AÚN abierto no viaja: se sube cuando cierre.
+            if ahora.saturating_sub(ultimo_envio) >= LOTE_SEG {
+                ultimo_envio = ahora;
+                if !acumulado.is_empty() || !ocios_pendientes.is_empty() {
+                    let lote = Lote {
+                        b: acumulado.drain().map(|(_, b)| b).collect(),
+                        i: std::mem::take(&mut ocios_pendientes),
+                    };
+                    let nucleo = h.state::<NucleoState>();
+                    let cola = {
+                        let mut n = nucleo.0.lock().unwrap();
+                        n.cola.push(lote);
+                        n.cola.clone()
+                    };
+                    guardar_cola(&h, &cola);
+                }
+                enviar(&h);
+                // Lo que tardó la subida NO fue una suspensión: sin este refresco, una tanda
+                // lenta (>1 min) hacía que el siguiente tic entrara por la rama `dormido` y
+                // cortara en falso el tramo de ocio abierto.
+                tic_previo = ahora_seg();
+            }
+        }
+    });
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Labstream OS",
-  "version": "1.6.1",
+  "version": "1.9.0",
   "identifier": "co.labstream.os",
   "build": {
     "frontendDist": "../dist"