v1.10.0: el video en primer plano no cuenta como inactividad

Regla pedida por el usuario: si alguien mira un video en el navegador sin tocar
el mouse, no es que este quieto — esta viendo algo. Ahora el sensor lo cuenta
como tiempo de navegador en vez de inactividad.

- Excepcion del VIDEO (Windows): en el tick, si `ocioso` (3 min sin entrada)
  PERO al frente hay un navegador (chrome/brave/edge/firefox/opera/vivaldi, se
  excluye el host WebView2) Y el sistema esta sacando sonido, es un video
  reproduciendose -> `viendo_video`. Se introduce `ocioso_efectivo = ocioso &&
  !viendo_video`, y TODO (tramo de inactividad, bandeja, acumulacion de la
  ventana) pasa a usar `ocioso_efectivo`. El bloque de navegador se acumula con
  a=0 (segundos sin entrada real): presente, sin teclear. La bandeja lo dice
  («video en primer plano»).
- Deteccion de sonido: medidor de pico de la salida de audio por defecto
  (WASAPI, IAudioMeterInformation via el crate `windows`, solo cfg(windows)).
  No abre el navegador, no lee la pestaña, no graba nada — solo pregunta al SO
  si hay sonido saliendo AHORA (pico > 0.01). Limite honesto documentado: un
  video MUDO no se detecta. macOS: stub que devuelve false (no hay API publica
  sencilla de nivel de audio; el equipo de edicion es Windows) -> comportamiento
  identico al de siempre en Mac.
- La ventana al frente ahora se lee cada tic mientras se mide (antes solo con
  actividad), porque hace falta para decidir la excepcion; se reutiliza esa
  misma lectura para acumular, sin volver a preguntar al SO.
- COM se inicializa una vez al arrancar el hilo del sensor (cfg(windows)).
- El contrato con el servidor NO cambia: se sigue mandando {blocks, idles}, solo
  que ahora hay menos idles y algun bloque de navegador cuando hay video. Nada
  que tocar en labstream-os.

Verificado con `cargo check`: el reensamblado compila limpio en el host (macOS),
y el codigo WASAPI type-checkea contra el target x86_64-pc-windows-msvc (aislado
en un crate minimo, porque `ring` de la TLS de ureq no cross-compila su C a
Windows desde Mac — eso lo hace la CI). Falta la validacion final en una maquina
Windows real (no puedo reproducir audio de Windows aqui): probar que un video en
YouTube con el mouse quieto sale como navegador y no como inactividad.

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

README.md

@@ -39,6 +39,46 @@ 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.10.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.
+  - **Desde la 1.10, la excepción del VIDEO** (solo Windows): si no hay entrada
+    PERO al frente hay un navegador (Chrome/Brave/Edge/Firefox…) y está saliendo
+    sonido —un video reproduciéndose—, ese rato NO se anota como inactividad: se
+    cuenta como tiempo de navegador (con 0 segundos «activos», porque no se
+    teclea). Se detecta con el medidor de audio del sistema (WASAPI,
+    `IAudioMeterInformation`): no abre el navegador, no lee la pestaña, no graba
+    nada — solo pregunta si hay sonido saliendo. Límite honesto: un video **mudo**
+    no se detecta (no suena). En macOS no aplica (no hay API pública sencilla de
+    nivel de audio); el equipo de edición es Windows.
+  - **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-*`.
 

dist/index.html

@@ -7,7 +7,8 @@
     <!--
       Barra de pestañas del shell de escritorio (webview "chrome", local).
       Habla con Rust por eventos (__TAURI__.event):
-        recibe  ls-tabs      {tabs:[{label,title,url,loading,active}], zoom, version, mac}
+        recibe  ls-tabs      {tabs:[{label,title,url,loading,active,color}], zoom, version,
+                              mac, win, maximized, dark}
         emite   ls-ready, ls-new-tab, ls-activate, ls-close-tab, ls-reload, ls-zoom, ls-cycle,
                 ls-activate-n, ls-nav, ls-menu, ls-check-update, ls-tab-menu, ls-reorder
       En macOS la ventana lleva el título en OVERLAY: esta barra ES la fila del título, así que
@@ -15,33 +16,60 @@
       (`data-tauri-drag-region`). En Windows hay título nativo aparte y no se reserva nada.
     -->
     <style>
-      /* Paleta estilo Chrome: la barra es una FRANJA más oscura y la pestaña activa es una
-         tarjeta del color del contenido que se funde con él (sin línea debajo). */
+      /* La barra se pinta del color de la APP, no del gris de Chrome: blanca en tema claro y
+         negra en oscuro, para que la ventana se lea como una sola pieza y no como una franja
+         de navegador pegada encima.
+         El truco de Chrome se conserva igual —la pestaña activa es una tarjeta del color del
+         CONTENIDO que se funde con él—, solo que ahora el contraste va al revés en oscuro: la
+         franja es más negra que el contenido, así que la activa destaca por ser más clara. La
+         diferencia es sutil a propósito; quien la marca de verdad es el borde inferior, que la
+         pestaña activa tapa con su propio fondo. */
       :root {
-        --bg: #dee1e6;          /* franja de pestañas (Chrome claro) */
+        --bg: #f4f5f7;          /* franja: casi blanca, del tono de la app en claro */
         --fg: #45474a;
         --muted: #5f6368;
-        --tab-active-bg: #ffffff;
+        --tab-active-bg: #ffffff;  /* mismo fondo que la app → pestaña fundida con el contenido */
         --tab-active-fg: #202124;
-        --accent: #6366f1;      /* indigo-500, color de Labstream */
-        --border: #c9ccd1;      /* línea bajo la barra (la tapa la pestaña activa) */
-        --hover: rgba(255, 255, 255, 0.55);  /* píldora de hover en pestañas inactivas */
+        --accent: #F47A20;      /* NARANJA Labstream (el índigo de antes no era de la marca) */
+        --border: #dcdee1;      /* línea bajo la barra (la tapa la pestaña activa) */
+        /* Sobre una franja casi blanca, un hover blanco no se vería: aquí oscurece. */
+        --hover: rgba(0, 0, 0, 0.06);
         --btn-hover: rgba(0, 0, 0, 0.08);
         --sep: rgba(0, 0, 0, 0.22);          /* separador fino entre pestañas inactivas */
       }
+      /* ── Quién decide el tema ──
+         La APP, no Windows: la web elige su modo con su propio botón (clase `dark` en su
+         <html>, defaultTheme claro, sin seguir al sistema), así que obedecer aquí al
+         prefers-color-scheme del sistema pintaba la barra negra sobre una app clara — el
+         bug de siempre. El script inyectado reporta el tema real, Rust lo reenvía en
+         `ls-tabs` (`dark`) y este documento se pone la clase `oscuro` o `claro`.
+         El bloque de medios queda SOLO como arranque en frío (primer arranque, sin
+         estado.json y sin reporte aún): en cuanto hay clase, la clase manda.
+         OJO: los valores oscuros van DOS veces (media query y .oscuro) — cambiarlos a la par. */
       @media (prefers-color-scheme: dark) {
-        :root {
-          --bg: #202124;        /* franja (Chrome oscuro) */
+        :root:not(.claro) {
+          --bg: #0d0d0f;        /* franja: negra, más oscura que el contenido */
           --fg: #bdc1c6;
           --muted: #80868b;
           --tab-active-bg: #18181b;  /* mismo fondo que la app → pestaña fundida con el contenido */
           --tab-active-fg: #e8eaed;
-          --border: #101013;
+          --border: #26262a;
           --hover: rgba(255, 255, 255, 0.08);
           --btn-hover: rgba(255, 255, 255, 0.1);
           --sep: rgba(255, 255, 255, 0.25);
         }
       }
+      :root.oscuro {
+        --bg: #0d0d0f;
+        --fg: #bdc1c6;
+        --muted: #80868b;
+        --tab-active-bg: #18181b;
+        --tab-active-fg: #e8eaed;
+        --border: #26262a;
+        --hover: rgba(255, 255, 255, 0.08);
+        --btn-hover: rgba(255, 255, 255, 0.1);
+        --sep: rgba(255, 255, 255, 0.25);
+      }
       * { box-sizing: border-box; }
       html, body {
         margin: 0;
@@ -81,10 +109,13 @@
         display: flex;
         align-items: center;
         gap: 7px;
-        /* Elástico como en Chrome: se reparten el ancho y se encogen al abrir más. */
+        /* Elástico como en Chrome: se reparten el ancho y se encogen al abrir más. El tope
+           sube a 280 px porque los títulos ahora traen nombre real y sección
+           («Hotjamin Orgánicos · Archivos»), y a 240 se cortaban de más. Con muchas pestañas
+           abiertas da igual: mandan el reparto y el modo compacto. */
         flex: 1 1 220px;
         min-width: 42px;
-        max-width: 240px;
+        max-width: 280px;
         height: 30px;
         margin-bottom: 5px;
         padding: 0 6px 0 10px;
@@ -158,9 +189,11 @@
       .tab[data-color]:not(.active)::before { display: none; }
       .tab[data-color].active { box-shadow: inset 0 3px 0 rgb(var(--tc)); }
       @media (prefers-color-scheme: dark) {
-        .tab[data-color]:not(.active) { background: rgba(var(--tc), 0.36); }
-        .tab[data-color]:not(.active):hover { background: rgba(var(--tc), 0.5); }
+        :root:not(.claro) .tab[data-color]:not(.active) { background: rgba(var(--tc), 0.36); }
+        :root:not(.claro) .tab[data-color]:not(.active):hover { background: rgba(var(--tc), 0.5); }
       }
+      :root.oscuro .tab[data-color]:not(.active) { background: rgba(var(--tc), 0.36); }
+      :root.oscuro .tab[data-color]:not(.active):hover { background: rgba(var(--tc), 0.5); }
       /* Reordenar arrastrando: NO se usa drag&drop de HTML5 (en el webview de la barra en
          macOS los eventos no llegan), sino eventos de puntero. Se apaga el arrastre nativo de
          WebKit para que no salga la imagen fantasma al mover una pestaña. */
@@ -498,6 +531,12 @@
         $pct.textContent = estado.zoom + "%";
         $pct.classList.toggle("activo", estado.zoom !== 100);
         $ver.textContent = estado.version ? "v" + estado.version : "";
+        // Tema: manda el de la APP (payload `dark`). Mientras Rust no sepa nada (null),
+        // no se pone clase y siguen las media queries del sistema como arranque en frío.
+        if (typeof estado.dark === "boolean") {
+          document.documentElement.classList.toggle("oscuro", estado.dark);
+          document.documentElement.classList.toggle("claro", !estado.dark);
+        }
         // En macOS la barra ES la fila del título: hay que dejar libre el semáforo.
         document.body.classList.toggle("mac", !!estado.mac);
         // En Windows también ES la fila del título, pero ahí los botones de ventana los

package.json

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

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "labstream-desktop"
-version = "1.6.0"
+version = "1.10.0"
 description = "Cliente de escritorio de Labstream OS"
 authors = ["Labstream SAS"]
 edition = "2021"
@@ -28,3 +28,30 @@ 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"
+
+# ── Excepción del video (Windows) ──
+# Para saber si «hay un video reproduciéndose» sin espiar el navegador: se mira el MEDIDOR de
+# la salida de audio por defecto (WASAPI, IAudioMeterInformation). Si al frente hay un navegador
+# y está saliendo sonido, es un video sonando → cuenta como navegador, no como inactividad.
+# Solo Windows: en macOS no hay API pública sencilla de nivel de audio por app (el equipo de
+# edición es Windows). El `windows` crate ya está en la caché por Tauri.
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.61", features = [
+    "Win32_Foundation",
+    "Win32_System_Com",
+    # IMMDevice::Activate exige AMBAS (su firma lleva un PROPVARIANT): sin ellas el método
+    # queda cfg'd out y «no existe». Verificado con cargo check --target windows-msvc.
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_Variant",
+    "Win32_Media_Audio",
+    "Win32_Media_Audio_Endpoints",
+] }

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};
@@ -97,11 +99,15 @@ struct Shell {
     // Último estado maximizado conocido. Solo sirve para no repintar la barra en CADA
     // evento de redimensión: únicamente cuando el icono ▢/❐ tiene que cambiar.
     maximized: bool,
+    // Tema REAL de la app (la clase `dark` de <html>, reportada por el script inyectado).
+    // Es global y no por pestaña: todas las pestañas del origen comparten el mismo modo
+    // (localStorage). None = ninguna pestaña ha reportado aún → la barra cae al del sistema.
+    dark: Option<bool>,
 }
 
 impl Default for Shell {
     fn default() -> Self {
-        Self { tabs: Vec::new(), active: 0, zoom_idx: ZOOM_100, next_id: 1, win: None, autostart: None, closed: Vec::new(), menu_tab: None, maximized: false }
+        Self { tabs: Vec::new(), active: 0, zoom_idx: ZOOM_100, next_id: 1, win: None, autostart: None, closed: Vec::new(), menu_tab: None, maximized: false, dark: None }
     }
 }
 
@@ -132,6 +138,10 @@ struct Persisted {
     active: usize,
     #[serde(default)]
     autostart: Option<bool>,
+    // Último tema conocido de la app: la barra abre ya del color correcto en vez de
+    // arrancar con el del sistema y dar un fogonazo al cargar la primera pestaña.
+    #[serde(default)]
+    dark: Option<bool>,
 }
 
 fn state_path<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
@@ -157,6 +167,7 @@ fn save_persisted<R: Runtime>(app: &AppHandle<R>) {
             colors: s.tabs.iter().map(|t| t.color.clone().unwrap_or_default()).collect(),
             active: s.active,
             autostart: s.autostart,
+            dark: s.dark,
         }
     };
     if let Some(dir) = path.parent() {
@@ -212,9 +223,39 @@ const INIT_JS_TPL: &str = r#"
   }
   function newTab(url) { emit('ls-new-tab', { url: url }); }
 
-  // Título y URL → barra de pestañas (y para restaurar la sesión al reabrir).
+  // ── ¿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 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 });
+    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');
@@ -233,6 +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 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) {
@@ -368,6 +421,8 @@ fn broadcast<R: Runtime>(app: &AppHandle<R>) {
             // que dibuja ella misma los botones minimizar/maximizar/cerrar (no hay nativos).
             "win": cfg!(target_os = "windows"),
             "maximized": maximized,
+            // Tema real de la app (null hasta el primer reporte: la barra usa el del sistema).
+            "dark": s.dark,
         })
     };
     let _ = app.emit_to(EventTarget::webview(CHROME), "ls-tabs", payload);
@@ -945,6 +1000,10 @@ fn field_i64(payload: &str, key: &str) -> Option<i64> {
     serde_json::from_str::<serde_json::Value>(payload).ok()?.get(key)?.as_i64()
 }
 
+fn field_bool(payload: &str, key: &str) -> Option<bool> {
+    serde_json::from_str::<serde_json::Value>(payload).ok()?.get(key)?.as_bool()
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     let mut builder = tauri::Builder::default();
@@ -994,6 +1053,7 @@ pub fn run() {
                 s.zoom_idx = saved.zoom_idx.unwrap_or(ZOOM_100).min(ZOOM_STEPS.len() - 1);
                 s.win = saved.win;
                 s.autostart = saved.autostart;
+                s.dark = saved.dark;
             }
 
             // Ventana principal (contenedora). Tamaño/posición de la sesión anterior si los hay.
@@ -1308,10 +1368,11 @@ pub fn run() {
             });
             let h = handle.clone();
             handle.listen_any("ls-title", move |e| {
-                let (label, title, url) = (
+                let (label, title, url, dark) = (
                     field(e.payload(), "label"),
                     field(e.payload(), "title"),
                     field(e.payload(), "url"),
+                    field_bool(e.payload(), "dark"),
                 );
                 if let Some(label) = label {
                     let shell = h.state::<ShellState>();
@@ -1324,16 +1385,24 @@ pub fn run() {
                             t.url = url;
                         }
                     }
+                    // El tema es global (todas las pestañas del origen comparten modo): el
+                    // último reporte manda, venga de la pestaña que venga.
+                    if let Some(dark) = dark {
+                        s.dark = Some(dark);
+                    }
                     drop(s);
                     broadcast(&h);
                     save_persisted(&h);
                 }
             });
 
-            // 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())
@@ -1346,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| {
@@ -1361,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,673 @@
+// ── 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()
+}
+
+// ── Excepción del video ──
+// ¿La ventana al frente es un NAVEGADOR? El servidor ya clasifica el sitio por el título; aquí
+// solo hace falta saber que es un navegador para aplicar la excepción del video. Se excluye el
+// host WebView2 (el motor de Edge embebido que usa ESTA misma app y otras de escritorio): no es
+// navegación de nadie, igual que en el servidor.
+fn es_navegador(app: &str) -> bool {
+    let a = app.to_lowercase();
+    if a.contains("webview") {
+        return false;
+    }
+    ["chrome", "brave", "edge", "firefox", "opera", "vivaldi"].iter().any(|n| a.contains(n))
+}
+
+// ¿Está saliendo SONIDO por la salida de audio por defecto? Es el proxy de «hay un video
+// reproduciéndose»: se lee el medidor de pico de WASAPI (IAudioMeterInformation) del dispositivo
+// de salida. No abre el navegador, no lee la pestaña, no graba nada — solo pregunta al sistema
+// si hay sonido saliendo AHORA. Un video mudo no se detecta (no suena); es el límite honesto de
+// medirlo desde fuera del navegador.
+#[cfg(windows)]
+fn hay_audio_sonando() -> bool {
+    use windows::Win32::Media::Audio::Endpoints::IAudioMeterInformation;
+    use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDeviceEnumerator, MMDeviceEnumerator};
+    use windows::Win32::System::Com::{CoCreateInstance, CLSCTX_ALL};
+    unsafe {
+        let Ok(enumerador) = CoCreateInstance::<_, IMMDeviceEnumerator>(&MMDeviceEnumerator, None, CLSCTX_ALL) else {
+            return false;
+        };
+        // eMultimedia = el endpoint que usan música y video (no el de comunicaciones).
+        let Ok(dispositivo) = enumerador.GetDefaultAudioEndpoint(eRender, eMultimedia) else {
+            return false; // sin dispositivo de salida (p. ej. sin tarjeta/monitor de audio)
+        };
+        let Ok(medidor) = dispositivo.Activate::<IAudioMeterInformation>(CLSCTX_ALL, None) else {
+            return false;
+        };
+        // Umbral pequeño para no dispararse con el ruido de fondo del silencio digital.
+        matches!(medidor.GetPeakValue(), Ok(pico) if pico > 0.01)
+    }
+}
+
+#[cfg(not(windows))]
+fn hay_audio_sonando() -> bool {
+    // macOS: no hay API pública sencilla de nivel de audio; la excepción del video no aplica aquí
+    // (el equipo de edición es Windows). Follow-up posible con CoreAudio. false = como siempre.
+    false
+}
+
+// ── 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 || {
+        // COM para este hilo: lo necesita la lectura del medidor de audio (WASAPI) de la
+        // excepción del video. Se hace UNA vez al arrancar el hilo; si ya estaba inicializado,
+        // devuelve S_FALSE y no pasa nada. En macOS no existe y se omite.
+        #[cfg(windows)]
+        unsafe {
+            use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+            let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+        }
+
+        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;
+
+            // ── Ventana al frente + excepción del VIDEO ──
+            // La ventana se lee cada tic mientras se mide (antes solo cuando había actividad):
+            // ahora hace falta AUNQUE se esté ocioso, para saber si al frente hay un video.
+            let ventana = if token_ok && !pausado {
+                active_win_pos_rs::get_active_window()
+                    .ok()
+                    .map(|v| (normaliza(&v.app_name, 80), normaliza(&v.title, 140)))
+            } else {
+                None
+            };
+            // Sin entrada PERO con un navegador al frente y sonido saliendo = un video
+            // reproduciéndose. El usuario lo pidió: eso NO es inactividad, cuenta como tiempo de
+            // navegador (abajo se acumula el bloque con a=0, porque no hubo entrada). Solo se
+            // consulta el audio en ese caso puntual (ocioso + navegador al frente), no en cada tic.
+            let viendo_video = ocioso
+                && ventana.as_ref().map(|(app, _)| es_navegador(app)).unwrap_or(false)
+                && hay_audio_sonando();
+            // La inactividad EFECTIVA: quieto de verdad, salvo que sea un video en primer plano.
+            // Todo lo de abajo (tramo de ocio, bandeja, acumulación) usa esta, no `ocioso`.
+            let ocioso_efectivo = ocioso && !viendo_video;
+
+            // ── 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 —o cuando
+            // arranca un video en primer plano, que cuenta como actividad de navegador. 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_efectivo && !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_efectivo && 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_efectivo;
+            }
+
+            // 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 viendo_video {
+                // Ocioso, pero con un video en primer plano: se cuenta como navegador.
+                "video en primer plano"
+            } else if ocioso_efectivo {
+                // 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();
+            }
+
+            // Se acumula la ventana al frente cuando NO hay inactividad efectiva: o sea, con
+            // actividad real, O con un video en primer plano (viendo_video → ocioso_efectivo es
+            // false). En el caso del video, `hubo_input` es false, así que el bloque suma
+            // segundos de navegador pero 0 activos — honesto: presente, sin teclear. Se usa la
+            // `ventana` ya leída arriba, sin volver a preguntar al sistema.
+            if token_ok && !pausado && !ocioso_efectivo {
+                if let Some((app_name, titulo)) = ventana.clone() {
+                    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.0",
+  "version": "1.10.0",
   "identifier": "co.labstream.os",
   "build": {
     "frontendDist": "../dist"