Licencia MIT de Labstream (LICENSE y LICENCIA-ES.md)

La app solo buscaba versión nueva al abrir: un equipo que la deja abierta de la mañana
a la noche se quedaba en la de la mañana (este PC seguía en la 1.20 con la 1.23
publicada, y Rellenar con IA no le llegaba). Ahora, cada hora, mira si hay una nueva
sin instalarla: la versión de la barra pasa a «Actualizar a vX» (en el color de la
marca) y avisa una vez por versión. Al pulsarlo instala, se reinicia y vuelve a abrir
las pestañas. No se reinicia sola en medio del trabajo.

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

.github/workflows/build.yml

@@ -51,6 +51,65 @@ jobs:
       - name: Generar iconos (desde app-icon.png)
         run: npm run icons
 
+      - name: Probar el cliente
+        run: npm test
+
+      # ── FIRMA DE macOS ──────────────────────────────────────────────────────────────────
+      # Hasta el 2026-09-19 este build NO firmaba la app de macOS: no se le pasaba ninguna
+      # identidad, así que el bundler de Tauri se saltaba `codesign` entero y el .dmg salía con
+      # la firma ad hoc que deja el enlazador. Se veía así en la app instalada:
+      #     flags=0x20002(adhoc,linker-signed) · Info.plist=not bound · Sealed Resources=none
+      # Consecuencias: los entitlements (micrófono, cámara, JIT) NO se aplicaban —el
+      # Entitlements.plist del repo era decoración—, el Info.plist y los recursos no iban
+      # sellados, y la app no se podía notarizar de ninguna manera.
+      #
+      # `APPLE_SIGNING_IDENTITY` decide qué pasa, y por eso se calcula aquí y no en el `env:`
+      # del paso de abajo: un secreto que no existe llega como cadena VACÍA, y Tauri
+      # interpreta `APPLE_CERTIFICATE=""` como «hay certificado» y revienta al importarlo.
+      # Solo se exporta lo que de verdad tiene valor.
+      #
+      #   · CON los secretos de Developer ID → firma real + notarizado + grapado.
+      #   · SIN ellos → identidad "-", que es la firma AD HOC: no engaña a Gatekeeper (habrá
+      #     que seguir abriendo con clic derecho), pero SÍ sella los recursos, ata el
+      #     Info.plist y aplica los entitlements. Estrictamente mejor que no firmar.
+      #
+      # El hardened runtime no se configura: en Tauri v2 `bundle.macOS.hardenedRuntime` ya
+      # viene en true, y es lo que hace que los entitlements signifiquen algo.
+      - name: Preparar la firma de macOS
+        if: matrix.platform == 'macos-latest'
+        shell: bash
+        env:
+          CERT: ${{ secrets.APPLE_CERTIFICATE }}
+          CERT_PW: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          NOTARIZA_ID: ${{ secrets.APPLE_ID }}
+          NOTARIZA_PW: ${{ secrets.APPLE_PASSWORD }}
+          NOTARIZA_TEAM: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          set -euo pipefail
+          # Los valores van por heredoc con delimitador: un base64 largo o con saltos rompería
+          # la forma `CLAVE=valor`. Nada se imprime: los secretos no pasan por el log.
+          exportar() { printf '%s<<__FIN__\n%s\n__FIN__\n' "$1" "$2" >> "$GITHUB_ENV"; }
+          if [ -n "${CERT:-}" ] && [ -n "${CERT_PW:-}" ]; then
+            exportar APPLE_CERTIFICATE "$CERT"
+            exportar APPLE_CERTIFICATE_PASSWORD "$CERT_PW"
+            exportar APPLE_SIGNING_IDENTITY "${IDENTITY:-Developer ID Application}"
+            echo "Firma: Developer ID (certificado del repo)."
+          else
+            exportar APPLE_SIGNING_IDENTITY "-"
+            echo "Firma: AD HOC. Sella recursos y aplica entitlements, pero Gatekeeper seguirá avisando."
+            echo "Para firma de verdad, añade los secrets APPLE_CERTIFICATE y APPLE_CERTIFICATE_PASSWORD."
+          fi
+          # Notarizar solo tiene sentido con Developer ID; las tres claves van juntas o ninguna.
+          if [ -n "${CERT:-}" ] && [ -n "${NOTARIZA_ID:-}" ] && [ -n "${NOTARIZA_PW:-}" ] && [ -n "${NOTARIZA_TEAM:-}" ]; then
+            exportar APPLE_ID "$NOTARIZA_ID"
+            exportar APPLE_PASSWORD "$NOTARIZA_PW"
+            exportar APPLE_TEAM_ID "$NOTARIZA_TEAM"
+            echo "Notarizado: activado."
+          else
+            echo "Notarizado: omitido (faltan APPLE_ID, APPLE_PASSWORD o APPLE_TEAM_ID, o no hay certificado)."
+          fi
+
       - name: Construir, firmar y publicar
         uses: tauri-apps/tauri-action@v0
         env:
@@ -58,11 +117,53 @@ jobs:
           # Firma del updater: la clave privada y su contraseña van como secrets del repo.
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+          # Las APPLE_* las puso el paso de arriba en $GITHUB_ENV, solo si tenían valor.
         with:
           # En un tag usa su nombre (v1.0.0); en ejecución manual, deriva vX.Y.Z de la versión.
           tagName: ${{ github.ref_type == 'tag' && github.ref_name || 'v__VERSION__' }}
           releaseName: "Labstream OS Desktop __VERSION__"
           releaseBody: "Instaladores de escritorio de Labstream OS.\n\n- Windows: el archivo `.exe` (NSIS).\n- macOS: el archivo `.dmg` universal (Intel + Apple Silicon).\n\nActualización automática activada: las apps ya instaladas se actualizan solas al publicar una versión nueva."
-          releaseDraft: false
+          releaseDraft: true
           prerelease: false
           args: ${{ matrix.args }}
+
+      # ── LA RED QUE FALTABA ──────────────────────────────────────────────────────────────
+      # Que el build no firmara la app de macOS no lo dijo nada durante meses: el .dmg salía,
+      # se instalaba y funcionaba. Se descubrió a mano, con `codesign -dv`, persiguiendo otra
+      # cosa. Este paso hace esa comprobación en cada publicación y TUMBA el build si los
+      # entitlements no llegaron: es barato y es el único aviso que habría existido.
+      - name: Comprobar la firma de macOS
+        if: matrix.platform == 'macos-latest'
+        shell: bash
+        run: |
+          set -euo pipefail
+          APP=$(find src-tauri/target/universal-apple-darwin/release/bundle/macos -maxdepth 1 -name "*.app" | head -1)
+          if [ -z "$APP" ]; then echo "::error::No apareció ningún .app donde se esperaba"; exit 1; fi
+          echo "== $APP =="
+          codesign -dv --verbose=4 "$APP" 2>&1 || true
+          echo "== entitlements =="
+          codesign -d --entitlements - --xml "$APP" 2>/dev/null | plutil -convert xml1 -o - - || true
+          echo "== integridad del bundle =="
+          codesign --verify --strict --verbose=2 "$APP"
+          # Gatekeeper: con firma ad hoc esto SIEMPRE dice «rejected», y es esperado. Se
+          # informa sin tumbar nada; lo que sí es obligatorio es lo de abajo.
+          echo "== Gatekeeper (informativo) =="
+          spctl -a -t exec -vv "$APP" 2>&1 || true
+          echo "== obligatorio: los entitlements tienen que estar =="
+          if ! codesign -d --entitlements - --xml "$APP" 2>/dev/null | grep -q "com.apple.security.cs.allow-jit"; then
+            echo "::error::La app salió SIN entitlements. Revisa el paso «Preparar la firma de macOS» y bundle.macOS.entitlements en tauri.conf.json."
+            exit 1
+          fi
+          echo "Entitlements aplicados."
+
+  activar:
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Publicar solo cuando ambos instaladores estan completos
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION=$(node -p "require('./package.json').version")
+          gh release edit "v$VERSION" --draft=false --latest

.github/workflows/check.yml

@@ -0,0 +1,105 @@
+name: Verificar compilación (sin publicar)
+
+# Comprueba que el shell COMPILA en Windows y macOS sin construir instaladores ni tocar
+# Releases. Sirve para revisar un cambio en una rama antes de etiquetar la versión: el
+# workflow de publicar solo se dispara con etiquetas `v*`, así que hasta ahora no había
+# forma de saber si algo compilaba sin publicarlo.
+on:
+  push:
+    branches-ignore:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read # solo lee el repo: no crea releases ni sube nada
+
+jobs:
+  check:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Clonar repo
+        uses: actions/checkout@v4
+
+      - name: Instalar Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Instalar Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      - name: Cache de Rust
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Instalar dependencias
+        run: npm install
+
+      - name: Probar el script del cliente
+        run: npm test
+
+      # build.rs de Tauri valida que existan los iconos que declara tauri.conf.json.
+      - name: Generar iconos (desde app-icon.png)
+        run: npm run icons
+
+      - name: cargo check
+        working-directory: src-tauri
+        run: cargo check --all-targets
+
+      # Avisa de errores reales de Clippy sin tumbar la verificación por avisos de estilo.
+      - name: cargo clippy (informativo)
+        working-directory: src-tauri
+        continue-on-error: true
+        run: cargo clippy --all-targets
+
+  # Instalador de PRUEBA para Windows. Queda colgado de la ejecución como artifact y no
+  # toca Releases ni el updater: sirve para VER el cambio funcionando antes de publicárselo
+  # a todo el equipo, que es irreversible en la práctica (las apps se actualizan solas).
+  instalador-prueba:
+    runs-on: windows-latest
+    steps:
+      - name: Clonar repo
+        uses: actions/checkout@v4
+
+      - name: Instalar Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Instalar Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache de Rust
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Instalar dependencias
+        run: npm install
+
+      - name: Generar iconos (desde app-icon.png)
+        run: npm run icons
+
+      # La firma hace falta porque tauri.conf.json pide artefactos de updater; el .exe se
+      # queda igualmente aquí, sin publicarse en ningún sitio.
+      - name: Construir el instalador (NSIS)
+        env:
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+        run: npm run tauri build -- --bundles nsis
+
+      - name: Guardar el instalador como artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: instalador-windows-prueba
+          path: src-tauri/target/release/bundle/nsis/*.exe
+          retention-days: 14

LICENCIA-ES.md

@@ -0,0 +1,40 @@
+# Licencia de las apps públicas de Labstream (resumen en español)
+
+Las apps marcadas como **públicas** en el catálogo se distribuyen bajo la **Licencia MIT**.
+El texto legal que vale es el de `LICENSE` (en inglés, como es habitual en esta licencia);
+esto es una explicación.
+
+## Qué puedes hacer
+
+- **Descargarlas, instalarlas y usarlas** gratis, para lo que quieras, también en trabajos
+  comerciales.
+- **Copiarlas, modificarlas y redistribuirlas**, enteras o en parte, con o sin cambios.
+- Incluirlas en otros programas, incluso de pago.
+
+## Única condición
+
+- Conservar el aviso de copyright y el texto de la licencia (`LICENSE`) en cualquier copia o
+  parte sustancial del programa.
+
+## Sin garantía
+
+Los programas se entregan **tal cual**, sin garantía de ningún tipo. Labstream S.A.S. no
+responde por daños derivados de su uso.
+
+## Lo que la licencia no cubre
+
+- La **marca Labstream** y su logotipo: puedes usar el código, no presentar otro producto como
+  si fuera de Labstream.
+- Las **apps privadas** y las **apps de clientes**: tienen las condiciones del contrato de cada
+  proyecto.
+- Los **componentes de terceros** que cada app incluye: tienen su propia licencia, listada en
+  el `TERCEROS.md` de cada repositorio.
+
+## Datos personales
+
+Las apps de escritorio públicas no envían datos a internet ni a Labstream. Las apps web
+guardan los datos en servidores de Labstream en Colombia y se rigen por la política de
+tratamiento de datos personales de Labstream S.A.S. (Ley 1581 de 2012 y Decreto 1377 de 2013).
+Consultas: hola@labstreamsas.com.
+
+Labstream S.A.S. · NIT 900.665.024-5 · Bogotá, Colombia

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Labstream S.A.S. (NIT 900.665.024-5), Bogotá, Colombia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -12,6 +12,42 @@ NAS. Esto le da al equipo un cliente nativo de verdad en Windows y Mac:
   la app** — antes morían en silencio. También ⌘/Ctrl+clic y clic central.
   Atajos: ⌘/Ctrl+T nueva, ⌘/Ctrl+W cerrar, Ctrl+Tab rotar, ⌘/Ctrl+1…9 ir a la n.
   La sesión (pestañas abiertas, activa) **se restaura** al reabrir.
+- **La barra de pestañas ES la fila del título** (v1.6.0), en Windows y en macOS:
+  no se gasta una franja entera en repetir el nombre de la app. En Windows la
+  ventana va sin decoración y la propia barra dibuja los botones minimizar /
+  maximizar / cerrar; en macOS el semáforo lo sigue pintando el sistema y la barra
+  le deja su hueco. El doble clic en el hueco libre maximiza y restaura.
+- **Colores de pestaña** (v1.6.0): clic derecho sobre una pestaña ▸ **Color**, con
+  la misma paleta de nueve tonos que usa Chrome para sus grupos. Sirve para agrupar
+  de un vistazo (todo lo de un cliente en verde) y **se guarda con la sesión**.
+- **Pestaña del color de su página** (v1.21.0): una página puede pedir el color de
+  su pestaña con `<html data-ls-pestana="#rrggbb">` (solo ese formato). El modo
+  edición de un set la pinta del gris del editor: activa se funde con su barra de
+  arriba y detrás se reconoce entre las demás. Esa página no cambia el tema de la
+  barra (su fondo oscuro no es el de la app).
+- **La IA del equipo** (v1.22.0, Windows con tarjeta NVIDIA): la máscara de «Sujeto» y
+  «Fondo» del editor de revelado la busca la app, no el navegador — ONNX Runtime con
+  DirectML sobre la tarjeta y BiRefNet en media precisión (`src-tauri/src/ia/`): 0,3 s
+  por foto en vez de 2,5–3 s. La primera vez baja ≈700 MB a los datos de la app
+  (`%LOCALAPPDATA%\<identificador>\ia`): ONNX Runtime 1.24.4 DirectML y DirectML 1.15.4
+  de NuGet y el modelo del servidor de la app (`/api/modelos/sujeto-equipo`, con la
+  sesión de la pestaña), todo fijado por huella SHA-256. La página llama a
+  `ia_estado` / `ia_preparar` / `ia_sujeto`, permitidos solo para el origen de la app
+  (`build.rs` + `capabilities/default.json`). El modelo se suelta de la tarjeta a los
+  2 min sin uso. Prueba de punta a punta en la tarjeta del equipo:
+  `LS_IA_DIR=<carpeta> cargo test --lib de_punta_a_punta -- --ignored --nocapture`.
+- **Rellenar** (v1.23.0, Windows): en Eliminar del editor de revelado, lo pintado lo
+  rellena LaMa (`src-tauri/src/ia/relleno.rs`, comando `ia_rellenar`) con lo que debería
+  haber detrás; la página lo guarda como un parche de la foto. Corre en la CPU (LaMa no
+  corre con DirectML: su FFT falla en la tarjeta): ~3 s a 512 px, ~10 s a 1024 (el tope).
+  La primera vez baja el motor (si no estaba) y el modelo (≈210 MB, del servidor de la
+  app con la sesión de la pestaña, fijado por huella). `ia_estado` / `ia_preparar` llevan
+  `{ que: "relleno" }`; sin él, hablan del sujeto (como la 1.22).
+- **Pestañas con nombre** (v1.21.0): `window.open(url, "ls-…")` o un enlace con
+  `target="ls-…"` abre la pestaña la primera vez y las siguientes **vuelven a
+  ella** en vez de abrir otra. La página recibe la URL nueva por
+  `window.__lsAbrir(url)` (el modo edición cambia de foto sin recargar); si no lo
+  tiene, navega. Nombre y color se guardan con la sesión.
 - **Zoom de interfaz**: ⌘/Ctrl `+` / `−` / `0` y Ctrl+rueda, con indicador en la
   barra y **persistencia** entre sesiones (50%–250%).
 - **Documentos dentro de la app**: los visores/editores del propio servidor
@@ -31,11 +67,114 @@ 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).
 
+- **Pestañas en reposo** (v1.19.0, solo Windows): cada pestaña es la web app entera, con su
+  conexión del chat y sus sondeos. Una que lleva 5 minutos oculta se **suspende** (WebView2
+  `TrySuspend`: deja de gastar CPU y el sistema puede recuperar su memoria) y despierta sola,
+  donde estaba, al volver a ella. No se duerme la activa, ni una con una subida, una descarga o
+  audio en curso, ni un editor de documentos (`/docs/`).
+
+- **Salud de la app** (v1.20.0, `src-tauri/src/salud.rs`): cuánto gasta de verdad, qué falla
+  y cómo se repone sola. Nada sale del equipo; todo queda en la carpeta de logs de la app
+  (⋮ ▸ *Abrir diagnóstico*, o desde la bandeja).
+  - **Recursos reales**: el exe es pequeño; el gasto está en la docena de procesos de WebView2
+    que cuelgan de él (uno por pestaña, GPU, utilidad), que el Administrador de tareas reparte.
+    Cada minuto se mide el árbol entero —memoria privada, CPU como la columna del Administrador
+    de tareas, número de procesos— y se ve en la bandeja y en ⋮ («Recursos: 2,1 GB · CPU 3 % ·
+    13 procesos»). Cada muestra va a `recursos.csv` (fecha, procesos, MB, CPU, pestañas,
+    dormidas): la curva de un día de trabajo real.
+  - **Diario de errores** (`salud.log`, rota a 2 MB): pánicos de Rust, procesos de WebView2
+    caídos o colgados, errores de JavaScript de las páginas (mensaje y archivo:línea, máx. 20
+    por carga y sin repetidos en un minuto), el hilo principal sin responder (ventana
+    congelada: cuándo y cuánto), fallos del actualizador y **cierres de golpe** (si al arrancar
+    sigue el testigo `en-marcha`, la sesión anterior no terminó bien).
+  - **Se repone sola**: pestaña cuyo proceso muere o se cuelga → se recarga (freno: 3 veces en
+    10 min; después avisa y la deja quieta). Si muere el proceso principal de WebView2 (caen
+    todas) → la app se reinicia sola. Windows la reabre si se cuelga o se cierra de golpe
+    (`RegisterApplicationRestart`). Con el árbol por encima de 3 GB se duermen **ya** las
+    pestañas ocultas (con las mismas reglas del reposo: nunca una con subida, descarga o audio).
+
+- **Ahorro de memoria** (v1.20.0, `src-tauri/src/memoria.rs`). Medido en el equipo de edición:
+  2,2 GB con 5 pestañas tras un día abierta, **1,3 GB de ellos en el proceso gráfico** de WebView2,
+  que crece con las horas y no devuelve nada (reiniciarlo a mano bajó la app a 1,1 GB sin perder
+  nada). Sin quitar funciones:
+  - **Al abrir solo se carga la pestaña activa**; las demás esperan en la barra con su título y
+    se cargan al hacer clic (como Chrome/Edge). Antes arrancaban todas a la vez.
+  - **Pestañas descartadas**: una que lleva 30 min dormida se cierra de verdad y vuelve a su URL
+    al activarla (1-2 s de carga). Nunca un editor de documentos ni una con subida, descarga o audio.
+  - **Nivel de memoria bajo** para lo que no se ve (pestañas ocultas; todo con la ventana en la
+    bandeja o minimizada): WebView2 suelta cachés que puede regenerar.
+  - **El proceso gráfico se recicla** al pasar de 600 MB, solo si nadie mira (ventana oculta o
+    minimizada, o 10 min sin tocar el equipo y sin sonido saliendo), como mucho cada 30 min.
+  - Lo que ya se guardaba en disco sigue igual: la caché HTTP (los archivos de la app vienen con
+    `immutable`, 1 año), el service worker de la web y el cajón de miniaturas (`cache.rs`).
+
+- **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-*`.
 
 El servidor objetivo se configura en `src-tauri/src/lib.rs` → constante `SERVER_URL`.
 
+### Portadas autenticadas (1.14.1)
+
+Las imagenes conservan su URL HTTPS y se cargan con la sesion del webview, igual
+que en el navegador. Ya no se reescriben a `lsthumb://`: el descargador Rust no
+comparte las cookies y fallaba con miniaturas sin token o con token vencido.
+Tampoco se modifica el DOM de las imagenes durante la hidratacion.
+
+Se usa la cache HTTP con los ETag y Cache-Control del servidor. Una respuesta
+304 reutiliza los bytes descargados; no implica fabricar otro fotograma. El
+cajon antiguo no se borra, pero no se usa para las nuevas peticiones de imagenes.
+No cambia el almacenamiento de originales, la cache HLS de LabTem ni los datos offline.
+
+Google Docs, Sheets, Drive y el inicio de sesion de Google se abren en el navegador
+del sistema. Google no admite OAuth en webviews controlados por una app; ademas,
+WKWebView no debe anunciarse como Chrome. Se conserva el agente de usuario nativo
+y no se borran cookies ni sesiones. Las hojas conectadas siguen disponibles como
+tabla dentro del area contable. Al reiniciar se restauran solo pestanas de Labstream.
+
+Pruebas: `npm test`; con Playwright disponible en Node,
+`node tests/images.browser.cjs` verifica sesion, 304, carga dinamica y lienzo.
+La prueba de navegador usa un servidor local y una cookie ficticia, sin datos reales.
+
 Salidas:
 
 - **Windows** → instalador `.exe` (NSIS).
@@ -133,39 +272,104 @@ el de Mac a la vez, así ambas plataformas van siempre sincronizadas.
 
 ---
 
-## Actualización automática (opcional, recomendable a futuro)
+## Actualización automática (ACTIVA)
 
-Hoy, para actualizar, el equipo descarga el nuevo instalador del Release y lo
+Las apps ya instaladas **se actualizan solas**: el updater consulta el `latest.json`
-reinstala encima. Para que las apps ya instaladas se actualicen solas, Tauri trae
+que publica cada Release, y los instaladores se firman en el CI con la clave privada
-un *updater* (funciona igual en Windows y Mac). Para activarlo (paso futuro):
+guardada como secret del repo (`TAURI_SIGNING_PRIVATE_KEY`). También se puede forzar
+la comprobación con clic en la versión de la barra, o desde el menú ⋮ ▸ *Buscar
+actualización…*.
 
-1. Genera el par de claves de firma:
+Al **abrir**, la app busca versión nueva y, si la hay, la instala y se reinicia sola. Con la
-   ```bash
+app **abierta** (desde la 1.24) mira cada hora sin instalar nada: si hay una nueva, la versión
-   npm run tauri signer generate -- -w ~/.tauri/labstream.key
+de la barra pasa a **«Actualizar a vX»** (en el color de la marca) y avisa una vez. Al pulsarlo
-   ```
+instala, se reinicia y vuelve a abrir las pestañas. No se reinicia sola en medio del trabajo:
-2. Añade el `plugin-updater` y la clave pública en `tauri.conf.json`, y guarda la
+se perdería lo que una página no hubiera guardado.
-   clave privada como **secret** en GitHub (`TAURI_SIGNING_PRIVATE_KEY`).
-3. Apunta el updater al `latest.json` que publica el Release.
 
-Se deja sin activar a propósito para que la **primera** versión compile sin
+> ⚠️ De ahí se sigue algo que conviene tener presente: **un commit en `main` no le
-configuración extra.
+> llega a nadie**. Mientras no exista la etiqueta `vX.Y.Z`, el CI no construye nada y
+> el updater no ve versión nueva. Y al revés: publicar una etiqueta **actualiza la app
+> de todo el equipo**, así que no es un paso que se dé a la ligera.
+
+## Probar un cambio antes de publicarlo
+
+`.github/workflows/check.yml` corre en cualquier rama que no sea `main` y **no publica
+nada**:
+
+- `cargo check` en Windows y macOS — comprueba que compila en las dos.
+- Un job aparte deja el **instalador `.exe` de prueba** como *artifact* de la ejecución
+  (14 días), para instalarlo encima y ver el cambio funcionando de verdad.
+
+Es la forma de mirar un cambio visual —la barra, los colores— sin sacárselo al equipo.
 
 ---
 
-## Avisos de seguridad del sistema (instalación interna sin firmar)
+## Firma de macOS
 
-Como los instaladores **no están firmados** con certificado de pago, la primera
+### Lo que pasaba hasta la 1.15.0
-vez cada sistema muestra una advertencia. Es normal para apps internas:
 
-- **Windows (SmartScreen):** pantalla azul *"Windows protegió su PC"* →
+El build **no firmaba** la app de macOS. No se le pasaba ninguna identidad, así que
-  **Más información → Ejecutar de todos modos**.
+el bundler de Tauri se saltaba `codesign` entero y el `.dmg` salía con la firma ad hoc
-- **macOS (Gatekeeper):** *"no se puede abrir porque proviene de un desarrollador
+que deja el enlazador. En la app instalada se veía así:
-  no identificado"* → clic derecho sobre la app → **Abrir** → **Abrir**. (Si
-  insiste, ejecutar una vez: `xattr -cr "/Applications/Labstream OS.app"`.)
 
-Si en el futuro se distribuye a clientes externos, conviene firmar:
+```
-*code signing* en Windows (~150–400 USD/año) y un *Apple Developer ID* + notarizado
+$ codesign -dv "/Applications/Labstream OS.app"
-en Mac (99 USD/año) para quitar estos avisos.
+Identifier=labstream_desktop-0a5819ba37119701
+CodeDirectory ... flags=0x20002(adhoc,linker-signed)
+Info.plist=not bound
+Sealed Resources=none
+TeamIdentifier=not set
+```
+
+Tres cosas mal, y ninguna avisaba:
+
+- **`Entitlements.plist` no se aplicaba.** Los permisos de micrófono, cámara y JIT
+  eran decoración: se escriben al firmar, y no se firmaba.
+- **`Info.plist=not bound` y `Sealed Resources=none`.** Ni el Info.plist ni los
+  recursos iban dentro de la firma: cualquiera podía cambiarlos sin romperla.
+- **Identificador de enlazador** (`labstream_desktop-<hash>`) en vez del de la app
+  (`co.labstream.os`), que es por lo que macOS recuerda los permisos concedidos.
+
+### Lo que hace ahora (desde la 1.16.0)
+
+`build.yml` decide según los secrets que haya en el repo:
+
+| Secrets | Resultado |
+| --- | --- |
+| ninguno | Firma **ad hoc** (`-s -`) con hardened runtime y los entitlements. Gatekeeper sigue avisando, pero el bundle va sellado y los permisos se aplican. |
+| `APPLE_CERTIFICATE` + `APPLE_CERTIFICATE_PASSWORD` | Firma real con **Developer ID**. Gatekeeper deja de avisar en cualquier Mac. |
+| …y además `APPLE_ID` + `APPLE_PASSWORD` + `APPLE_TEAM_ID` | Firma real + **notarizado y grapado**. Ni el primer arranque avisa. |
+
+Y hay un paso que **tumba la publicación** si los entitlements no llegaron al `.app`.
+Ese paso es la lección: que esto estuviera roto no lo dijo nada durante meses.
+
+### Pasar a Developer ID (99 USD/año)
+
+1. Alta en el Apple Developer Program.
+2. En *Certificates* crear uno de tipo **Developer ID Application** y exportarlo del
+   Llavero como `.p12` con contraseña.
+3. Convertirlo a texto: `base64 -i certificado.p12 | pbcopy`.
+4. En GitHub → *Settings ▸ Secrets and variables ▸ Actions*, añadir:
+   - `APPLE_CERTIFICATE` — lo que quedó en el portapapeles.
+   - `APPLE_CERTIFICATE_PASSWORD` — la contraseña del `.p12`.
+   - `APPLE_SIGNING_IDENTITY` — opcional; por defecto `Developer ID Application`.
+5. Para notarizar, además:
+   - `APPLE_ID` — el correo de la cuenta de desarrollador.
+   - `APPLE_PASSWORD` — una **contraseña específica de app** (appleid.apple.com, no la
+     del Apple ID).
+   - `APPLE_TEAM_ID` — el identificador de equipo de 10 caracteres.
+
+No hay que tocar ni un archivo: en cuanto los secrets existan, la siguiente etiqueta
+sale firmada.
+
+### Mientras siga ad hoc
+
+- **macOS (Gatekeeper):** *"no se puede abrir porque proviene de un desarrollador no
+  identificado"* → clic derecho sobre la app → **Abrir** → **Abrir**. (Si insiste:
+  `xattr -cr "/Applications/Labstream OS.app"`.)
+- **Windows (SmartScreen):** *"Windows protegió su PC"* → **Más información →
+  Ejecutar de todos modos**. Windows es aparte: su firma cuesta 150–400 USD/año y no
+  la toca nada de lo de arriba.
 
 ---
 
@@ -180,10 +384,10 @@ labstream-desktop/
 │   ├── tauri.conf.json          nombre, versión, iconos, instaladores, entitlements
 │   ├── Cargo.toml               dependencias Rust + versión
 │   ├── Info.plist               textos de permiso (micrófono/cámara) en macOS
-│   ├── Entitlements.plist       entitlements de macOS (audio-input, cámara, red)
+│   ├── Entitlements.plist       entitlements de macOS (micrófono, cámara, JIT)
 │   ├── build.rs
 │   ├── capabilities/default.json
 │   ├── icons/                   se generan desde app-icon.png
 │   └── src/{main.rs,lib.rs}     lib.rs crea la ventana + SERVER_URL + tray
-└── .github/workflows/build.yml  build automático de .exe (Windows) y .dmg (macOS)
+└── .github/workflows/build.yml  build de .exe (Windows) y .dmg (macOS) + firma de macOS
 ```

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,pagina}], 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,83 @@
       (`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
+      /* La barra se pinta del color de la APP, no del gris de Chrome: blanca en tema claro y
-         tarjeta del color del contenido que se funde con él (sin línea debajo). */
+         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 */
+        --accent: #F47A20;      /* NARANJA Labstream (el índigo de antes no era de la marca) */
-        --border: #c9ccd1;      /* línea bajo la barra (la tapa la pestaña activa) */
+        --border: #dcdee1;      /* 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 */
+        /* 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 */
+        --sep: rgba(0, 0, 0, 0.22);          /* aro del favicon mientras carga */
+        /* PROFUNDIDAD. La inactiva no lleva un relleno gris —un bloque sólido pesa y compite
+           con la activa— sino un velo casi imperceptible y una sombra INTERIOR: parece estar un
+           plano por debajo. Al pasar el ratón cambia de signo, la sombra sale hacia fuera y la
+           pestaña sube: por eso el hover va hacia el BLANCO de la activa y no hacia el gris. */
+        --tab-atras: rgba(0, 0, 0, 0.035);
+        --tab-atras-sombra: inset 0 1px 1.5px rgba(0, 0, 0, 0.055);
+        --tab-hover-bg: rgba(255, 255, 255, 0.85);
+        --tab-hover-sombra: 0 1px 3px rgba(0, 0, 0, 0.10);
+        --tab-activa-sombra: 0 -1px 4px rgba(0, 0, 0, 0.07);
       }
+      /* ── 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 {
+        :root:not(.claro) {
-          --bg: #202124;        /* franja (Chrome oscuro) */
+          --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);
+        /* En oscuro el movimiento es el mismo pero con luz: la inactiva se hunde con un velo
+           blanco muy tenue y una sombra negra dentro; al pasar el ratón sube hacia la luz. */
+        --tab-atras: rgba(255, 255, 255, 0.035);
+        --tab-atras-sombra: inset 0 1px 1.5px rgba(0, 0, 0, 0.35);
+        --tab-hover-bg: rgba(255, 255, 255, 0.10);
+        --tab-hover-sombra: 0 1px 3px rgba(0, 0, 0, 0.45);
+        --tab-activa-sombra: 0 -1px 4px rgba(0, 0, 0, 0.35);
         }
       }
+      :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);
+        /* En oscuro el movimiento es el mismo pero con luz: la inactiva se hunde con un velo
+           blanco muy tenue y una sombra negra dentro; al pasar el ratón sube hacia la luz. */
+        --tab-atras: rgba(255, 255, 255, 0.035);
+        --tab-atras-sombra: inset 0 1px 1.5px rgba(0, 0, 0, 0.35);
+        --tab-hover-bg: rgba(255, 255, 255, 0.10);
+        --tab-hover-sombra: 0 1px 3px rgba(0, 0, 0, 0.45);
+        --tab-activa-sombra: 0 -1px 4px rgba(0, 0, 0, 0.35);
+      }
       * { box-sizing: border-box; }
       html, body {
         margin: 0;
@@ -81,60 +132,93 @@
         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;
-        border-radius: 9px;         /* inactiva: píldora redondeada (hover) */
+        border-radius: 9px;         /* inactiva: píldora redondeada */
         position: relative;
-        overflow: visible;          /* deja asomar las curvas de la base de la activa */
+        overflow: visible;          /* las sombras viven fuera de la caja */
+        transition: background 140ms ease, box-shadow 140ms ease, color 140ms ease;
       }
-      .tab:not(.active):hover { background: var(--hover); }
+      /* ── PROFUNDIDAD: las que no mandan están detrás ──────────────────────────────────
-      /* Separador fino a la IZQUIERDA de cada inactiva; se oculta pegado a la activa,
+         Antes la inactiva no era nada: texto suelto sobre la franja, al mismo plano que la
-         al hover y en la primera (igual que Chrome). */
+         activa, y lo único que las separaba era un filete de 1px. Ahora la inactiva se HUNDE
-      .tab:not(.active)::before {
+         —velo tenue y sombra interior— y al pasar el ratón el gesto se invierte: la sombra sale
-        content: "";
+         hacia fuera y el fondo tira hacia el blanco de la activa, así que la pestaña sube hacia
-        position: absolute;
+         ti. Es sombra y no relleno a propósito: un bloque gris sólido pesa tanto como la activa
-        left: -1px;
+         y acaba compitiendo con ella.
-        top: 50%;
+         Con fondo propio el separador vertical entre pestañas sobra —ya se ve dónde acaba cada
-        transform: translateY(-50%);
+         una—, así que se retiró. */
-        width: 1px;
+      .tab:not(.active) {
-        height: 16px;
+        background: var(--tab-atras);
-        background: var(--sep);
+        box-shadow: var(--tab-atras-sombra);
+      }
+      .tab:not(.active):hover {
+        background: var(--tab-hover-bg);
+        box-shadow: var(--tab-hover-sombra);
+        color: var(--tab-active-fg);
       }
-      .tab:first-child::before,
-      .tab:hover::before,
-      .tab.active + .tab::before,
-      .tab:hover + .tab::before { display: none; }
       .tab.active {
         background: var(--tab-active-bg);
         color: var(--tab-active-fg);
         height: 35px;
         margin-bottom: 0;           /* su base cae 1px SOBRE el borde de la barra y lo tapa */
         border-radius: 10px 10px 0 0;
+        /* Levantada, apenas: la sombra va HACIA ARRIBA porque abajo la pestaña está fundida con
+           el contenido y una sombra ahí dibujaría una línea donde justamente no debe haberla. */
+        box-shadow: var(--tab-activa-sombra);
         z-index: 1;
       }
-      /* Curvas cóncavas de Chrome en la base de la pestaña activa: dos piezas de 8px con
+      /* AQUÍ ESTABAN LAS CURVAS CÓNCAVAS DE CHROME: dos piezas de 8px a los lados de la activa
-         un cuarto de círculo transparente que "derrama" el fondo hacia los lados. */
+         con un cuarto de círculo transparente que derramaba su fondo hacia fuera. El truco de
-      .tab.active::before,
+         Chrome funciona porque allí NO hay línea bajo la barra; aquí sí la hay, y esas dos
-      .tab.active::after {
+         piezas blancas la partían en dos justo a los costados de la pestaña — la «fluctuación»
-        content: "";
+         de la esquina. La activa ya se funde con el contenido por su propio fondo, que tapa la
-        position: absolute;
+         línea exactamente por su ancho; sin las piezas no asoma nada. */
-        bottom: 0;
+      /* ── Color de pestaña ────────────────────────────────────────────────────────────
-        width: 8px;
+         Misma idea que los grupos de Chrome: teñir para agrupar de un vistazo («todo lo de
-        height: 8px;
+         este cliente, en verde»). El color se elige con clic derecho sobre la pestaña ▸ Color,
-      }
+         y se guarda con la sesión.
-      .tab.active::before {
+         Va en componentes RGB sueltos (`--tc: r, g, b`) para sacar de UNA sola definición
-        left: -8px;
+         tanto el tono sólido como el fondo translúcido, sin repetir nueve colores por tema.
-        background: radial-gradient(circle at 0 0, transparent 8px, var(--tab-active-bg) 8.5px);
+         La pestaña ACTIVA no se tiñe entera: tiene que seguir fundida con el contenido, así
-      }
+         que lleva el color en una franja superior — igual que Chrome. */
-      .tab.active::after {
+      .tab[data-color="gris"]     { --tc: 95, 99, 104; }
-        right: -8px;
+      .tab[data-color="azul"]     { --tc: 26, 115, 232; }
-        background: radial-gradient(circle at 8px 0, transparent 8px, var(--tab-active-bg) 8.5px);
+      .tab[data-color="rojo"]     { --tc: 217, 48, 37; }
+      .tab[data-color="amarillo"] { --tc: 249, 171, 0; }
+      .tab[data-color="verde"]    { --tc: 30, 142, 62; }
+      .tab[data-color="rosa"]     { --tc: 208, 24, 132; }
+      .tab[data-color="morado"]   { --tc: 147, 52, 230; }
+      .tab[data-color="cian"]     { --tc: 0, 123, 131; }
+      .tab[data-color="naranja"]  { --tc: 250, 144, 62; }
+      .tab[data-color]:not(.active) { background: rgba(var(--tc), 0.18); }
+      .tab[data-color]:not(.active):hover { background: rgba(var(--tc), 0.32); }
+      .tab[data-color].active { box-shadow: inset 0 3px 0 rgb(var(--tc)); }
+      @media (prefers-color-scheme: dark) {
+        :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); }
+      /* ── La pestaña del COLOR DE SU PÁGINA (1.21) ──
+         La página lo pide (`<html data-ls-pestana="#262626">`): el modo edición de un set pinta la
+         suya del gris del editor. Activa, es de ese color y se funde con la barra de arriba de la
+         página, como la de siempre se funde con el blanco de la app. Detrás, el mismo color: entre
+         las demás se reconoce de un vistazo. Con color del menú encima, ese va de franja arriba.
+         (#tabs delante: gana a las reglas de tema y de color del menú sin !important.) */
+      #tabs .tab.pagina { --muted: color-mix(in srgb, var(--tp-fg) 60%, transparent); background: var(--tp); color: var(--tp-fg); }
+      #tabs .tab.pagina:not(.active) { box-shadow: none; }
+      #tabs .tab.pagina:not(.active):hover { background: color-mix(in srgb, var(--tp) 86%, var(--tp-fg)); color: var(--tp-fg); }
+      #tabs .tab.pagina .cerrar:hover { background: color-mix(in srgb, var(--tp-fg) 18%, transparent); color: var(--tp-fg); }
+      #tabs .tab.pagina[data-color] { box-shadow: inset 0 3px 0 rgb(var(--tc)); }
       /* 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. */
@@ -168,6 +252,11 @@
         overflow: hidden;
         text-overflow: ellipsis;
       }
+      /* La ACTIVA en negrilla: el relieve dice dónde está el plano de delante, pero el peso de
+         la letra es lo que se lee sin mirar. Va en el título y no en la pestaña entera para que
+         el aspa de cerrar no engorde con él. 600 y no 700: a este tamaño el bold entero
+         emborrona, y lo que hace falta es que destaque, no que grite. */
+      .tab.active .titulo { font-weight: 600; }
       .tab .cerrar {
         flex: 0 0 auto;
         width: 18px;
@@ -205,6 +294,17 @@
         height: 26px;
         font-size: 15px;
       }
+      /* «+» de nueva pestaña, DENTRO de la tira y pegado a la última pestaña (estilo Chrome).
+         Hereda de `button` (transparente, redondo, hover); solo fija tamaño, evita estirarse
+         y se separa un pelín de la última pestaña. Bottom-alineado con las pestañas. */
+      .nueva-tab {
+        flex: 0 0 auto;
+        width: 28px;
+        height: 28px;
+        margin: 0 2px 6px 4px;
+        font-size: 18px;
+        line-height: 1;
+      }
       #zoom {
         flex: 0 0 auto;
         display: flex;
@@ -233,6 +333,39 @@
         border-radius: 13px;
       }
       #version:hover { color: var(--accent); }
+      /* Hay una versión nueva publicada: el botón la ofrece (clic: instala y reinicia). */
+      #version.nueva {
+        color: #fff;
+        background: var(--accent);
+        font-weight: 600;
+        padding: 0 10px;
+      }
+      #version.nueva:hover { color: #fff; filter: brightness(1.1); }
+      /* ── Botones de ventana ──────────────────────────────────────────────────────────
+         Solo en Windows: allí la ventana va SIN decoración, así que esta barra es la fila
+         del título (como Chrome) y el aspa del sistema no existe. Medidas y colores del
+         propio Windows 11: 46 px de ancho, alto completo de la barra, esquinas rectas
+         hasta el borde, y rojo #c42b1c en el aspa al pasar por encima.
+         Los glifos salen de la fuente de iconos del sistema (Fluent en Win 11, MDL2 en 10). */
+      #wincontrols { display: none; }
+      body.win #wincontrols {
+        display: flex;
+        flex: 0 0 auto;
+        align-self: stretch;
+        margin-left: 6px;
+      }
+      /* Los botones tienen que morder el borde derecho: la barra cede su margen. */
+      body.win #bar { padding-right: 0; }
+      #wincontrols button {
+        width: 46px;
+        border-radius: 0;
+        color: var(--fg);
+        font-family: "Segoe Fluent Icons", "Segoe MDL2 Assets", system-ui;
+        font-size: 10px;
+        line-height: 1;
+      }
+      #wincontrols button:hover { background: var(--btn-hover); }
+      #w-cerrar:hover { background: #c42b1c; color: #fff; }
     </style>
   </head>
   <body>
@@ -241,8 +374,9 @@
     <div id="bar" data-tauri-drag-region>
       <button class="icono" id="atras" title="Atrás (⌘/Ctrl+[)">←</button>
       <button class="icono" id="adelante" title="Adelante (⌘/Ctrl+])">→</button>
+      <!-- El botón «+» de nueva pestaña ya NO va aquí fijo: se dibuja DENTRO de #tabs, pegado a
+           la última pestaña (estilo Chrome), en render(). Ver `.nueva-tab`. -->
       <div id="tabs" data-tauri-drag-region></div>
-      <button class="icono" id="nueva" title="Nueva pestaña (⌘/Ctrl+T)">+</button>
       <button class="icono" id="recargar" title="Recargar (⌘/Ctrl+R)">⟳</button>
       <div id="zoom">
         <button id="z-menos" title="Alejar (⌘/Ctrl+−)">−</button>
@@ -251,6 +385,12 @@
       </div>
       <button id="version" title="Versión de la app · clic: buscar actualización"></button>
       <button class="icono" id="menu" title="Opciones de la app">⋮</button>
+      <!-- Solo visibles en Windows (clase `win` del body): allí no hay barra de título. -->
+      <div id="wincontrols">
+        <button id="w-min" title="Minimizar">&#xE921;</button>
+        <button id="w-max" title="Maximizar">&#xE922;</button>
+        <button id="w-cerrar" title="Cerrar">&#xE8BB;</button>
+      </div>
     </div>
     <script>
       const T = window.__TAURI__;
@@ -264,6 +404,7 @@
       const $tabs = document.getElementById("tabs");
       const $pct = document.getElementById("z-pct");
       const $ver = document.getElementById("version");
+      const $wmax = document.getElementById("w-max");
 
       // Nombre + icono de cada pestaña a partir de su RUTA (mismas etiquetas que la barra
       // superior de la web). Sin esto todas las pestañas se llamaban «(25) Labstream OS» y
@@ -378,6 +519,14 @@
         $tabs.classList.toggle("compactas", ancho < 112);
       }
 
+      // ¿Un #rrggbb claro? (luminancia relativa): decide si la letra encima va oscura o clara.
+      function esClaro(hex) {
+        const n = parseInt(hex.slice(1), 16);
+        const lin = (c) => { c /= 255; return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4; };
+        const l = 0.2126 * lin((n >> 16) & 255) + 0.7152 * lin((n >> 8) & 255) + 0.0722 * lin(n & 255);
+        return l > 0.35;
+      }
+
       function render() {
         $tabs.textContent = "";
         for (const t of estado.tabs) {
@@ -385,6 +534,13 @@
           const el = document.createElement("div");
           el.className = "tab" + (t.active ? " active" : "");
           el.dataset.label = t.label;
+          if (t.color) el.dataset.color = t.color; // teñido desde el menú de la pestaña
+          // El color que pide la página (ya validado #rrggbb en el shell), con letra que se lea encima.
+          if (t.pagina) {
+            el.classList.add("pagina");
+            el.style.setProperty("--tp", t.pagina);
+            el.style.setProperty("--tp-fg", esClaro(t.pagina) ? "#202124" : "#ececec");
+          }
           el.title = texto;
 
           const fav = document.createElement("span");
@@ -431,6 +587,15 @@
 
           $tabs.appendChild(el);
         }
+        // El «+» de nueva pestaña, PEGADO a la última (estilo Chrome): al vivir dentro de #tabs
+        // como último elemento (flex 0 0 auto), queda justo tras la última pestaña en vez de
+        // fijo a la derecha de la barra. El hueco libre después de él sigue moviendo la ventana.
+        const mas = document.createElement("button");
+        mas.className = "nueva-tab";
+        mas.textContent = "+";
+        mas.title = "Nueva pestaña (⌘/Ctrl+T)";
+        mas.addEventListener("click", () => emitir("ls-new-tab", {}));
+        $tabs.appendChild(mas);
         requestAnimationFrame(ajustarCompactas);
 
         const activa = $tabs.querySelector(".tab.active");
@@ -438,9 +603,29 @@
 
         $pct.textContent = estado.zoom + "%";
         $pct.classList.toggle("activo", estado.zoom !== 100);
-        $ver.textContent = estado.version ? "v" + estado.version : "";
+        // Con una versión nueva esperando, el botón la ofrece; si no, la versión de ahora.
+        const nueva = estado.actualizacion || null;
+        $ver.textContent = nueva ? "Actualizar a v" + nueva : estado.version ? "v" + estado.version : "";
+        $ver.classList.toggle("nueva", !!nueva);
+        $ver.title = nueva
+          ? "Hay una versión nueva (" + nueva + "): clic para instalarla. La app se reinicia y vuelve a abrir tus pestañas."
+          : "Versión de la app · clic: buscar actualización";
+        // 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
+        // pinta esta barra: el del medio alterna entre maximizar (▢) y restaurar (❐).
+        document.body.classList.toggle("win", !!estado.win);
+        if (estado.win) {
+          const max = !!estado.maximized;
+          $wmax.textContent = max ? "\uE923" : "\uE922"; // ChromeRestore / ChromeMaximize
+          $wmax.title = max ? "Restaurar" : "Maximizar";
+        }
       }
 
       if (E) {
@@ -454,7 +639,6 @@
 
       document.getElementById("atras").addEventListener("click", () => emitir("ls-nav", { dir: -1 }));
       document.getElementById("adelante").addEventListener("click", () => emitir("ls-nav", { dir: 1 }));
-      document.getElementById("nueva").addEventListener("click", () => emitir("ls-new-tab", {}));
       document.getElementById("recargar").addEventListener("click", () => emitir("ls-reload", {}));
       // Menú de OPCIONES de la app (nativo, lo pinta Rust): botón ⋮ o clic derecho en la barra.
       document.getElementById("menu").addEventListener("click", () => emitir("ls-menu", {}));
@@ -466,10 +650,14 @@
       document.getElementById("z-menos").addEventListener("click", () => emitir("ls-zoom", { dir: -1 }));
       document.getElementById("z-mas").addEventListener("click", () => emitir("ls-zoom", { dir: 1 }));
       $pct.addEventListener("click", () => emitir("ls-zoom", { dir: 0 }));
-      // Doble clic en el hueco libre de la barra = pestaña nueva.
+      // Botones de ventana (Windows). Cerrar oculta a la bandeja, como el aspa de siempre.
-      $tabs.addEventListener("dblclick", (e) => {
+      document.getElementById("w-min").addEventListener("click", () => emitir("ls-window", { act: "min" }));
-        if (e.target === $tabs) emitir("ls-new-tab", {});
+      $wmax.addEventListener("click", () => emitir("ls-window", { act: "max" }));
-      });
+      document.getElementById("w-cerrar").addEventListener("click", () => emitir("ls-window", { act: "close" }));
+      // El doble clic en el hueco libre lo gobierna `data-tauri-drag-region`: maximiza y
+      // restaura, como la barra de título del sistema y como la de pestañas de Chrome.
+      // (Antes abría una pestaña nueva; ahora que la barra ES el título, chocaba con él.
+      // Para una pestaña nueva quedan el botón + y ⌘/Ctrl+T.)
 
       // Atajos también cuando el foco está en la barra.
       addEventListener("keydown", (e) => {

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "labstream-desktop",
-  "version": "1.4.0",
+  "version": "1.19.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "labstream-desktop",
-      "version": "1.4.0",
+      "version": "1.19.0",
       "devDependencies": {
         "@tauri-apps/cli": "^2"
       }

package.json

@@ -1,9 +1,10 @@
 {
   "name": "labstream-desktop",
-  "version": "1.5.1",
+  "version": "1.24.0",
   "private": true,
   "description": "App de escritorio (Windows) que envuelve Labstream OS — cliente del servidor del NAS.",
   "scripts": {
+    "test": "node --test tests/images.test.cjs",
     "icons": "tauri icon app-icon.png",
     "dev": "npm run icons && tauri dev",
     "build": "npm run icons && tauri build",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "labstream-desktop"
-version = "1.5.1"
+version = "1.24.0"
 description = "Cliente de escritorio de Labstream OS"
 authors = ["Labstream SAS"]
 edition = "2021"
@@ -28,3 +28,71 @@ tauri-plugin-updater = "2"
 tauri-plugin-single-instance = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+# ── Diálogo «Guardar como» de las descargas (on_download en create_tab, lib.rs) ──
+# rfd DIRECTO y no tauri-plugin-dialog: el manejador de descargas de wry exige la respuesta en
+# el mismo hilo y de forma síncrona (WebView2 DownloadStarting / WKDownload
+# decideDestination, ambos en el hilo principal). El `blocking_save_file()` del plugin monta
+# el diálogo ASÍNCRONO (rfd::AsyncFileDialog) y espera en un canal; en macOS ese diálogo se
+# presenta como hoja (beginSheetModalForWindow) y necesita que el run loop principal siga
+# girando… que es justo el hilo que está bloqueado esperando el canal → cuelgue. El
+# `rfd::FileDialog` síncrono corre un bucle modal anidado en el propio hilo
+# (IFileDialog::Show / NSSavePanel.runModal), que es lo que hace falta aquí.
+# Mismas features que usa el plugin oficial (common-controls-v6 = estilo moderno en Windows).
+rfd = { version = "0.17", default-features = false, features = ["common-controls-v6"] }
+# Para decodificar el último segmento de la URL cuando no hay nombre sugerido (macOS).
+percent-encoding = "2"
+# ── 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"
+ureq = { version = "2", features = ["json"] }
+gethostname = "0.5"
+# ── La IA del equipo (src/ia, 1.22) ──
+# sha2: la huella de lo que se baja (modelo y motor); zip: sacar las DLL del paquete del motor.
+sha2 = "0.10"
+zip = { version = "4", default-features = false, features = ["deflate"] }
+
+# device_query solo en Windows/Linux: la huella de entrada (posición del mouse + cuántas teclas
+# hay presionadas). En macOS NO se usa —leer el teclado global dispara el permiso de
+# Accesibilidad y el diálogo «… quiere controlar este ordenador»— y se sustituye por
+# CGEventSourceSecondsSinceLastEventType (idle_seconds_macos en tracker.rs), que no pide permiso.
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+device_query = "4"
+
+# ── 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]
+# IA del equipo (1.22, src/ia/motor.rs): ONNX Runtime con DirectML sobre la tarjeta. `load-dynamic`:
+# nada se enlaza al compilar; la DLL (la de DirectML 1.24, de NuGet) se baja la primera vez y se
+# carga desde la carpeta de la IA. `api-24`: la versión de la API que trae esa DLL.
+ort = { version = "=2.0.0-rc.14", default-features = false, features = ["std", "load-dynamic", "directml", "api-24"] }
+# Pestañas en reposo (1.19): ICoreWebView2_3::TrySuspend. Es la misma versión que ya trae Tauri.
+webview2-com = "0.38"
+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",
+    # Salud (1.20): medir el árbol de procesos (exe + WebView2) y el reinicio automático de Windows.
+    "Win32_System_Diagnostics_ToolHelp",
+    "Win32_System_ProcessStatus",
+    "Win32_System_Threading",
+    "Win32_System_Recovery",
+    # Memoria (1.20): ¿cuánto lleva el equipo sin tocar? (para reciclar el proceso gráfico sin que se note)
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_System_SystemInformation",
+    # IA del equipo (1.22): ¿hay tarjeta NVIDIA? (los adaptadores de DXGI)
+    "Win32_Graphics_Dxgi",
+    # y cargar DirectML.dll por su ruta antes que ONNX Runtime (src/ia/motor.rs)
+    "Win32_System_LibraryLoader",
+] }

src-tauri/Entitlements.plist

@@ -1,17 +1,39 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!--
+  ENTITLEMENTS DE macOS.
+
+  OJO AL ESCRIBIR AQUÍ: nada de dos guiones seguidos dentro de un comentario. XML los prohíbe,
+  y el que lee este archivo NO es plutil (que los deja pasar) sino AMFI, dentro de codesign,
+  que se planta con «Failed to parse entitlements». Por eso abajo las opciones de codesign se
+  nombran sin sus guiones.
+
+  Estas claves solo sirven de algo si la app se FIRMA pasándole este archivo y con el hardened
+  runtime puesto. Hasta el 2026-09-19 no era el caso: el build no firmaba nada y la app salía
+  con la firma ad hoc del enlazador (flags=0x20002 adhoc linker-signed, Info.plist sin atar,
+  recursos sin sellar). O sea, este archivo era decoración. Lo que lo arregla está en
+  .github/workflows/build.yml.
+
+  Son entitlements del HARDENED RUNTIME, no del App Sandbox (esta app no usa sandbox). El
+  hardened runtime cierra por defecto el micrófono, la cámara y la memoria ejecutable; cada
+  clave vuelve a abrir una, y sin ella la función no falla con un error claro: simplemente no
+  hay permiso.
+
+  Se cayó com.apple.security.network.client: esa es exclusiva del App Sandbox y, sin
+  com.apple.security.app-sandbox, no hace absolutamente nada. Si algún día se mete la app en el
+  sandbox, vuelve, junto con las de acceso a archivos que harán falta.
+-->
 <plist version="1.0">
 <dict>
-	<!-- Micrófono: notas de voz del chat (getUserMedia en el webview). -->
+	<!-- Micrófono: notas de voz del chat (getUserMedia en el webview). El texto que ve la
+	     persona al conceder el permiso vive en Info.plist (NSMicrophoneUsageDescription). -->
 	<key>com.apple.security.device.audio-input</key>
 	<true/>
-	<!-- Cámara: adjuntar foto/video en el chat. -->
+	<!-- Cámara: adjuntar foto y video en el chat (NSCameraUsageDescription). -->
 	<key>com.apple.security.device.camera</key>
 	<true/>
-	<!-- Cliente de red (conecta con os.labstreamsas.com). -->
+	<!-- WKWebView compila JavaScript en caliente. Bajo hardened runtime eso es memoria
-	<key>com.apple.security.network.client</key>
+	     ejecutable y hay que pedirlo explícitamente. -->
-	<true/>
-	<!-- Requerido por WKWebView (JIT de JavaScript) bajo hardened runtime. -->
 	<key>com.apple.security.cs.allow-jit</key>
 	<true/>
 </dict>

src-tauri/build.rs

@@ -1,3 +1,9 @@
 fn main() {
-    tauri_build::build()
+    // Los comandos de la app (la IA del equipo, src/ia): con su manifiesto, cada uno necesita su
+    // permiso en capabilities/default.json, y es lo que deja que la página remota los llame.
+    tauri_build::try_build(
+        tauri_build::Attributes::new()
+            .app_manifest(tauri_build::AppManifest::new().commands(&["ia_estado", "ia_preparar", "ia_sujeto", "ia_rellenar"])),
+    )
+    .expect("tauri-build");
 }

src-tauri/capabilities/default.json

@@ -18,6 +18,10 @@
     "core:default",
     "opener:default",
     "notification:default",
-    "core:window:allow-start-dragging"
+    "core:window:allow-start-dragging",
+    "allow-ia-estado",
+    "allow-ia-preparar",
+    "allow-ia-sujeto",
+    "allow-ia-rellenar"
   ]
 }

src-tauri/permissions/autogenerated/ia_estado.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-ia-estado"
+description = "Enables the ia_estado command without any pre-configured scope."
+commands.allow = ["ia_estado"]
+
+[[permission]]
+identifier = "deny-ia-estado"
+description = "Denies the ia_estado command without any pre-configured scope."
+commands.deny = ["ia_estado"]

src-tauri/permissions/autogenerated/ia_preparar.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-ia-preparar"
+description = "Enables the ia_preparar command without any pre-configured scope."
+commands.allow = ["ia_preparar"]
+
+[[permission]]
+identifier = "deny-ia-preparar"
+description = "Denies the ia_preparar command without any pre-configured scope."
+commands.deny = ["ia_preparar"]

src-tauri/permissions/autogenerated/ia_rellenar.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-ia-rellenar"
+description = "Enables the ia_rellenar command without any pre-configured scope."
+commands.allow = ["ia_rellenar"]
+
+[[permission]]
+identifier = "deny-ia-rellenar"
+description = "Denies the ia_rellenar command without any pre-configured scope."
+commands.deny = ["ia_rellenar"]

src-tauri/permissions/autogenerated/ia_sujeto.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-ia-sujeto"
+description = "Enables the ia_sujeto command without any pre-configured scope."
+commands.allow = ["ia_sujeto"]
+
+[[permission]]
+identifier = "deny-ia-sujeto"
+description = "Denies the ia_sujeto command without any pre-configured scope."
+commands.deny = ["ia_sujeto"]

src-tauri/src/cache.rs

@@ -0,0 +1,339 @@
+// ── El «cajón» de miniaturas de la app ──
+//
+// El problema que resuelve: las webviews guardan las imágenes en un caché del SISTEMA que es
+// pequeño y volátil — el sistema lo vacía cuando necesita espacio. En un Mac del equipo se
+// midieron 22 MB; un solo set de 500 fotos, entre cuadrícula y visor, pasa de 150 MB. No cabe,
+// se borra solo, y al reabrir la app hay que volver a bajarlo todo del NAS. Eso es lo que se
+// siente como «se relee cada vez que cierro».
+//
+// El cajón es un caché PROPIO de la app, en su carpeta interna (`app_cache_dir`, invisible en el
+// Finder), con un tope que decidimos nosotros y una poda por antigüedad — igual que la que el NAS
+// ya hace con sus miniaturas. Sobrevive a cerrar la app y se vacía con un botón.
+//
+// Cómo se usa: la web app, DENTRO de la app de escritorio, pide las miniaturas por el esquema
+// `lsthumb://` en vez de directamente al servidor (lo reescribe el script de inicio). Este módulo
+// es quien contesta ese esquema: si la miniatura está en el cajón la sirve del disco sin tocar la
+// red; si no, la trae del NAS una vez, la guarda y la sirve.
+//
+// La clave del cajón NO incluye el token firmado de la URL (que rota cada 24 h): se deriva de la
+// identidad estable de la miniatura (la ruta + su variante), así que la misma foto acierta en el
+// cajón un mes después. El token solo se usa para ir a buscarla al NAS cuando falta.
+
+use std::fs;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::{Duration, SystemTime};
+
+use tauri::{AppHandle, Manager, Runtime};
+
+// El único servidor del que este cajón acepta traer bytes. Sin este cerrojo, una URL manipulada
+// convertiría la app en un proxy abierto que trae cualquier cosa de internet (un SSRF). Se compara
+// por ORIGEN exacto (esquema + host + puerto), no por «empieza por».
+const SERVER: &str = "https://os.labstreamsas.com";
+
+// Tope del cajón: 3 GB, una sesión grande entera de miniaturas. Al pasarse, se borra lo más viejo
+// (por último uso) hasta bajar del tope. Es el mismo criterio y tamaño que el caché del NAS.
+const CAP_BYTES: u64 = 3 * 1024 * 1024 * 1024;
+
+// Recorrer el directorio para podar es caro: no se hace en cada escritura, sino cada N.
+const PODA_CADA: u32 = 200;
+static DESDE_PODA: AtomicU32 = AtomicU32::new(0);
+
+// Subcarpeta del caché de la app donde vive el cajón.
+const DIR: &str = "miniaturas";
+
+// ── Piezas PURAS (probadas abajo) ─────────────────────────────────────────────
+
+// ¿Se puede traer esta URL? Solo el origen del servidor, y solo rutas de su API. Cualquier otra
+// cosa se rechaza: el cajón no es un proxy de propósito general.
+pub fn permitido(url: &str) -> bool {
+    let (Ok(u), Ok(srv)) = (tauri::Url::parse(url), tauri::Url::parse(SERVER)) else {
+        return false;
+    };
+    u.origin() == srv.origin() && u.path().starts_with("/api/")
+}
+
+// La clave estable de una miniatura: su ruta + los parámetros que la IDENTIFICAN, ordenados, y
+// SIN el token `t` (que rota). Se resume con FNV-1a a un nombre corto y seguro para el sistema de
+// archivos. Que no lleve el token es lo que hace que el cajón siga acertando cuando el token de la
+// página cambió: la foto es la misma.
+pub fn clave_de(url: &str) -> Option<String> {
+    let u = tauri::Url::parse(url).ok()?;
+    let mut params: Vec<(String, String)> = u
+        .query_pairs()
+        .filter(|(k, _)| k != "t") // el token NO forma parte de la identidad
+        .map(|(k, v)| (k.into_owned(), v.into_owned()))
+        .collect();
+    params.sort();
+    let mut base = u.path().to_string();
+    for (k, v) in &params {
+        base.push('|');
+        base.push_str(k);
+        base.push('=');
+        base.push_str(v);
+    }
+    Some(fnv1a_hex(&base))
+}
+
+// Saca el parámetro `u` (la URL real del servidor, percent-encoded) de la URI del esquema. Funciona
+// sea cual sea la forma que la plataforma le dé al esquema — `lsthumb://c/?u=…` en macOS,
+// `http://lsthumb.localhost/…?u=…` en Windows —: en ambas `u` viaja como parámetro de consulta y
+// query_pairs lo decodifica.
+pub fn url_pedida(uri: &str) -> Option<String> {
+    tauri::Url::parse(uri)
+        .ok()?
+        .query_pairs()
+        .find(|(k, _)| k == "u")
+        .map(|(_, v)| v.into_owned())
+}
+
+fn fnv1a_hex(s: &str) -> String {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for b in s.as_bytes() {
+        h ^= *b as u64;
+        h = h.wrapping_mul(0x100000001b3);
+    }
+    format!("{h:016x}")
+}
+
+// Un archivo del cajón, para decidir la poda.
+#[derive(Clone)]
+struct Entrada {
+    ruta: PathBuf,
+    bytes: u64,
+    usado: SystemTime,
+}
+
+// La POLÍTICA de poda, aislada del disco para poder probarla: dado el contenido del cajón y el
+// tope, devuelve qué archivos borrar — los MÁS VIEJOS por último uso, hasta que el total baje del
+// tope. Si ya cabe, no borra nada.
+fn plan_de_poda(mut items: Vec<Entrada>, cap: u64) -> Vec<PathBuf> {
+    let total: u64 = items.iter().map(|e| e.bytes).sum();
+    if total <= cap {
+        return Vec::new();
+    }
+    // Más viejo primero (el primero en salir).
+    items.sort_by_key(|e| e.usado);
+    let mut sobra = total - cap;
+    let mut a_borrar = Vec::new();
+    for e in items {
+        if sobra == 0 {
+            break;
+        }
+        a_borrar.push(e.ruta);
+        sobra = sobra.saturating_sub(e.bytes);
+    }
+    a_borrar
+}
+
+// ── Disco ──────────────────────────────────────────────────────────────────────
+
+fn dir<R: Runtime>(app: &AppHandle<R>) -> Option<PathBuf> {
+    let base = app.path().app_cache_dir().ok()?;
+    Some(base.join(DIR))
+}
+
+// Lee una miniatura del cajón. `None` = no está (o no se pudo leer): el que llama irá al NAS.
+pub fn leer<R: Runtime>(app: &AppHandle<R>, clave: &str) -> Option<Vec<u8>> {
+    let ruta = dir(app)?.join(clave);
+    fs::read(&ruta).ok()
+}
+
+// Guarda una miniatura en el cajón (escritura atómica: se escribe a un temporal y se renombra, así
+// una lectura nunca ve un archivo a medias). Cada cierto número de escrituras, poda.
+pub fn escribir<R: Runtime>(app: &AppHandle<R>, clave: &str, bytes: &[u8]) {
+    let Some(d) = dir(app) else { return };
+    if fs::create_dir_all(&d).is_err() {
+        return;
+    }
+    let destino = d.join(clave);
+    let tmp = d.join(format!("{clave}.tmp"));
+    if fs::write(&tmp, bytes).is_ok() {
+        let _ = fs::rename(&tmp, &destino);
+    }
+    if DESDE_PODA.fetch_add(1, Ordering::Relaxed) + 1 >= PODA_CADA {
+        DESDE_PODA.store(0, Ordering::Relaxed);
+        podar(&d);
+    }
+}
+
+fn podar(d: &Path) {
+    let Ok(rd) = fs::read_dir(d) else { return };
+    let mut items = Vec::new();
+    for e in rd.flatten() {
+        let Ok(meta) = e.metadata() else { continue };
+        if !meta.is_file() {
+            continue;
+        }
+        let nombre = e.file_name();
+        if nombre.to_string_lossy().ends_with(".tmp") {
+            continue; // un temporal a medio escribir no se poda ni se cuenta
+        }
+        // Último uso: la fecha de acceso si el sistema la lleva, si no la de modificación.
+        let usado = meta.accessed().or_else(|_| meta.modified()).unwrap_or(SystemTime::UNIX_EPOCH);
+        items.push(Entrada { ruta: e.path(), bytes: meta.len(), usado });
+    }
+    for ruta in plan_de_poda(items, CAP_BYTES) {
+        let _ = fs::remove_file(ruta);
+    }
+}
+
+// Cuánto ocupa el cajón, en bytes (para la etiqueta «Vaciar caché (NN MB)» del menú).
+pub fn tamano<R: Runtime>(app: &AppHandle<R>) -> u64 {
+    let Some(d) = dir(app) else { return 0 };
+    let Ok(rd) = fs::read_dir(&d) else { return 0 };
+    rd.flatten()
+        .filter_map(|e| e.metadata().ok())
+        .filter(|m| m.is_file())
+        .map(|m| m.len())
+        .sum()
+}
+
+// Vacía el cajón entero. No pierde nada importante: se vuelve a llenar solo con el uso.
+pub fn vaciar<R: Runtime>(app: &AppHandle<R>) {
+    if let Some(d) = dir(app) {
+        let _ = fs::remove_dir_all(&d);
+        let _ = fs::create_dir_all(&d);
+    }
+}
+
+// ── Traer del NAS (solo cuando falta en el cajón) ───────────────────────────────
+
+// Tope de lo que se acepta bajar por miniatura. Una miniatura webp pesa cientos de KB; 64 MB es un
+// techo absurdo a propósito, solo para que una respuesta descomunal no llene la memoria.
+const MAX_DESCARGA: u64 = 64 * 1024 * 1024;
+
+// Trae los bytes de una miniatura del servidor. Devuelve `(bytes, es_webp)`: solo se GUARDAN en el
+// cajón las que son webp (lo único que este esquema pide); una respuesta de otro tipo se sirve tal
+// cual pero no se cachea. `Err(codigo)` = no se pudo traer (para que la imagen quede rota como
+// quedaría sin la app, no en blanco).
+pub fn traer(url: &str) -> Result<(Vec<u8>, bool), u16> {
+    let resp = match ureq::get(url).timeout(Duration::from_secs(30)).call() {
+        Ok(r) => r,
+        Err(ureq::Error::Status(code, _)) => return Err(code),
+        Err(_) => return Err(502), // sin red o error de transporte
+    };
+    let es_webp = resp
+        .header("Content-Type")
+        .map(|c| c.starts_with("image/webp"))
+        .unwrap_or(false);
+    let mut bytes = Vec::new();
+    resp.into_reader()
+        .take(MAX_DESCARGA)
+        .read_to_end(&mut bytes)
+        .map_err(|_| 502u16)?;
+    Ok((bytes, es_webp))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[test]
+    fn url_pedida_saca_y_decodifica_la_url_real() {
+        let real = "https://os.labstreamsas.com/api/files-asset/abc?t=1.x&thumb=1";
+        let uri = format!("lsthumb://c/?u={}", urlencoding_min(real));
+        assert_eq!(url_pedida(&uri).as_deref(), Some(real));
+        // Y también la forma que podría tomar en Windows.
+        let uri_win = format!("http://lsthumb.localhost/?u={}", urlencoding_min(real));
+        assert_eq!(url_pedida(&uri_win).as_deref(), Some(real));
+    }
+
+    #[test]
+    fn url_pedida_sin_u_es_none() {
+        assert_eq!(url_pedida("lsthumb://c/?otra=cosa"), None);
+    }
+
+    // Percent-encoding mínimo para las pruebas (: / ? & =), suficiente para estos casos.
+    fn urlencoding_min(s: &str) -> String {
+        s.chars()
+            .map(|c| match c {
+                ':' => "%3A".into(),
+                '/' => "%2F".into(),
+                '?' => "%3F".into(),
+                '&' => "%26".into(),
+                '=' => "%3D".into(),
+                c => c.to_string(),
+            })
+            .collect()
+    }
+
+    #[test]
+    fn permitido_solo_el_servidor_y_su_api() {
+        assert!(permitido("https://os.labstreamsas.com/api/files-asset/abc?t=1.x&thumb=1"));
+        // Otro host, aunque diga labstream: NO.
+        assert!(!permitido("https://malo.labstreamsas.com.attacker.net/api/x"));
+        // El servidor pero fuera de /api/: NO (nada de rutas arbitrarias).
+        assert!(!permitido("https://os.labstreamsas.com/etc/passwd"));
+        // http en vez de https: distinto origen, NO.
+        assert!(!permitido("http://os.labstreamsas.com/api/x"));
+        // Basura: NO.
+        assert!(!permitido("no-soy-una-url"));
+    }
+
+    #[test]
+    fn la_clave_ignora_el_token_que_rota() {
+        // La MISMA miniatura con dos tokens distintos (mañana, pasado) → la misma clave.
+        let hoy = clave_de("https://os.labstreamsas.com/api/files-asset/abc?t=1000.aaa&thumb=1");
+        let man = clave_de("https://os.labstreamsas.com/api/files-asset/abc?t=2000.bbb&thumb=1");
+        assert!(hoy.is_some());
+        assert_eq!(hoy, man, "el token no debe formar parte de la clave");
+    }
+
+    #[test]
+    fn la_clave_distingue_foto_y_variante() {
+        let mini = clave_de("https://os.labstreamsas.com/api/files-asset/abc?t=1.x&thumb=1").unwrap();
+        let xl = clave_de("https://os.labstreamsas.com/api/files-asset/abc?t=1.x&thumb=xl").unwrap();
+        let otra = clave_de("https://os.labstreamsas.com/api/files-asset/def?t=1.x&thumb=1").unwrap();
+        assert_ne!(mini, xl, "la miniatura y el visor son distintos");
+        assert_ne!(mini, otra, "dos fotos distintas son claves distintas");
+    }
+
+    #[test]
+    fn la_clave_no_depende_del_orden_de_los_parametros() {
+        let a = clave_de("https://os.labstreamsas.com/api/files-asset/abc?thumb=1&t=1.x").unwrap();
+        let b = clave_de("https://os.labstreamsas.com/api/files-asset/abc?t=1.x&thumb=1").unwrap();
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn la_clave_es_segura_para_el_sistema_de_archivos() {
+        let k = clave_de("https://os.labstreamsas.com/api/files-asset/abc?thumb=1").unwrap();
+        assert!(k.chars().all(|c| c.is_ascii_hexdigit()), "clave = {k}");
+    }
+
+    fn e(ruta: &str, bytes: u64, hace_segundos: u64) -> Entrada {
+        Entrada {
+            ruta: PathBuf::from(ruta),
+            bytes,
+            usado: SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000 - hace_segundos),
+        }
+    }
+
+    #[test]
+    fn poda_no_borra_nada_si_cabe() {
+        let items = vec![e("a", 100, 10), e("b", 100, 5)];
+        assert!(plan_de_poda(items, 1000).is_empty());
+    }
+
+    #[test]
+    fn poda_borra_lo_mas_viejo_primero_hasta_bajar_del_tope() {
+        // Total 900, tope 500 → sobran 400. Debe borrar los más viejos hasta cubrir 400.
+        let items = vec![
+            e("nueva", 300, 1),    // la más reciente
+            e("media", 300, 100),
+            e("vieja", 300, 1000), // la más antigua
+        ];
+        let borra = plan_de_poda(items, 500);
+        // Vieja (300) no basta (faltan 100) → también media. Nueva se salva.
+        assert_eq!(borra, vec![PathBuf::from("vieja"), PathBuf::from("media")]);
+    }
+
+    #[test]
+    fn poda_justo_en_el_tope_no_borra() {
+        let items = vec![e("a", 250, 10), e("b", 250, 5)];
+        assert!(plan_de_poda(items, 500).is_empty(), "500==500 cabe");
+    }
+}

src-tauri/src/ia/bajar.rs

@@ -0,0 +1,170 @@
+// ── Bajar las piezas de la IA: comprobadas con su huella y, si vienen en un zip, sacadas de él ──
+//
+// Todo va a la carpeta de la IA en los datos de la app del equipo (`ia::carpeta`). Cada pieza se
+// baja a un `.parte`, se le saca la huella SHA-256 MIENTRAS llega y solo si cuadra con la anotada
+// en el código pasa a su sitio; al acabar se deja una marca `<nombre>.ok` con la huella, que es lo
+// que se mira después para saber si está (un archivo a medias nunca tiene marca).
+
+use sha2::{Digest, Sha256};
+use std::fs::{self, File};
+use std::io::{self, BufReader, BufWriter, Read, Write};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+/// Una pieza que se baja: un archivo tal cual o un zip del que se sacan unos archivos.
+pub struct Pieza {
+    /// Nombre corto (la marca `.ok` y los avisos).
+    pub nombre: &'static str,
+    pub url: &'static str,
+    /// Huella SHA-256 del archivo bajado, en hexadecimal.
+    pub sha256: &'static str,
+    pub bytes: u64,
+    pub forma: Forma,
+    /// Se pide con la sesión de la pestaña (lo sirve el servidor de la app solo al equipo).
+    pub con_sesion: bool,
+}
+
+pub enum Forma {
+    /// El archivo, con este nombre, en la carpeta de la IA.
+    Archivo(&'static str),
+    /// Un zip (un .nupkg lo es): de él, estos archivos —por su ruta EXACTA dentro: un paquete trae
+    /// varias DLL con el mismo nombre (x86, arm64, Xbox…)— a la carpeta de la IA, con su nombre.
+    Zip(&'static [&'static str]),
+}
+
+fn marca(dir: &Path, p: &Pieza) -> PathBuf {
+    dir.join(format!("{}.ok", p.nombre))
+}
+
+/// ¿Está ya en el equipo (con su marca y la huella de ahora)?
+pub fn esta(dir: &Path, p: &Pieza) -> bool {
+    fs::read_to_string(marca(dir, p)).map(|s| s.trim() == p.sha256).unwrap_or(false)
+}
+
+/// Baja la pieza (si no está) avisando de lo que lleva con `avance(bytes_nuevos)`. `sesion`: las
+/// cookies de la pestaña para el servidor de la app (solo viajan a él: `con_sesion` y su origen).
+pub fn bajar(dir: &Path, p: &Pieza, sesion: Option<&str>, avance: &mut dyn FnMut(u64)) -> Result<(), String> {
+    if esta(dir, p) {
+        return Ok(());
+    }
+    fs::create_dir_all(dir).map_err(|e| format!("No se pudo crear la carpeta de la IA: {e}"))?;
+    let parte = dir.join(format!("{}.parte", p.nombre));
+    let mut pedido = ureq::AgentBuilder::new()
+        .timeout_connect(Duration::from_secs(20))
+        .timeout_read(Duration::from_secs(60))
+        .build()
+        .get(p.url);
+    if p.con_sesion && p.url.starts_with(&format!("{}/", crate::SERVER_URL)) {
+        if let Some(c) = sesion.filter(|c| !c.is_empty()) {
+            pedido = pedido.set("Cookie", c);
+        }
+    }
+    let resp = pedido.call().map_err(|e| match e {
+        ureq::Error::Status(401, _) => format!("No se pudo bajar {}: la sesión de la app caducó (vuelve a entrar).", p.nombre),
+        e => format!("No se pudo bajar {}: {e}", p.nombre),
+    })?;
+    let mut leer = resp.into_reader();
+    let mut escribir = BufWriter::new(File::create(&parte).map_err(|e| format!("No se pudo escribir {}: {e}", p.nombre))?);
+    let mut huella = Sha256::new();
+    let mut buf = vec![0u8; 1 << 20];
+    let mut total: u64 = 0;
+    loop {
+        let n = leer.read(&mut buf).map_err(|e| format!("La descarga de {} se cortó: {e}", p.nombre))?;
+        if n == 0 {
+            break;
+        }
+        huella.update(&buf[..n]);
+        escribir.write_all(&buf[..n]).map_err(|e| format!("No se pudo escribir {}: {e}", p.nombre))?;
+        total += n as u64;
+        avance(n as u64);
+    }
+    escribir.flush().map_err(|e| format!("No se pudo escribir {}: {e}", p.nombre))?;
+    drop(escribir);
+    let hex = huella.finalize().iter().map(|b| format!("{b:02x}")).collect::<String>();
+    if hex != p.sha256 {
+        let _ = fs::remove_file(&parte);
+        return Err(format!("{} llegó distinto de lo esperado ({total} bytes). Vuelve a intentarlo.", p.nombre));
+    }
+    match p.forma {
+        Forma::Archivo(destino) => {
+            let d = dir.join(destino);
+            let _ = fs::remove_file(&d);
+            fs::rename(&parte, &d).map_err(|e| format!("No se pudo guardar {}: {e}", p.nombre))?;
+        }
+        Forma::Zip(quiero) => {
+            let r = extraer(&parte, dir, quiero);
+            let _ = fs::remove_file(&parte);
+            r?;
+        }
+    }
+    fs::write(marca(dir, p), p.sha256).map_err(|e| format!("No se pudo guardar {}: {e}", p.nombre))?;
+    Ok(())
+}
+
+/// Saca del zip los archivos de `quiero` (rutas exactas dentro del zip) a `dir`, con su nombre.
+fn extraer(zip: &Path, dir: &Path, quiero: &[&str]) -> Result<(), String> {
+    let f = File::open(zip).map_err(|e| format!("No se pudo abrir lo bajado: {e}"))?;
+    let mut z = zip::ZipArchive::new(BufReader::new(f)).map_err(|e| format!("Lo bajado no es un zip válido: {e}"))?;
+    let mut faltan: Vec<&str> = quiero.to_vec();
+    for i in 0..z.len() {
+        let mut e = z.by_index(i).map_err(|e| format!("El zip está dañado: {e}"))?;
+        if e.is_dir() {
+            continue;
+        }
+        let ruta = e.name().replace('\\', "/");
+        let nombre = ruta.rsplit('/').next().unwrap_or("").to_string();
+        if nombre.is_empty() || nombre.contains("..") {
+            continue;
+        }
+        if let Some(k) = faltan.iter().position(|q| q.eq_ignore_ascii_case(&ruta)) {
+            faltan.remove(k);
+            let destino = dir.join(&nombre);
+            let tmp = dir.join(format!("{nombre}.parte"));
+            let mut out = BufWriter::new(File::create(&tmp).map_err(|e| format!("No se pudo escribir {nombre}: {e}"))?);
+            io::copy(&mut e, &mut out).map_err(|e| format!("No se pudo sacar {nombre}: {e}"))?;
+            out.flush().map_err(|e| format!("No se pudo escribir {nombre}: {e}"))?;
+            drop(out);
+            let _ = fs::remove_file(&destino);
+            fs::rename(&tmp, &destino).map_err(|e| format!("No se pudo guardar {nombre}: {e}"))?;
+        }
+    }
+    if faltan.is_empty() {
+        Ok(())
+    } else {
+        Err(format!("En lo bajado no vinieron: {}", faltan.join(", ")))
+    }
+}
+
+#[cfg(test)]
+mod pruebas {
+    use super::*;
+
+    #[test]
+    fn saca_del_zip_solo_lo_pedido_y_dice_lo_que_falta() {
+        let dir = std::env::temp_dir().join(format!("ls-ia-prueba-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        let zp = dir.join("x.zip");
+        {
+            let mut w = zip::ZipWriter::new(File::create(&zp).unwrap());
+            let o: zip::write::SimpleFileOptions = Default::default();
+            w.start_file("bin/x64-xbox/a.dll", o).unwrap();
+            w.write_all(b"XBOX").unwrap();
+            w.start_file("bin/x64-win/a.dll", o).unwrap();
+            w.write_all(b"AAA").unwrap();
+            w.start_file("bin/x64-win/b.dll", o).unwrap();
+            w.write_all(b"BBB").unwrap();
+            w.finish().unwrap();
+        }
+        // la de la ruta pedida, no la primera con ese nombre
+        extraer(&zp, &dir, &["bin/x64-win/a.dll"]).unwrap();
+        assert_eq!(fs::read(dir.join("a.dll")).unwrap(), b"AAA");
+        assert!(!dir.join("b.dll").exists());
+        assert!(extraer(&zp, &dir, &["a.dll"]).unwrap_err().contains("a.dll"));
+        let p = Pieza { nombre: "x", url: "", sha256: "abc", bytes: 1, forma: Forma::Archivo("x"), con_sesion: false };
+        assert!(!esta(&dir, &p));
+        fs::write(marca(&dir, &p), "abc").unwrap();
+        assert!(esta(&dir, &p));
+        let _ = fs::remove_dir_all(&dir);
+    }
+}

src-tauri/src/ia/imagen.rs

@@ -0,0 +1,88 @@
+// ── La foto como la quiere el modelo, y su respuesta como la quiere la página ──
+// Lo mismo que hace el navegador (lib/revelado/modelo-sujeto: entradaDelModelo), aquí en Rust:
+// la foto RGBA (como se ve en el editor) a `lado` × `lado` entre sus cuatro píxeles más cercanos,
+// en tres planos RGB normalizados como ImageNet. Y la salida, a un byte por punto.
+
+const MEDIA: [f32; 3] = [0.485, 0.456, 0.406];
+const DESVIACION: [f32; 3] = [0.229, 0.224, 0.225];
+
+/// RGBA (`ancho` × `alto`) → [1, 3, lado, lado] en un vector plano.
+pub fn entrada(rgba: &[u8], ancho: usize, alto: usize, lado: usize) -> Vec<f32> {
+    let plano = lado * lado;
+    let mut out = vec![0f32; 3 * plano];
+    for y in 0..lado {
+        let fy = (((y as f32 + 0.5) / lado as f32) * alto as f32 - 0.5).clamp(0.0, (alto - 1) as f32);
+        let y0 = fy.floor() as usize;
+        let y1 = (y0 + 1).min(alto - 1);
+        let wy = fy - y0 as f32;
+        for x in 0..lado {
+            let fx = (((x as f32 + 0.5) / lado as f32) * ancho as f32 - 0.5).clamp(0.0, (ancho - 1) as f32);
+            let x0 = fx.floor() as usize;
+            let x1 = (x0 + 1).min(ancho - 1);
+            let wx = fx - x0 as f32;
+            for c in 0..3 {
+                let p = |xx: usize, yy: usize| rgba[(yy * ancho + xx) * 4 + c] as f32;
+                let arriba = p(x0, y0) + (p(x1, y0) - p(x0, y0)) * wx;
+                let abajo = p(x0, y1) + (p(x1, y1) - p(x0, y1)) * wx;
+                let v = arriba + (abajo - arriba) * wy;
+                out[c * plano + y * lado + x] = (v / 255.0 - MEDIA[c]) / DESVIACION[c];
+            }
+        }
+    }
+    out
+}
+
+/// ¿La salida viene sin sigmoide? (BiRefNet la aplica fuera de la red; si algo cae fuera de 0..1,
+/// son logits y hay que aplicarla aquí.)
+pub fn son_logits(salida: &[f32]) -> bool {
+    salida.iter().any(|&v| !(-0.001..=1.001).contains(&v))
+}
+
+/// La salida del modelo a un byte por punto. `logits`: la salida va sin sigmoide (BiRefNet la
+/// aplica fuera de la red).
+pub fn a_bytes(salida: &[f32], logits: bool) -> Vec<u8> {
+    salida
+        .iter()
+        .map(|&v| {
+            let p = if logits { 1.0 / (1.0 + (-v).exp()) } else { v };
+            (p.clamp(0.0, 1.0) * 255.0).round() as u8
+        })
+        .collect()
+}
+
+/// La respuesta de `ia_sujeto` para la página: [ancho u32][alto u32][bytes] (little endian).
+pub fn respuesta(ancho: u32, alto: u32, bytes: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(8 + bytes.len());
+    out.extend_from_slice(&ancho.to_le_bytes());
+    out.extend_from_slice(&alto.to_le_bytes());
+    out.extend_from_slice(bytes);
+    out
+}
+
+#[cfg(test)]
+mod pruebas {
+    use super::*;
+
+    #[test]
+    fn la_entrada_es_la_del_navegador() {
+        // 2 × 1: rojo puro y blanco; a 2 × 2 cada columna toma su píxel
+        let rgba = [255, 0, 0, 255, 255, 255, 255, 255];
+        let e = entrada(&rgba, 2, 1, 2);
+        let norm = |v: f32, c: usize| (v / 255.0 - MEDIA[c]) / DESVIACION[c];
+        assert!((e[0] - norm(255.0, 0)).abs() < 1e-5); // R de (0,0)
+        assert!((e[4] - norm(0.0, 1)).abs() < 1e-5); // G de (0,0)
+        assert!((e[5] - norm(255.0, 1)).abs() < 1e-5); // G de (1,0)
+        assert!((e[8 + 3] - norm(255.0, 2)).abs() < 1e-5); // B de (1,1)
+        assert_eq!(e.len(), 12);
+    }
+
+    #[test]
+    fn la_salida_a_bytes_y_la_respuesta() {
+        assert_eq!(a_bytes(&[-20.0, 0.0, 20.0], true), vec![0, 128, 255]);
+        assert_eq!(a_bytes(&[0.0, 0.5, 1.2], false), vec![0, 128, 255]);
+        assert!(son_logits(&[0.2, -3.0]) && !son_logits(&[0.0, 0.5, 1.0]));
+        let r = respuesta(3, 2, &[1, 2, 3, 4, 5, 6]);
+        assert_eq!(&r[..8], &[3, 0, 0, 0, 2, 0, 0, 0]);
+        assert_eq!(r.len(), 14);
+    }
+}

src-tauri/src/ia/mod.rs

@@ -0,0 +1,370 @@
+// ── La IA EN EL EQUIPO: la máscara de sujeto (1.22) y Rellenar (1.23) de Labstream OS ──────────
+//
+// Munka: «los pcs que usan esta función tienen Nvidia de 16 GB… el modelo se ejecuta en local y se
+// conecta y sube el resultado a la app». En el editor de revelado (modo edición de un set):
+// - «Sujeto» y «Fondo» los busca esta app: ONNX Runtime con DirectML sobre la tarjeta NVIDIA y
+//   BiRefNet en media precisión (piezas.rs): 0,3 s por foto en vez de 2,5–3 s en el navegador.
+// - «Rellenar» (Eliminar con IA): LaMa rellena lo pintado (relleno.rs), en la CPU (motor.rs:
+//   abrir_en_cpu; LaMa no corre con DirectML).
+//
+// La página (lib/revelado/ia-local en labstream-os) llama a cuatro comandos, permitidos SOLO para el
+// origen de la app (capabilities/default.json + el manifiesto de build.rs):
+//   ia_estado   ({ que }) → ¿se puede aquí?, ¿está ya bajado?, cuánto falta, qué tarjeta
+//   ia_preparar ({ que }) → baja lo que falte (eventos «ia-progreso» { fase, parte } a esa pestaña)
+//                           y abre el modelo
+//   ia_sujeto   ← RGBA en el cuerpo (binario) + x-ancho / x-alto
+//               → [ancho u32][alto u32][un byte por punto] (lib/revelado/ia-local: leerRespuesta)
+//   ia_rellenar ← RGBA con el hueco en el alfa + x-ancho / x-alto
+//               → [ancho u32][alto u32][RGB, 3 bytes por punto]
+// `que` es "sujeto" (o nada: la página de la 1.22) o "relleno". El resultado vuelve a la página, que lo
+// pone en la máscara o en un parche de la foto y lo guarda con su revelado.
+//
+// Nada se baja ni se carga al arrancar la app: solo cuando alguien lo pide. Lo bajado vive en los
+// datos de la app del equipo (`carpeta`), comprobado con su huella (bajar.rs). Cada modelo abierto
+// ocupa memoria (el del sujeto, ~7 GB de la tarjeta mientras busca: DirectML guarda lo que pidió):
+// se suelta a los SOLTAR_TRAS sin usarlo, que los editores trabajan con Resolve abierto.
+
+mod bajar;
+mod imagen;
+mod motor;
+mod piezas;
+mod relleno;
+mod tarjeta;
+
+use piezas::Que;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use tauri::{AppHandle, Emitter, EventTarget, Manager, Runtime, Webview};
+
+/// Sin usarlo este rato, el modelo se suelta (de la tarjeta, o de la memoria el de rellenar).
+const SOLTAR_TRAS: Duration = Duration::from_secs(2 * 60);
+
+struct Abierto {
+    motor: motor::Motor,
+    usado: Instant,
+}
+
+/// El modelo abierto de cada IA: el del sujeto (DirectML) y el de rellenar (CPU).
+static SUJETO: Mutex<Option<Abierto>> = Mutex::new(None);
+static RELLENO: Mutex<Option<Abierto>> = Mutex::new(None);
+/// Una preparación a la vez (dos pestañas que piden a la vez no bajan dos veces).
+static PREPARANDO: Mutex<()> = Mutex::new(());
+static VIGILANTE: std::sync::Once = std::sync::Once::new();
+
+fn abierto(que: Que) -> &'static Mutex<Option<Abierto>> {
+    match que {
+        Que::Sujeto => &SUJETO,
+        Que::Relleno => &RELLENO,
+    }
+}
+
+fn carpeta<R: Runtime>(app: &AppHandle<R>) -> Result<PathBuf, String> {
+    app.path().app_local_data_dir().map(|d| d.join("ia")).map_err(|e| format!("No hay carpeta de datos de la app: {e}"))
+}
+
+fn faltan(dir: &std::path::Path, que: Que) -> u64 {
+    piezas::de(que).into_iter().filter(|p| !bajar::esta(dir, p)).map(|p| p.bytes).sum()
+}
+
+#[derive(serde::Serialize)]
+pub struct Estado {
+    /// de qué IA habla (así la página sabe que esta app conoce Rellenar)
+    que: &'static str,
+    disponible: bool,
+    motivo: Option<String>,
+    listo: bool,
+    faltan: u64,
+    modelo: &'static str,
+    tarjeta: Option<String>,
+}
+
+/// Por qué esta IA no puede correr aquí (None: sí puede). El sujeto pide NVIDIA; rellenar va en la CPU.
+fn motivo(que: Que, tarjeta: Option<&tarjeta::Tarjeta>) -> Option<String> {
+    if !cfg!(all(windows, target_arch = "x86_64")) {
+        Some("La IA del equipo es para la app de Windows.".to_string())
+    } else if que == Que::Sujeto && tarjeta.is_none() {
+        Some("Este equipo no tiene tarjeta NVIDIA.".to_string())
+    } else {
+        None
+    }
+}
+
+#[tauri::command]
+pub fn ia_estado<R: Runtime>(app: AppHandle<R>, que: Option<String>) -> Estado {
+    let que = Que::de(que.as_deref());
+    let t = tarjeta::nvidia();
+    let motivo = motivo(que, t.as_ref());
+    let dir = carpeta(&app).ok();
+    let falta = dir.as_deref().map(|d| faltan(d, que)).unwrap_or(u64::MAX);
+    Estado {
+        que: que.nombre(),
+        disponible: motivo.is_none() && dir.is_some(),
+        motivo,
+        listo: falta == 0,
+        faltan: if falta == u64::MAX { 0 } else { falta },
+        modelo: match que {
+            Que::Sujeto => piezas::NOMBRE_MODELO,
+            Que::Relleno => piezas::NOMBRE_RELLENO,
+        },
+        tarjeta: t.map(|t| t.nombre),
+    }
+}
+
+fn avisar<R: Runtime>(app: &AppHandle<R>, label: &str, fase: &str, parte: f64) {
+    let _ = app.emit_to(EventTarget::webview(label), "ia-progreso", serde_json::json!({ "fase": fase, "parte": parte }));
+}
+
+/// Baja lo que falte y deja el modelo abierto (en un hilo aparte: puede tardar minutos).
+#[tauri::command]
+pub async fn ia_preparar<R: Runtime>(app: AppHandle<R>, webview: Webview<R>, que: Option<String>) -> Result<(), String> {
+    let que = Que::de(que.as_deref());
+    let label = webview.label().to_string();
+    // La sesión de la pestaña, para bajar el modelo del servidor de la app (solo viaja a él). Aquí y
+    // no en el hilo de abajo: leer cookies de WebView2 desde un comando síncrono se queda colgado.
+    let sesion = tauri::Url::parse(crate::SERVER_URL)
+        .ok()
+        .and_then(|u| webview.cookies_for_url(u).ok())
+        .map(|cs| cs.iter().map(|c| format!("{}={}", c.name(), c.value())).collect::<Vec<_>>().join("; "));
+    tauri::async_runtime::spawn_blocking(move || preparar(&app, &label, sesion.as_deref(), que))
+        .await
+        .map_err(|e| format!("La IA no pudo prepararse: {e}"))?
+}
+
+fn preparar<R: Runtime>(app: &AppHandle<R>, label: &str, sesion: Option<&str>, que: Que) -> Result<(), String> {
+    if let Some(m) = motivo(que, tarjeta::nvidia().as_ref()) {
+        return Err(m);
+    }
+    let _uno = PREPARANDO.lock().unwrap_or_else(|e| e.into_inner());
+    let dir = carpeta(app)?;
+    let total = faltan(&dir, que);
+    if total > 0 {
+        let hecho = AtomicU64::new(0);
+        let mut ultimo = 0u64;
+        avisar(app, label, "bajando", 0.0);
+        for p in piezas::de(que) {
+            bajar::bajar(&dir, p, sesion, &mut |n| {
+                let h = hecho.fetch_add(n, Ordering::Relaxed) + n;
+                // un aviso cada ~1 %
+                if h - ultimo > total / 100 {
+                    ultimo = h;
+                    avisar(app, label, "bajando", (h as f64 / total as f64).min(1.0));
+                }
+            })
+            .map_err(|e| {
+                crate::salud::anotar("ERROR", "ia", &e);
+                e
+            })?;
+        }
+        crate::salud::anotar("INFO", "ia", &format!("IA de {} bajada al equipo ({} MB)", que.nombre(), total / 1_000_000));
+    }
+    let mut m = abierto(que).lock().unwrap_or_else(|e| e.into_inner());
+    if m.is_none() {
+        avisar(app, label, "preparando", 0.0);
+        let t0 = Instant::now();
+        let motor = match que {
+            Que::Sujeto => motor::Motor::abrir(&dir),
+            Que::Relleno => motor::Motor::abrir_en_cpu(&dir, piezas::ARCHIVO_RELLENO),
+        }
+        .map_err(|e| {
+            crate::salud::anotar("ERROR", "ia", &format!("no se pudo abrir el modelo de {}: {e}", que.nombre()));
+            e
+        })?;
+        crate::salud::anotar("INFO", "ia", &format!("modelo de {} abierto en {:.1} s ({})", que.nombre(), t0.elapsed().as_secs_f32(), motor.donde()));
+        *m = Some(Abierto { motor, usado: Instant::now() });
+        vigilar();
+    }
+    Ok(())
+}
+
+/// Suelta cada modelo cuando lleva SOLTAR_TRAS sin usarse.
+fn vigilar() {
+    VIGILANTE.call_once(|| {
+        std::thread::spawn(|| loop {
+            std::thread::sleep(Duration::from_secs(15));
+            for que in [Que::Sujeto, Que::Relleno] {
+                let mut m = abierto(que).lock().unwrap_or_else(|e| e.into_inner());
+                if m.as_ref().map(|a| a.usado.elapsed() >= SOLTAR_TRAS).unwrap_or(false) {
+                    *m = None;
+                    crate::salud::anotar("INFO", "ia", &format!("modelo de {} soltado (sin uso)", que.nombre()));
+                }
+            }
+        });
+    });
+}
+
+/// La foto que manda la página: RGBA en el cuerpo, medidas en las cabeceras.
+fn foto_de(request: &tauri::ipc::Request<'_>) -> Result<(Vec<u8>, usize, usize), String> {
+    let medida = |k: &str| request.headers().get(k).and_then(|v| v.to_str().ok()).and_then(|v| v.parse::<usize>().ok()).unwrap_or(0);
+    let (ancho, alto) = (medida("x-ancho"), medida("x-alto"));
+    let tauri::ipc::InvokeBody::Raw(rgba) = request.body() else {
+        return Err("La foto no llegó (se esperaban sus píxeles).".into());
+    };
+    if ancho < 2 || alto < 2 || ancho > 16_384 || alto > 16_384 || rgba.len() != ancho * alto * 4 {
+        return Err("La foto llegó con unas medidas que no cuadran.".into());
+    }
+    Ok((rgba.clone(), ancho, alto))
+}
+
+/// Busca el sujeto en la foto que manda la página.
+#[tauri::command]
+pub async fn ia_sujeto(request: tauri::ipc::Request<'_>) -> Result<tauri::ipc::Response, String> {
+    let (rgba, ancho, alto) = foto_de(&request)?;
+    tauri::async_runtime::spawn_blocking(move || buscar(&rgba, ancho, alto))
+        .await
+        .map_err(|e| format!("La IA falló: {e}"))?
+        .map(tauri::ipc::Response::new)
+}
+
+fn buscar(rgba: &[u8], ancho: usize, alto: usize) -> Result<Vec<u8>, String> {
+    let mut m = SUJETO.lock().unwrap_or_else(|e| e.into_inner());
+    let Some(a) = m.as_mut() else {
+        return Err("La IA no está preparada.".into());
+    };
+    let lado = piezas::LADO;
+    let t0 = Instant::now();
+    let salida = a.motor.correr(imagen::entrada(rgba, ancho, alto, lado), lado);
+    a.usado = Instant::now();
+    match salida {
+        Ok(s) => {
+            crate::salud::anotar("INFO", "ia", &format!("sujeto en {:.2} s", t0.elapsed().as_secs_f32()));
+            Ok(imagen::respuesta(lado as u32, lado as u32, &imagen::a_bytes(&s, imagen::son_logits(&s))))
+        }
+        Err(e) => {
+            // una tarjeta que se perdió: se suelta para abrirla de nuevo la próxima vez
+            *m = None;
+            crate::salud::anotar("ERROR", "ia", &format!("no se pudo buscar el sujeto: {e}"));
+            Err(e)
+        }
+    }
+}
+
+/// Rellena el hueco (el alfa) de la foto que manda la página (relleno.rs).
+#[tauri::command]
+pub async fn ia_rellenar(request: tauri::ipc::Request<'_>) -> Result<tauri::ipc::Response, String> {
+    let (rgba, ancho, alto) = foto_de(&request)?;
+    tauri::async_runtime::spawn_blocking(move || rellenar(&rgba, ancho, alto))
+        .await
+        .map_err(|e| format!("La IA falló: {e}"))?
+        .map(tauri::ipc::Response::new)
+}
+
+fn rellenar(rgba: &[u8], ancho: usize, alto: usize) -> Result<Vec<u8>, String> {
+    let mut m = RELLENO.lock().unwrap_or_else(|e| e.into_inner());
+    let Some(a) = m.as_mut() else {
+        return Err("La IA no está preparada.".into());
+    };
+    let p = relleno::plan(ancho, alto);
+    let t0 = Instant::now();
+    let r = a.motor.correr_forma(&[1, 4, p.ph, p.pw], relleno::entrada(rgba, ancho, alto, p));
+    a.usado = Instant::now();
+    match r {
+        Ok((_, planos)) if planos.len() == 3 * p.pw * p.ph => {
+            crate::salud::anotar("INFO", "ia", &format!("relleno de {ancho}×{alto} (a {}×{} en {}×{}) en {:.1} s", p.sw, p.sh, p.pw, p.ph, t0.elapsed().as_secs_f32()));
+            let rgb = relleno::salida(&planos, p, rgba, ancho, alto);
+            Ok(imagen::respuesta(ancho as u32, alto as u32, &rgb))
+        }
+        Ok((forma, _)) => Err(format!("El modelo contestó {forma:?} y se esperaba [1, 3, {}, {}].", p.ph, p.pw)),
+        Err(e) => {
+            *m = None;
+            crate::salud::anotar("ERROR", "ia", &format!("no se pudo rellenar: {e}"));
+            Err(e)
+        }
+    }
+}
+
+#[cfg(all(test, windows))]
+mod pruebas {
+    use super::*;
+
+    /// De punta a punta en la tarjeta de ESTE equipo (no corre en CI: `cargo test -- --ignored`).
+    /// LS_IA_DIR: carpeta de la IA (se baja ahí lo que falte). LS_IA_ENTRADA: opcional, un .f32 con
+    /// la entrada [1,3,lado,lado] ya hecha (para comparar con la CPU); la salida va a LS_IA_SALIDA.
+    /// LS_IA_MODELO / LS_IA_LADO: probar otro modelo de la carpeta; LS_IA_ESPERA: segundos con el
+    /// modelo abierto entre vueltas (para mirar la memoria de la tarjeta).
+    #[test]
+    #[ignore]
+    fn de_punta_a_punta_en_la_tarjeta() {
+        let dir = PathBuf::from(std::env::var("LS_IA_DIR").expect("LS_IA_DIR"));
+        for p in piezas::de(Que::Sujeto) {
+            let t = Instant::now();
+            bajar::bajar(&dir, p, None, &mut |_| {}).unwrap();
+            eprintln!("{}: listo en {:.1} s", p.nombre, t.elapsed().as_secs_f32());
+        }
+        let t = Instant::now();
+        let mut m = match std::env::var("LS_IA_MODELO") {
+            Ok(f) => motor::Motor::abrir_archivo(&dir, &f).unwrap(),
+            Err(_) => motor::Motor::abrir(&dir).unwrap(),
+        };
+        eprintln!("modelo abierto en {:.1} s", t.elapsed().as_secs_f32());
+        let lado = std::env::var("LS_IA_LADO").ok().and_then(|v| v.parse().ok()).unwrap_or(piezas::LADO);
+        let entrada = match std::env::var("LS_IA_ENTRADA") {
+            Ok(f) => std::fs::read(f).unwrap().chunks_exact(4).map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect(),
+            Err(_) => {
+                let (w, h) = (1600usize, 1067usize);
+                let mut rgba = vec![255u8; w * h * 4];
+                for y in 0..h {
+                    for x in 0..w {
+                        let i = (y * w + x) * 4;
+                        let d = ((x as f32 - 800.0).powi(2) + (y as f32 - 560.0).powi(2)).sqrt() / 300.0;
+                        let g = (90.0 + 60.0 * y as f32 / h as f32) as u8;
+                        let c = if d < 1.0 { [220, 120, 60] } else { [g, g, g + 10] };
+                        rgba[i..i + 3].copy_from_slice(&c);
+                    }
+                }
+                imagen::entrada(&rgba, w, h, lado)
+            }
+        };
+        for vuelta in 0..2 {
+            let t = Instant::now();
+            let s = m.correr(entrada.clone(), lado).unwrap();
+            let (min, max) = s.iter().fold((f32::MAX, f32::MIN), |(a, b), &v| (a.min(v), b.max(v)));
+            eprintln!("vuelta {vuelta}: {:.2} s, salida {min:.2}..{max:.2}, logits {}", t.elapsed().as_secs_f32(), imagen::son_logits(&s));
+            if let Ok(seg) = std::env::var("LS_IA_ESPERA") {
+                eprintln!("esperando {seg} s con el modelo abierto");
+                std::thread::sleep(Duration::from_secs(seg.parse().unwrap_or(0)));
+            }
+            if vuelta == 1 {
+                if let Ok(f) = std::env::var("LS_IA_SALIDA") {
+                    std::fs::write(f, s.iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<u8>>()).unwrap();
+                }
+            }
+        }
+    }
+
+    /// Rellenar de punta a punta en ESTE equipo: LS_IA_DIR con el motor ya bajado y el modelo de
+    /// rellenar (piezas::ARCHIVO_RELLENO); unas rayas con un hueco cuadrado, al tamaño LS_IA_LADOS.
+    #[test]
+    #[ignore]
+    fn relleno_de_punta_a_punta() {
+        let dir = PathBuf::from(std::env::var("LS_IA_DIR").expect("LS_IA_DIR"));
+        let t = Instant::now();
+        let mut m = motor::Motor::abrir_en_cpu(&dir, piezas::ARCHIVO_RELLENO).unwrap();
+        eprintln!("lama abierto en {:.1} s ({})", t.elapsed().as_secs_f32(), m.donde());
+        let lados: Vec<usize> = std::env::var("LS_IA_LADOS").unwrap_or("600,1400".into()).split(',').filter_map(|v| v.trim().parse().ok()).collect();
+        for &lado in &lados {
+            let (w, h) = (lado, lado * 2 / 3);
+            let mut rgba = vec![0u8; w * h * 4];
+            for y in 0..h {
+                for x in 0..w {
+                    let i = (y * w + x) * 4;
+                    let raya: u8 = if (x / 16) % 2 == 0 { 40 } else { 0 };
+                    rgba[i] = 80 + raya;
+                    rgba[i + 1] = 120;
+                    rgba[i + 2] = 50 + raya;
+                    let hueco = x > w * 2 / 5 && x < w * 3 / 5 && y > h * 2 / 5 && y < h * 3 / 5;
+                    rgba[i + 3] = if hueco { 255 } else { 0 };
+                }
+            }
+            let p = relleno::plan(w, h);
+            let t = Instant::now();
+            let (_, planos) = m.correr_forma(&[1, 4, p.ph, p.pw], relleno::entrada(&rgba, w, h, p)).unwrap();
+            let rgb = relleno::salida(&planos, p, &rgba, w, h);
+            let c = (h / 2 * w + w / 2) * 3;
+            eprintln!("{w}×{h} ({p:?}): {:.2} s, centro {:?}, esquina {:?}", t.elapsed().as_secs_f32(), &rgb[c..c + 3], &rgb[..3]);
+            // fuera del hueco, lo que había
+            assert_eq!(&rgb[..3], &rgba[..3]);
+        }
+    }
+}

src-tauri/src/ia/motor.rs

@@ -0,0 +1,161 @@
+// ── El motor: ONNX Runtime con DirectML sobre la tarjeta (Windows) ──
+//
+// DirectML y no CUDA: corre en cualquier tarjeta con DirectX 12 —las NVIDIA del equipo incluidas—
+// sin pedir versión de controlador, y lo que hay que bajar son ~200 MB de Microsoft (NuGet) en vez
+// de ~1,3 GB de bibliotecas de NVIDIA. La exportación oficial de BiRefNet lleva la convolución
+// deformable deshecha en GatherND (lo que DirectML sabe hacer; DeformConv no).
+//
+// Las DLL no van en el instalador: las baja `ia_preparar` (piezas.rs) a la carpeta de la IA y aquí
+// se cargan desde ahí. DirectML.dll se carga ANTES por su ruta: onnxruntime.dll la pide por nombre
+// y, ya cargada, Windows le da esa y no la vieja de System32. ONNX Runtime se inicia UNA vez por
+// proceso (`ENTORNO`); la sesión (el modelo en la tarjeta) se abre y se suelta según se use.
+
+#[cfg(windows)]
+mod imp {
+    use super::super::piezas;
+    use ort::{
+        ep,
+        environment::Environment,
+        session::{builder::GraphOptimizationLevel, Session},
+        value::Tensor,
+    };
+    use std::path::Path;
+    use std::sync::OnceLock;
+
+    static ENTORNO: OnceLock<Result<Environment, String>> = OnceLock::new();
+
+    fn entorno(dir: &Path) -> Result<&'static Environment, String> {
+        ENTORNO
+            .get_or_init(|| {
+                cargar_por_ruta(&dir.join(piezas::DLL_DIRECTML))?;
+                let env = ort::init_from(dir.join(piezas::DLL_ORT))
+                    .map_err(|e| format!("No se pudo cargar ONNX Runtime: {e}"))?
+                    .with_name("labstream-ia")
+                    .build()
+                    .map_err(|e| format!("No se pudo iniciar ONNX Runtime: {e}"))?;
+                Ok(env)
+            })
+            .as_ref()
+            .map_err(|e| e.clone())
+    }
+
+    /// Carga una DLL por su ruta completa y la deja cargada para siempre.
+    fn cargar_por_ruta(ruta: &Path) -> Result<(), String> {
+        use std::os::windows::ffi::OsStrExt;
+        use windows::core::PCWSTR;
+        use windows::Win32::System::LibraryLoader::LoadLibraryW;
+        let w: Vec<u16> = ruta.as_os_str().encode_wide().chain(std::iter::once(0)).collect();
+        unsafe { LoadLibraryW(PCWSTR(w.as_ptr())) }.map(|_| ()).map_err(|e| format!("No se pudo cargar {}: {e}", ruta.display()))
+    }
+
+    pub struct Motor {
+        sesion: Session,
+        entrada: String,
+        donde: &'static str,
+    }
+
+    impl Motor {
+        pub fn abrir(dir: &Path) -> Result<Motor, String> {
+            Self::abrir_archivo(dir, piezas::ARCHIVO_MODELO)
+        }
+
+        pub fn abrir_archivo(dir: &Path, archivo: &str) -> Result<Motor, String> {
+            let env = entorno(dir)?;
+            let e = |e: ort::Error<ort::session::builder::SessionBuilder>| format!("No se pudo abrir el modelo: {e}");
+            let sesion = Session::builder(env)
+                .map_err(|e| format!("No se pudo abrir el modelo: {e}"))?
+                .with_optimization_level(GraphOptimizationLevel::Level3)
+                .map_err(e)?
+                // lo que pide DirectML: sin patrones de memoria y en serie
+                .with_memory_pattern(false)
+                .map_err(e)?
+                .with_parallel_execution(false)
+                .map_err(e)?
+                // El grafo FUNDIDO de DirectML pide la memoria de toda la red de una vez: con el modelo
+                // HR no cabía ni en 16 GB (E_OUTOFMEMORY en DmlFusedNode, RTX 5080, 14-oct-2026) y en
+                // media precisión iba 6 veces más lento. Nodo a nodo, cada tensor se suelta cuando ya
+                // no hace falta (el general: 0,3 s).
+                .with_config_entry("ep.dml.disable_graph_fusion", "1")
+                .map_err(e)?
+                .with_execution_providers([ep::DirectML::default()
+                    .with_device_filter(ep::directml::DeviceFilter::Gpu)
+                    .with_performance_preference(ep::directml::PerformancePreference::HighPerformance)
+                    .build()
+                    // sin la tarjeta NO se sigue en la CPU: serían 30 s por foto
+                    .error_on_failure()])
+                .map_err(e)?
+                .commit_from_file(dir.join(archivo))
+                .map_err(|e| format!("No se pudo abrir el modelo: {e}"))?;
+            let entrada = sesion.inputs().first().map(|i| i.name().to_string()).ok_or("El modelo no tiene entrada.")?;
+            Ok(Motor { sesion, entrada, donde: "DirectML" })
+        }
+
+        /// En la CPU (Rellenar: LaMa). Las exportaciones de LaMa no corren con DirectML —su FFT, sea el
+        /// operador DFT o productos de matrices, falla con 80070057 en una RTX 5080 (14-oct-2026)— y en
+        /// la CPU sí: 2,7 s a 512 px y 10 s a 1024. Y no le quita memoria a la tarjeta (Resolve).
+        pub fn abrir_en_cpu(dir: &Path, archivo: &str) -> Result<Motor, String> {
+            let env = entorno(dir)?;
+            let e = |e: ort::Error<ort::session::builder::SessionBuilder>| format!("No se pudo abrir el modelo: {e}");
+            let sesion = Session::builder(env)
+                .map_err(|e| format!("No se pudo abrir el modelo: {e}"))?
+                .with_optimization_level(GraphOptimizationLevel::Level3)
+                .map_err(e)?
+                .with_execution_providers([ep::CPU::default().build()])
+                .map_err(e)?
+                .commit_from_file(dir.join(archivo))
+                .map_err(|e| format!("No se pudo abrir el modelo: {e}"))?;
+            let entrada = sesion.inputs().first().map(|i| i.name().to_string()).ok_or("El modelo no tiene entrada.")?;
+            Ok(Motor { sesion, entrada, donde: "CPU" })
+        }
+
+        pub fn donde(&self) -> &'static str {
+            self.donde
+        }
+
+        /// La entrada [1, 3, lado, lado] → la salida [1, 1, lado, lado] (la última, si hay varias).
+        pub fn correr(&mut self, entrada: Vec<f32>, lado: usize) -> Result<Vec<f32>, String> {
+            let (forma, datos) = self.correr_forma(&[1, 3, lado, lado], entrada)?;
+            if datos.len() != lado * lado {
+                return Err(format!("El modelo contestó {forma:?} y se esperaba {lado} × {lado}."));
+            }
+            Ok(datos)
+        }
+
+        /// Su única entrada con esta forma → la última salida (su forma y sus datos).
+        pub fn correr_forma(&mut self, forma: &[usize], entrada: Vec<f32>) -> Result<(Vec<i64>, Vec<f32>), String> {
+            let t = Tensor::from_array((forma.to_vec(), entrada)).map_err(|e| format!("La foto no entró al modelo: {e}"))?;
+            let nombre = self.entrada.clone();
+            let salidas = self.sesion.run(ort::inputs![nombre => t]).map_err(|e| format!("La tarjeta no pudo con la foto: {e}"))?;
+            let ultima = salidas.len().checked_sub(1).ok_or("El modelo no contestó.")?;
+            let (forma, datos) = salidas[ultima].try_extract_tensor::<f32>().map_err(|e| format!("El modelo contestó algo raro: {e}"))?;
+            Ok((forma.iter().copied().collect(), datos.to_vec()))
+        }
+    }
+}
+
+#[cfg(not(windows))]
+mod imp {
+    use std::path::Path;
+
+    pub struct Motor;
+
+    impl Motor {
+        pub fn abrir(_dir: &Path) -> Result<Motor, String> {
+            Err("La IA del equipo es para Windows con tarjeta NVIDIA.".into())
+        }
+        pub fn abrir_en_cpu(_dir: &Path, _archivo: &str) -> Result<Motor, String> {
+            Err("La IA del equipo es para Windows.".into())
+        }
+        pub fn donde(&self) -> &'static str {
+            "-"
+        }
+        pub fn correr(&mut self, _entrada: Vec<f32>, _lado: usize) -> Result<Vec<f32>, String> {
+            Err("La IA del equipo es para Windows con tarjeta NVIDIA.".into())
+        }
+        pub fn correr_forma(&mut self, _forma: &[usize], _entrada: Vec<f32>) -> Result<(Vec<i64>, Vec<f32>), String> {
+            Err("La IA del equipo es para Windows con tarjeta NVIDIA.".into())
+        }
+    }
+}
+
+pub use imp::Motor;

src-tauri/src/ia/piezas.rs

@@ -0,0 +1,101 @@
+// ── Lo que la IA baja la primera vez, de dónde, y con qué huella ──
+// El motor (≈215 MB) es de las dos IA; cada modelo se baja solo cuando se usa la suya: el del sujeto
+// (≈490 MB) o el de rellenar (≈210 MB).
+//
+// Fijado por versión y huella SHA-256 (comprobadas al bajarlo el 14-oct-2026): si algún día cambia
+// lo que hay en esa dirección, no se usa.
+//
+// - El modelo: BiRefNet general (MIT, ZhengPeng7; el mismo del navegador) en media precisión, del
+//   servidor de la app (api/modelos/sujeto-equipo, con la sesión de la pestaña). Sale de la
+//   exportación ONNX oficial del autor (release v1 de su GitHub, float32) pasada a float16 con la
+//   entrada y la salida en float32 (scripts/modelo-sujeto-equipo.py de labstream-os). Entrada
+//   `input_image` [1, 3, 1024, 1024], salida `output_image` [1, 1, 1024, 1024] (logits). En una RTX
+//   5080: 0,3 s por foto y el mismo borde que el original en la CPU.
+//   El HR (2048 px, matting) se probó y NO va: su convolución deformable, deshecha en GatherND en la
+//   exportación oficial, ocupa 14–15 GB con DirectML y tarda de 6 a 45 s (14-oct-2026).
+// - Rellenar (1.23): LaMa (Apache-2.0, advimman/big-lama), la exportación ONNX de tamaño libre de
+//   g-ronimo (Hugging Face g-ronimo/lama, `lama.onnx`, la que usa wipe.photos), copiada al servidor de
+//   la app (api/modelos/relleno-equipo). Entrada `input` [1, 4, alto, ancho] (múltiplos de 32),
+//   salida `output` [1, 3, alto, ancho], 0..1. Corre en la CPU (ver motor.rs: abrir_en_cpu).
+// - ONNX Runtime 1.24.4 con DirectML (NuGet de Microsoft): onnxruntime.dll para x64.
+// - DirectML 1.15.4 (NuGet de Microsoft): DirectML.dll para Windows x64 (el paquete trae también
+//   las de Xbox y las de depurar: se saca por su ruta exacta).
+
+use super::bajar::{Forma, Pieza};
+
+pub const NOMBRE_MODELO: &str = "BiRefNet";
+pub const NOMBRE_RELLENO: &str = "LaMa";
+pub const ARCHIVO_RELLENO: &str = "lama-g-ronimo-44bb92b2.onnx";
+/// El lado de la entrada y de la salida del modelo.
+pub const LADO: usize = 1024;
+
+pub const ARCHIVO_MODELO: &str = "birefnet-general-epoch_244-fp16.onnx";
+pub const DLL_ORT: &str = "onnxruntime.dll";
+pub const DLL_DIRECTML: &str = "DirectML.dll";
+
+/// De qué IA se habla: la máscara de sujeto o rellenar.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Que {
+    Sujeto,
+    Relleno,
+}
+
+impl Que {
+    pub fn de(v: Option<&str>) -> Que {
+        if v == Some("relleno") {
+            Que::Relleno
+        } else {
+            Que::Sujeto
+        }
+    }
+    pub fn nombre(self) -> &'static str {
+        match self {
+            Que::Sujeto => "sujeto",
+            Que::Relleno => "relleno",
+        }
+    }
+}
+
+static RELLENO: Pieza = Pieza {
+    nombre: "lama-g-ronimo-44bb92b2",
+    url: "https://os.labstreamsas.com/api/modelos/relleno-equipo",
+    sha256: "44bb92b2693db40bb088dda226365a3aa8080a561584b8b0287ab11a97f9e9e7",
+    bytes: 209_181_361,
+    forma: Forma::Archivo(ARCHIVO_RELLENO),
+    con_sesion: true,
+};
+
+static PIEZAS: [Pieza; 3] = [
+    Pieza {
+        nombre: "onnxruntime-directml-1.24.4",
+        url: "https://api.nuget.org/v3-flatcontainer/microsoft.ml.onnxruntime.directml/1.24.4/microsoft.ml.onnxruntime.directml.1.24.4.nupkg",
+        sha256: "57e9f11b73437bef7a309496135d4c1f96b1a8e9ddba60013fa27bfc1d788681",
+        bytes: 12_458_649,
+        forma: Forma::Zip(&["runtimes/win-x64/native/onnxruntime.dll", "runtimes/win-x64/native/onnxruntime_providers_shared.dll"]),
+        con_sesion: false,
+    },
+    Pieza {
+        nombre: "directml-1.15.4",
+        url: "https://api.nuget.org/v3-flatcontainer/microsoft.ai.directml/1.15.4/microsoft.ai.directml.1.15.4.nupkg",
+        sha256: "4e7cb7ddce8cf837a7a75dc029209b520ca0101470fcdf275c1f49736a3615b9",
+        bytes: 202_292_617,
+        forma: Forma::Zip(&["bin/x64-win/DirectML.dll"]),
+        con_sesion: false,
+    },
+    Pieza {
+        nombre: "birefnet-general-epoch_244-fp16",
+        url: "https://os.labstreamsas.com/api/modelos/sujeto-equipo",
+        sha256: "323232ec73a04ac4d0ef8c325a75aa8d69ed7062235a7cf9941769fae4c9709f",
+        bytes: 489_666_838,
+        forma: Forma::Archivo(ARCHIVO_MODELO),
+        con_sesion: true,
+    },
+];
+
+/// Lo que necesita cada IA: el motor (los dos primeros) y su modelo.
+pub fn de(que: Que) -> Vec<&'static Pieza> {
+    match que {
+        Que::Sujeto => PIEZAS.iter().collect(),
+        Que::Relleno => vec![&PIEZAS[0], &PIEZAS[1], &RELLENO],
+    }
+}

src-tauri/src/ia/relleno.rs

@@ -0,0 +1,163 @@
+// ── RELLENAR: el hueco pintado en el editor, rellenado por LaMa (1.23) ──
+//
+// La página (lib/revelado/relleno y revelado-relleno de labstream-os) manda el trozo de la foto
+// alrededor de lo pintado, en 8 bits, con el hueco en el alfa (255 = rellenar). Aquí se lleva al
+// tamaño del modelo, se rellena, se vuelve a su tamaño y se devuelve el trozo con el hueco relleno y
+// lo demás tal cual estaba (byte a byte).
+//
+// El tamaño (`plan`): LaMa hace FFT de lo que ve, y la de ONNX Runtime en la CPU solo es rápida con
+// lados que son potencias de 2: 512 × 512 son 2,7 s y 704 × 448 —casi los mismos píxeles— 10 s
+// (14-oct-2026). Así que el trozo se reduce lo justo para caber en 512 (o en 1024 si pasa de 768 px:
+// LaMa generaliza bien hasta ahí, 10 s) y se completa hasta la potencia de 2 con su propio borde en
+// espejo (sin hueco: es contexto). Lo de fuera de la foto reducida se descarta al volver.
+//
+// El modelo (LaMa, Apache-2.0; la exportación ONNX de tamaño libre de g-ronimo): una entrada
+// [1, 4, alto, ancho] —RGB 0..1 con el hueco a cero, y el hueco 0/1— y una salida [1, 3, alto, ancho]
+// RGB 0..1, la foto entera.
+
+/// El lado mayor al que se rellena.
+pub const LADO_MAX: usize = 1024;
+
+/// Cómo entra un trozo de `ancho` × `alto` al modelo: reducido a `sw` × `sh` y completado en espejo
+/// hasta `pw` × `ph` (potencias de 2).
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Plan {
+    pub sw: usize,
+    pub sh: usize,
+    pub pw: usize,
+    pub ph: usize,
+}
+
+pub fn plan(ancho: usize, alto: usize) -> Plan {
+    let mayor = ancho.max(alto);
+    let lado = if mayor <= 768 { 512 } else { LADO_MAX };
+    let k = (lado as f64 / mayor as f64).min(1.0);
+    let sw = ((ancho as f64 * k).round() as usize).clamp(8, lado);
+    let sh = ((alto as f64 * k).round() as usize).clamp(8, lado);
+    Plan { sw, sh, pw: sw.next_power_of_two().max(64), ph: sh.next_power_of_two().max(64) }
+}
+
+/// Remuestrea `de` (`canales` por punto, `aw` × `ah`) a `bw` × `bh` entre sus cuatro vecinos.
+pub fn remuestrear(de: &[f32], aw: usize, ah: usize, canales: usize, bw: usize, bh: usize) -> Vec<f32> {
+    let mut out = vec![0f32; bw * bh * canales];
+    for y in 0..bh {
+        let fy = (((y as f32 + 0.5) / bh as f32) * ah as f32 - 0.5).clamp(0.0, (ah - 1) as f32);
+        let y0 = fy.floor() as usize;
+        let y1 = (y0 + 1).min(ah - 1);
+        let wy = fy - y0 as f32;
+        for x in 0..bw {
+            let fx = (((x as f32 + 0.5) / bw as f32) * aw as f32 - 0.5).clamp(0.0, (aw - 1) as f32);
+            let x0 = fx.floor() as usize;
+            let x1 = (x0 + 1).min(aw - 1);
+            let wx = fx - x0 as f32;
+            for c in 0..canales {
+                let p = |xx: usize, yy: usize| de[(yy * aw + xx) * canales + c];
+                let arriba = p(x0, y0) + (p(x1, y0) - p(x0, y0)) * wx;
+                let abajo = p(x0, y1) + (p(x1, y1) - p(x0, y1)) * wx;
+                out[(y * bw + x) * canales + c] = arriba + (abajo - arriba) * wy;
+            }
+        }
+    }
+    out
+}
+
+/// El índice en espejo de `i` dentro de 0..n (…2 1 0 1 2…n-2 n-1 n-2…).
+fn espejo(i: usize, n: usize) -> usize {
+    if n <= 1 {
+        return 0;
+    }
+    let periodo = 2 * (n - 1);
+    let r = i % periodo;
+    if r < n { r } else { periodo - r }
+}
+
+/// La entrada del modelo (planos [4, ph, pw]) a partir del RGBA de la página.
+pub fn entrada(rgba: &[u8], ancho: usize, alto: usize, p: Plan) -> Vec<f32> {
+    let n = ancho * alto;
+    let mut rgb = Vec::with_capacity(n * 3);
+    let mut hueco = Vec::with_capacity(n);
+    for i in 0..n {
+        rgb.extend_from_slice(&[rgba[i * 4] as f32 / 255.0, rgba[i * 4 + 1] as f32 / 255.0, rgba[i * 4 + 2] as f32 / 255.0]);
+        hueco.push(if rgba[i * 4 + 3] >= 128 { 1.0 } else { 0.0 });
+    }
+    let rgb = remuestrear(&rgb, ancho, alto, 3, p.sw, p.sh);
+    let hueco = remuestrear(&hueco, ancho, alto, 1, p.sw, p.sh);
+    let m = p.pw * p.ph;
+    let mut out = vec![0f32; 4 * m];
+    for y in 0..p.ph {
+        let dentro_y = y < p.sh;
+        let sy = espejo(y, p.sh);
+        for x in 0..p.pw {
+            let dentro = dentro_y && x < p.sw;
+            let sx = espejo(x, p.sw);
+            let s = sy * p.sw + sx;
+            // lo que toca el hueco, aunque sea un poco al reducir, es hueco; el espejo, nunca
+            let h = if dentro && hueco[s] > 0.02 { 1.0 } else { 0.0 };
+            let i = y * p.pw + x;
+            for c in 0..3 {
+                out[c * m + i] = if h > 0.0 { 0.0 } else { rgb[s * 3 + c] };
+            }
+            out[3 * m + i] = h;
+        }
+    }
+    out
+}
+
+/// La salida del modelo (planos [3, ph, pw], 0..1) de vuelta a `ancho` × `alto`: dentro del hueco lo
+/// rellenado; fuera, el RGB que llegó, tal cual. RGB 8 bits.
+pub fn salida(planos: &[f32], p: Plan, rgba: &[u8], ancho: usize, alto: usize) -> Vec<u8> {
+    let m = p.pw * p.ph;
+    let mut intercalado = vec![0f32; p.sw * p.sh * 3];
+    for y in 0..p.sh {
+        for x in 0..p.sw {
+            for c in 0..3 {
+                intercalado[(y * p.sw + x) * 3 + c] = planos[c * m + y * p.pw + x];
+            }
+        }
+    }
+    let grande = remuestrear(&intercalado, p.sw, p.sh, 3, ancho, alto);
+    let n = ancho * alto;
+    let mut out = vec![0u8; n * 3];
+    for i in 0..n {
+        let dentro = rgba[i * 4 + 3] >= 128;
+        for c in 0..3 {
+            out[i * 3 + c] = if dentro { (grande[i * 3 + c].clamp(0.0, 1.0) * 255.0).round() as u8 } else { rgba[i * 4 + c] };
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod pruebas {
+    use super::*;
+
+    #[test]
+    fn el_plan_reduce_lo_justo_y_completa_hasta_potencias_de_2() {
+        assert_eq!(plan(700, 460), Plan { sw: 512, sh: 336, pw: 512, ph: 512 });
+        assert_eq!(plan(500, 300), Plan { sw: 500, sh: 300, pw: 512, ph: 512 });
+        assert_eq!(plan(1400, 933), Plan { sw: 1024, sh: 682, pw: 1024, ph: 1024 });
+        assert_eq!(plan(200, 100), Plan { sw: 200, sh: 100, pw: 256, ph: 128 });
+        assert_eq!(plan(20, 10), Plan { sw: 20, sh: 10, pw: 64, ph: 64 });
+        assert_eq!(espejo(5, 4), 1);
+        assert_eq!(espejo(3, 4), 3);
+    }
+
+    #[test]
+    fn fuera_del_hueco_queda_lo_que_habia() {
+        // 2 × 1: el primero es hueco
+        let rgba = [10, 20, 30, 255, 40, 50, 60, 0];
+        let p = plan(2, 1);
+        let e = entrada(&rgba, 2, 1, p);
+        let m = p.pw * p.ph;
+        assert_eq!(e.len(), 4 * m);
+        // el hueco (0,0): RGB a cero y el canal del hueco a 1; el espejo (fuera de 2 × 1) no es hueco
+        assert_eq!(e[0], 0.0);
+        assert_eq!(e[3 * m], 1.0);
+        assert_eq!(e[3 * m + 10], 0.0);
+        // lo de la red: todo gris
+        let planos = vec![0.5f32; 3 * m];
+        let s = salida(&planos, p, &rgba, 2, 1);
+        assert_eq!(&s[..3], &[128, 128, 128]);
+        assert_eq!(&s[3..], &[40, 50, 60]);
+    }
+}

src-tauri/src/ia/tarjeta.rs

@@ -0,0 +1,36 @@
+// ── ¿Hay tarjeta NVIDIA en este equipo? ── (DXGI: lo que Windows sabe de sus adaptadores, sin
+// cargar nada de la IA). Es lo que decide si la máscara de sujeto la busca la app o el navegador.
+
+/// Una tarjeta NVIDIA del equipo: su nombre y su memoria propia (bytes).
+pub struct Tarjeta {
+    pub nombre: String,
+    pub memoria: u64,
+}
+
+const NVIDIA: u32 = 0x10DE;
+
+#[cfg(windows)]
+pub fn nvidia() -> Option<Tarjeta> {
+    use windows::Win32::Graphics::Dxgi::{CreateDXGIFactory1, IDXGIFactory1, DXGI_ADAPTER_FLAG_SOFTWARE};
+    let factory: IDXGIFactory1 = unsafe { CreateDXGIFactory1() }.ok()?;
+    let mut mejor: Option<Tarjeta> = None;
+    for i in 0.. {
+        let Ok(a) = (unsafe { factory.EnumAdapters1(i) }) else { break };
+        let Ok(d) = (unsafe { a.GetDesc1() }) else { continue };
+        if d.VendorId != NVIDIA || (d.Flags & DXGI_ADAPTER_FLAG_SOFTWARE.0 as u32) != 0 {
+            continue;
+        }
+        let largo = d.Description.iter().position(|&c| c == 0).unwrap_or(d.Description.len());
+        let t = Tarjeta { nombre: String::from_utf16_lossy(&d.Description[..largo]).trim().to_string(), memoria: d.DedicatedVideoMemory as u64 };
+        // con dos, la de más memoria
+        if mejor.as_ref().map(|m| t.memoria > m.memoria).unwrap_or(true) {
+            mejor = Some(t);
+        }
+    }
+    mejor
+}
+
+#[cfg(not(windows))]
+pub fn nvidia() -> Option<Tarjeta> {
+    None
+}

src-tauri/src/memoria.rs

@@ -0,0 +1,212 @@
+// ── Memoria (v1.20.0): que la app gaste lo que necesita y devuelva lo que no ──
+//
+// MEDIDO en el equipo de edición (2026-10-14, app abierta desde el día anterior, 5 pestañas):
+// 2.221 MB de memoria privada en 13 procesos. De eso, 1.329 MB eran del PROCESO GRÁFICO de
+// WebView2 (gpu-process), que crece con las horas (fotos, miniaturas, el reproductor de revisión,
+// dos monitores 4K) y no devuelve nada; cada pestaña viva pesaba 110-180 MB más. Se reinició a
+// mano solo el proceso gráfico: WebView2 lo levantó de nuevo, nada se perdió, y la app bajó a
+// 1.140 MB. De ahí salen las tres medidas de este módulo:
+//
+// 1. RECICLAR EL PROCESO GRÁFICO: si pasa de GPU_RECICLAR_MB y nadie está mirando (ventana
+//    oculta o minimizada, o sin tocar ratón ni teclado RECICLAR_INACTIVO), se cierra y WebView2
+//    crea otro al momento (es un caso previsto: ProcessFailed GPU_PROCESS_EXITED, que salud.rs
+//    anota). Como mucho cada RECICLAR_CADA: Chromium pasa a dibujar sin GPU si el proceso gráfico
+//    cae varias veces en poco tiempo, y eso sería peor que la memoria.
+// 2. NIVEL DE MEMORIA BAJO (ICoreWebView2_19::MemoryUsageTargetLevel): a las pestañas ocultas
+//    —y a todas con la ventana oculta o minimizada— se les pide a WebView2 que suelte cachés y
+//    memoria que puede regenerar. La pestaña a la vista vuelve a «normal» al instante.
+// 3. DESCARTAR PESTAÑAS (lib.rs, `ronda_de_reposo`): una pestaña que lleva DESCARTE_TRAS dormida
+//    se cierra de verdad —su proceso sale de la memoria— y se queda en la barra con su título,
+//    URL y color; al volver a ella se crea otra vez en la misma URL (1-2 s de carga). Es lo que
+//    hace el «Ahorro de memoria» de Chrome. Solo llegan aquí pestañas que ya pasaron el filtro
+//    del reposo (sin subidas, descargas ni audio, y nunca un editor de documentos).
+
+// En macOS solo existen los niveles y el descarte; la medición y el reciclaje son de Windows.
+#![cfg_attr(not(windows), allow(dead_code, unused_imports))]
+
+use std::{
+    sync::{mpsc, Mutex},
+    time::{Duration, Instant},
+};
+
+use tauri::{AppHandle, Manager, Runtime, Webview};
+
+use crate::salud;
+
+pub const GPU_RECICLAR_MB: u64 = 600;
+const RECICLAR_CADA: Duration = Duration::from_secs(30 * 60);
+const RECICLAR_INACTIVO: Duration = Duration::from_secs(10 * 60);
+pub const DESCARTE_TRAS: Duration = Duration::from_secs(30 * 60);
+
+static ULTIMO_RECICLAJE: Mutex<Option<Instant>> = Mutex::new(None);
+
+/// Memoria de los procesos de WebView2 por tipo, para el diario: (gpu_mb, renderers_mb).
+#[derive(Clone, Copy, Default)]
+pub struct Reparto {
+    pub gpu_mb: u64,
+    pub pestanas_mb: u64,
+}
+
+// ── Nivel de memoria de una pestaña ──
+
+#[cfg(windows)]
+pub fn nivel_bajo<R: Runtime>(wv: &Webview<R>, bajo: bool) {
+    let _ = wv.with_webview(move |pw| unsafe {
+        use webview2_com::Microsoft::Web::WebView2::Win32::{
+            ICoreWebView2_19, COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_LOW, COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_NORMAL,
+        };
+        use windows::core::Interface;
+        let Ok(core) = pw.controller().CoreWebView2() else { return };
+        // ICoreWebView2_19 existe desde el runtime 1.0.2210 (2023): si no está, no pasa nada.
+        let Ok(c19) = core.cast::<ICoreWebView2_19>() else { return };
+        let _ = c19.SetMemoryUsageTargetLevel(if bajo { COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_LOW } else { COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_NORMAL });
+    });
+}
+#[cfg(not(windows))]
+pub fn nivel_bajo<R: Runtime>(_wv: &Webview<R>, _bajo: bool) {}
+
+/// Con la ventana oculta o minimizada, todas las vistas a nivel bajo; si no, solo las ocultas.
+/// La llama la ronda de salud cada minuto (desde su hilo: las consultas a la ventana esperan al
+/// hilo principal y aquí eso es seguro).
+pub fn ajustar_niveles<R: Runtime>(app: &AppHandle<R>) {
+    let Some(win) = app.get_window("main") else { return };
+    let nadie_mira = !win.is_visible().unwrap_or(true) || win.is_minimized().unwrap_or(false);
+    let activa = {
+        let shell = app.state::<crate::ShellState>();
+        let s = shell.lock().unwrap();
+        s.tabs.get(s.active).map(|t| t.label.clone())
+    };
+    for wv in win.webviews() {
+        let visible = wv.label() == crate::CHROME || Some(wv.label()) == activa.as_deref();
+        nivel_bajo(&wv, nadie_mira || !visible);
+    }
+}
+
+/// La ventana vuelve a verse (bandeja, minimizar, foco): la barra y la pestaña activa recuperan el
+/// nivel normal YA, sin esperar a la ronda del minuto. No consulta la ventana: vale en cualquier hilo.
+pub fn a_la_vista<R: Runtime>(app: &AppHandle<R>) {
+    let activa = {
+        let shell = app.state::<crate::ShellState>();
+        let s = shell.lock().unwrap();
+        s.tabs.get(s.active).map(|t| t.label.clone())
+    };
+    for label in std::iter::once(crate::CHROME.to_string()).chain(activa) {
+        if let Some(wv) = app.get_webview(&label) {
+            nivel_bajo(&wv, false);
+        }
+    }
+}
+
+// ── Procesos de WebView2 y reciclaje del proceso gráfico ──
+
+/// (pid, tipo) de todos los procesos del entorno WebView2 de la app. Tipo: el valor de
+/// COREWEBVIEW2_PROCESS_KIND (0 navegador, 1 pestaña, 2 utilidad, 3 sandbox, 4 GPU…).
+/// No llamar desde el hilo principal: espera su respuesta.
+#[cfg(windows)]
+fn procesos<R: Runtime>(app: &AppHandle<R>) -> Vec<(u32, i32)> {
+    let Some(wv) = app.get_webview(crate::CHROME) else { return Vec::new() };
+    let (tx, rx) = mpsc::channel();
+    let pedido = wv.with_webview(move |pw| unsafe {
+        use webview2_com::Microsoft::Web::WebView2::Win32::{ICoreWebView2Environment8, ICoreWebView2_2, COREWEBVIEW2_PROCESS_KIND};
+        use windows::core::Interface;
+        let mut v = Vec::new();
+        let lista = pw
+            .controller()
+            .CoreWebView2()
+            .and_then(|c| c.cast::<ICoreWebView2_2>())
+            .and_then(|c| c.Environment())
+            .and_then(|e| e.cast::<ICoreWebView2Environment8>())
+            .and_then(|e| e.GetProcessInfos());
+        if let Ok(lista) = lista {
+            let mut n = 0u32;
+            let _ = lista.Count(&mut n);
+            for i in 0..n {
+                let Ok(info) = lista.GetValueAtIndex(i) else { continue };
+                let (mut pid, mut kind) = (0i32, COREWEBVIEW2_PROCESS_KIND::default());
+                if info.ProcessId(&mut pid).is_ok() && info.Kind(&mut kind).is_ok() {
+                    v.push((pid as u32, kind.0));
+                }
+            }
+        }
+        let _ = tx.send(v);
+    });
+    if pedido.is_err() {
+        return Vec::new();
+    }
+    rx.recv_timeout(Duration::from_secs(5)).unwrap_or_default()
+}
+
+/// Segundos sin tocar ratón ni teclado en todo el equipo.
+#[cfg(windows)]
+fn inactivo() -> Duration {
+    use windows::Win32::{System::SystemInformation::GetTickCount, UI::Input::KeyboardAndMouse::{GetLastInputInfo, LASTINPUTINFO}};
+    unsafe {
+        let mut li = LASTINPUTINFO { cbSize: std::mem::size_of::<LASTINPUTINFO>() as u32, dwTime: 0 };
+        if !GetLastInputInfo(&mut li).as_bool() {
+            return Duration::ZERO;
+        }
+        Duration::from_millis(GetTickCount().wrapping_sub(li.dwTime) as u64)
+    }
+}
+
+/// Ronda de memoria (cada minuto, hilo de salud): reparte la memoria por tipo y, si toca,
+/// recicla el proceso gráfico.
+#[cfg(windows)]
+pub fn ronda<R: Runtime>(app: &AppHandle<R>) -> Reparto {
+    const GPU: i32 = 4; // COREWEBVIEW2_PROCESS_KIND_GPU
+    const PESTANA: i32 = 1; // COREWEBVIEW2_PROCESS_KIND_RENDERER
+    let procs = procesos(app);
+    let mut r = Reparto::default();
+    let mut gpu = None;
+    for &(pid, kind) in &procs {
+        let mb = salud::memoria_privada_mb(pid);
+        match kind {
+            GPU => {
+                r.gpu_mb += mb;
+                gpu = Some((pid, mb));
+            }
+            PESTANA => r.pestanas_mb += mb,
+            _ => {}
+        }
+    }
+    if let Some((pid, mb)) = gpu {
+        if mb >= GPU_RECICLAR_MB {
+            let nadie_mira = app
+                .get_window("main")
+                .map(|w| !w.is_visible().unwrap_or(true) || w.is_minimized().unwrap_or(false))
+                .unwrap_or(false);
+            let toca = ULTIMO_RECICLAJE.lock().unwrap().map(|t| t.elapsed() >= RECICLAR_CADA).unwrap_or(true);
+            // Con la ventana a la vista solo si nadie toca el equipo Y no sale sonido: alguien
+            // viendo un video de revisión sin tocar nada está «inactivo» pero sí está mirando, y
+            // cortarle el proceso gráfico le daría un parpadeo en pleno video.
+            let quieto = inactivo() >= RECICLAR_INACTIVO && !crate::tracker::hay_audio_sonando();
+            if toca && (nadie_mira || quieto) {
+                *ULTIMO_RECICLAJE.lock().unwrap() = Some(Instant::now());
+                if terminar(pid) {
+                    salud::anotar("INFO", "memoria", &format!("proceso gráfico reciclado: tenía {mb} MB (WebView2 crea otro limpio)"));
+                } else {
+                    salud::anotar("AVISO", "memoria", &format!("no se pudo reciclar el proceso gráfico ({mb} MB)"));
+                }
+            }
+        }
+    }
+    r
+}
+#[cfg(not(windows))]
+pub fn ronda<R: Runtime>(_app: &AppHandle<R>) -> Reparto {
+    Reparto::default()
+}
+
+#[cfg(windows)]
+fn terminar(pid: u32) -> bool {
+    use windows::Win32::{
+        Foundation::CloseHandle,
+        System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE},
+    };
+    unsafe {
+        let Ok(h) = OpenProcess(PROCESS_TERMINATE, false, pid) else { return false };
+        let ok = TerminateProcess(h, 0).is_ok();
+        let _ = CloseHandle(h);
+        ok
+    }
+}

src-tauri/src/salud.rs

@@ -0,0 +1,519 @@
+// ── Salud de la app (v1.20.0): cuánto gasta de verdad, qué falla y cómo se repone sola ──
+//
+// POR QUÉ: la app es un exe pequeño (~60 MB) que cuelga de él una docena de procesos de WebView2
+// (uno por pestaña, más el GPU y los de utilidad). En el Administrador de tareas el gasto real
+// queda repartido entre «Microsoft Edge WebView2» y no se ve cuánto pesa Labstream OS entero; y
+// cuando algo fallaba (una pestaña en blanco, un cuelgue) no quedaba rastro. Este módulo:
+//
+// 1. MIDE cada minuto el ÁRBOL de procesos de la app (el exe + todos sus WebView2): memoria
+//    privada, CPU y número de procesos. Lo enseña en la bandeja («Recursos: 2,1 GB · CPU 3 %»)
+//    y lo anota en `recursos.csv`, para tener la curva de un día de trabajo real.
+//    Columnas del CSV: fecha, procesos, memoria_mb, cpu, pestañas, dormidas, descartadas,
+//    gpu_mb (proceso gráfico) y pestanas_mb (suma de los procesos de pestaña).
+// 2. ANOTA en `salud.log` lo que falla: pánicos de Rust, procesos de WebView2 caídos o colgados,
+//    errores de JavaScript de las páginas, el hilo principal sin responder y los cierres de golpe
+//    (si al arrancar sigue el testigo `en-marcha`, la sesión anterior no se cerró bien).
+// 3. SE REPONE: una pestaña cuyo proceso murió o se colgó se recarga sola (con freno: más de 3 en
+//    10 min y se deja quieta para no entrar en bucle); si muere el proceso principal de WebView2
+//    —se caen TODAS las pestañas— la app se reinicia; Windows la vuelve a abrir si se cuelga o
+//    se cierra de golpe (RegisterApplicationRestart); y con la memoria por encima del umbral se
+//    duermen ya las pestañas ocultas, sin esperar sus 5 minutos.
+//
+// Todo queda en la carpeta de logs de la app (%LOCALAPPDATA%\co.labstream.os\logs) y se abre
+// desde ⋮ ▸ Diagnóstico. No se envía nada a ningún sitio.
+
+use std::{
+    collections::HashMap,
+    fs,
+    io::Write,
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicBool, AtomicU32, Ordering},
+        Mutex, OnceLock,
+    },
+    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
+};
+
+use tauri::{menu::MenuItem, AppHandle, Manager, Runtime};
+
+const LOG_MAX: u64 = 2 * 1024 * 1024; // salud.log rota a salud.1.log al pasar de 2 MB
+const CSV_MAX: u64 = 4 * 1024 * 1024;
+const MUESTRA_CADA: Duration = Duration::from_secs(60);
+/// Memoria privada del árbol a partir de la cual se duermen ya las pestañas ocultas.
+pub const MEMORIA_ALTA_MB: u64 = 3 * 1024;
+const RECARGAS_MAX: usize = 3; // por pestaña…
+const RECARGAS_VENTANA: Duration = Duration::from_secs(10 * 60); // …en esta ventana
+
+static DIR: OnceLock<PathBuf> = OnceLock::new();
+static ESCRITURA: Mutex<()> = Mutex::new(());
+static ERRORES: AtomicU32 = AtomicU32::new(0);
+static RECUPERACIONES: AtomicU32 = AtomicU32::new(0);
+static REINICIANDO: AtomicBool = AtomicBool::new(false);
+static ULTIMA: Mutex<Option<Muestra>> = Mutex::new(None);
+static RECARGAS: OnceLock<Mutex<HashMap<String, Vec<Instant>>>> = OnceLock::new();
+static VISTOS_JS: OnceLock<Mutex<HashMap<String, Instant>>> = OnceLock::new();
+
+#[derive(Clone, Copy, Default)]
+pub struct Muestra {
+    pub procesos: u32,
+    pub memoria_mb: u64,
+    pub cpu: f64,
+}
+
+pub struct SaludUi<R: Runtime>(pub MenuItem<R>);
+
+// ── Diario ──
+
+/// Fecha y hora UTC en ISO 8601, sin dependencias (días civiles de Howard Hinnant).
+fn ahora_iso() -> String {
+    let s = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0) as i64;
+    let (dias, resto) = (s.div_euclid(86_400), s.rem_euclid(86_400));
+    let z = dias + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z - era * 146_097;
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = yoe + era * 400 + if m <= 2 { 1 } else { 0 };
+    format!("{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}Z", resto / 3600, resto % 3600 / 60, resto % 60)
+}
+
+fn anexar(nombre: &str, max: u64, linea: &str) {
+    let Some(dir) = DIR.get() else { return };
+    let _g = ESCRITURA.lock();
+    let ruta = dir.join(nombre);
+    if fs::metadata(&ruta).map(|m| m.len() > max).unwrap_or(false) {
+        let viejo = dir.join(nombre.replacen('.', ".1.", 1));
+        let _ = fs::remove_file(&viejo);
+        let _ = fs::rename(&ruta, &viejo);
+    }
+    if let Ok(mut f) = fs::OpenOptions::new().create(true).append(true).open(&ruta) {
+        let _ = writeln!(f, "{linea}");
+    }
+}
+
+/// Anota una línea en salud.log. `nivel`: INFO, AVISO o ERROR.
+pub fn anotar(nivel: &str, origen: &str, msg: &str) {
+    if nivel == "ERROR" {
+        ERRORES.fetch_add(1, Ordering::Relaxed);
+    }
+    let msg = msg.replace(['\r', '\n'], " ");
+    anexar("salud.log", LOG_MAX, &format!("{} {nivel:<5} {origen}: {msg}", ahora_iso()));
+}
+
+/// Error de JavaScript de una pestaña. El mismo mensaje no se repite más de una vez por minuto.
+pub fn error_js(label: &str, tipo: &str, msg: &str, src: &str, ruta: &str) {
+    let clave = format!("{tipo}|{msg}|{src}");
+    {
+        let mut v = VISTOS_JS.get_or_init(Default::default).lock().unwrap();
+        if v.get(&clave).map(|t| t.elapsed() < Duration::from_secs(60)).unwrap_or(false) {
+            return;
+        }
+        if v.len() > 500 {
+            v.clear();
+        }
+        v.insert(clave, Instant::now());
+    }
+    anotar("ERROR", &format!("js {label}"), &format!("{tipo} en {ruta}: {msg} [{src}]"));
+}
+
+pub fn carpeta() -> Option<PathBuf> {
+    DIR.get().cloned()
+}
+
+/// Texto para la bandeja y el menú ⋮.
+pub fn resumen() -> String {
+    if cfg!(not(windows)) {
+        return "Recursos: la medición es solo de Windows".into();
+    }
+    let Some(m) = *ULTIMA.lock().unwrap() else { return "Recursos: midiendo…".into() };
+    let mem = if m.memoria_mb >= 1024 { format!("{:.1} GB", m.memoria_mb as f64 / 1024.0).replace('.', ",") } else { format!("{} MB", m.memoria_mb) };
+    let mut s = format!("Recursos: {mem} · CPU {:.0} % · {} procesos", m.cpu, m.procesos);
+    let (e, r) = (ERRORES.load(Ordering::Relaxed), RECUPERACIONES.load(Ordering::Relaxed));
+    if e > 0 || r > 0 {
+        s.push_str(&format!(" · {e} errores, {r} recuperadas"));
+    }
+    s
+}
+
+// ── Arranque y salida ──
+
+/// Prepara la carpeta, el registro de pánicos, el testigo de cierre limpio y el reinicio automático.
+/// Va lo PRIMERO en setup: así un fallo del propio arranque ya queda anotado.
+pub fn preparar<R: Runtime>(app: &AppHandle<R>) {
+    let dir = app
+        .path()
+        .app_log_dir()
+        .or_else(|_| app.path().app_local_data_dir().map(|d| d.join("logs")))
+        .unwrap_or_else(|_| std::env::temp_dir().join("labstream-os-logs"));
+    let _ = fs::create_dir_all(&dir);
+    let _ = DIR.set(dir.clone());
+
+    let anterior = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |info| {
+        let donde = info.location().map(|l| format!("{}:{}", l.file(), l.line())).unwrap_or_default();
+        let que = info
+            .payload()
+            .downcast_ref::<&str>()
+            .map(|s| s.to_string())
+            .or_else(|| info.payload().downcast_ref::<String>().cloned())
+            .unwrap_or_default();
+        anotar("ERROR", "panico", &format!("{que} ({donde}) hilo={}", std::thread::current().name().unwrap_or("?")));
+        anterior(info);
+    }));
+
+    let testigo = dir.join("en-marcha");
+    if testigo.exists() {
+        anotar("ERROR", "app", "la sesión anterior terminó de golpe (cierre forzado, cuelgue, apagón o fallo)");
+    }
+    let _ = fs::write(&testigo, std::process::id().to_string());
+    anotar("INFO", "app", &format!("inicio v{} pid {}", app.package_info().version, std::process::id()));
+
+    #[cfg(windows)]
+    unsafe {
+        // Si la app se cuelga o se cae, Windows la vuelve a abrir (solo si llevaba ≥60 s en marcha,
+        // así que un fallo en el arranque no entra en bucle). Al reiniciar el equipo no: de eso ya
+        // se encarga el arranque automático.
+        use windows::Win32::System::Recovery::{RegisterApplicationRestart, RESTART_NO_REBOOT};
+        if RegisterApplicationRestart(windows::core::PCWSTR::null(), RESTART_NO_REBOOT).is_err() {
+            anotar("AVISO", "app", "no se pudo registrar el reinicio automático de Windows");
+        }
+    }
+}
+
+/// Salida limpia: borra el testigo (si no se borra, el próximo arranque anota un cierre de golpe).
+pub fn salida_limpia() {
+    if REINICIANDO.load(Ordering::Relaxed) {
+        anotar("INFO", "app", "reinicio para recuperarse");
+    } else {
+        anotar("INFO", "app", "salida");
+    }
+    if let Some(d) = DIR.get() {
+        let _ = fs::remove_file(d.join("en-marcha"));
+    }
+}
+
+/// Justo antes de que el instalador de una actualización cierre la app (en Windows lo hace él, sin
+/// pasar por la salida normal): se anota y se quita el testigo, para no contarlo como cierre de golpe.
+pub fn antes_de_actualizar(version: &str) {
+    anotar("INFO", "actualizacion", &format!("se instala la versión {version}"));
+    if let Some(d) = DIR.get() {
+        let _ = fs::remove_file(d.join("en-marcha"));
+    }
+}
+
+/// Hilo de medición y vigilante del hilo principal. `memoria_alta` se llama (como mucho cada 10
+/// min) cuando el árbol pasa de MEMORIA_ALTA_MB: lib.rs duerme ahí las pestañas ocultas.
+pub fn iniciar<R: Runtime>(app: &AppHandle<R>, item: MenuItem<R>, memoria_alta: impl Fn(&AppHandle<R>) + Send + 'static) {
+    app.manage(SaludUi(item));
+    let h = app.clone();
+    std::thread::Builder::new()
+        .name("salud-recursos".into())
+        .spawn(move || {
+            // El medidor de audio (memoria.rs → tracker::hay_audio_sonando) usa COM en este hilo.
+            #[cfg(windows)]
+            unsafe {
+                use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+                let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+            }
+            let mut medidor = Medidor::default();
+            let mut ultimo_aviso: Option<Instant> = None;
+            let mut pico = 0u64;
+            loop {
+                std::thread::sleep(MUESTRA_CADA);
+                // Primero la memoria (memoria.rs): niveles de las vistas y, si toca, reciclar el
+                // proceso gráfico. Luego se mide, para que la muestra ya refleje lo liberado.
+                crate::memoria::ajustar_niveles(&h);
+                let reparto = crate::memoria::ronda(&h);
+                let Some(m) = medidor.medir() else { continue };
+                *ULTIMA.lock().unwrap() = Some(m);
+                let (pestanas, dormidas, descartadas) = conteo_pestanas(&h);
+                anexar(
+                    "recursos.csv",
+                    CSV_MAX,
+                    &format!(
+                        "{},{},{},{:.1},{},{},{},{},{}",
+                        ahora_iso(), m.procesos, m.memoria_mb, m.cpu, pestanas, dormidas, descartadas, reparto.gpu_mb, reparto.pestanas_mb
+                    ),
+                );
+                if m.memoria_mb > pico + 256 && m.memoria_mb > 1024 {
+                    pico = m.memoria_mb;
+                    anotar("INFO", "recursos", &format!("nuevo pico de memoria: {} MB en {} procesos ({pestanas} pestañas)", m.memoria_mb, m.procesos));
+                }
+                if m.memoria_mb >= MEMORIA_ALTA_MB && ultimo_aviso.map(|t| t.elapsed() > Duration::from_secs(600)).unwrap_or(true) {
+                    ultimo_aviso = Some(Instant::now());
+                    anotar("AVISO", "recursos", &format!("memoria alta ({} MB): se duermen ya las pestañas ocultas", m.memoria_mb));
+                    memoria_alta(&h);
+                }
+                // set_text despacha al hilo principal y espera: aquí, en un hilo propio, es seguro.
+                let _ = h.state::<SaludUi<R>>().0.set_text(resumen());
+            }
+        })
+        .ok();
+
+    // ¿Responde el hilo principal? Un cuelgue de la interfaz (la ventana «No responde») no deja
+    // ningún otro rastro. Se le manda una tarea vacía cada 20 s; si tarda más de 15 s, se anota
+    // cuándo empezó y cuánto duró.
+    let h = app.clone();
+    std::thread::Builder::new()
+        .name("salud-vigilante".into())
+        .spawn(move || loop {
+            std::thread::sleep(Duration::from_secs(20));
+            let (tx, rx) = std::sync::mpsc::channel();
+            let t0 = Instant::now();
+            if h.run_on_main_thread(move || {
+                let _ = tx.send(());
+            })
+            .is_err()
+            {
+                return; // la app está cerrándose
+            }
+            if rx.recv_timeout(Duration::from_secs(15)).is_err() {
+                anotar("ERROR", "app", "el hilo principal no responde (la ventana se congeló)");
+                let _ = rx.recv();
+                anotar("AVISO", "app", &format!("el hilo principal volvió a responder tras {} s", t0.elapsed().as_secs()));
+            }
+        })
+        .ok();
+}
+
+fn conteo_pestanas<R: Runtime>(app: &AppHandle<R>) -> (usize, usize, usize) {
+    let shell = app.state::<crate::ShellState>();
+    let s = shell.lock().unwrap();
+    (s.tabs.len(), s.tabs.iter().filter(|t| t.dormida).count(), s.tabs.iter().filter(|t| t.descartada).count())
+}
+
+/// Memoria privada de un proceso, en MB (0 si no se puede abrir).
+#[cfg(windows)]
+pub fn memoria_privada_mb(pid: u32) -> u64 {
+    use windows::Win32::{
+        Foundation::CloseHandle,
+        System::{
+            ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS, PROCESS_MEMORY_COUNTERS_EX},
+            Threading::{OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION},
+        },
+    };
+    unsafe {
+        let Ok(hp) = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid) else { return 0 };
+        let mut mc = PROCESS_MEMORY_COUNTERS_EX { cb: std::mem::size_of::<PROCESS_MEMORY_COUNTERS_EX>() as u32, ..Default::default() };
+        let ok = GetProcessMemoryInfo(hp, &mut mc as *mut _ as *mut PROCESS_MEMORY_COUNTERS, mc.cb).is_ok();
+        let _ = CloseHandle(hp);
+        if ok {
+            mc.PrivateUsage as u64 / (1024 * 1024)
+        } else {
+            0
+        }
+    }
+}
+
+// ── Recuperación de pestañas (WebView2) ──
+
+#[cfg_attr(not(windows), allow(dead_code))] // en macOS no hay ProcessFailed: solo lo usa Windows
+/// ¿Se puede recargar otra vez esta pestaña? Freno contra bucles: RECARGAS_MAX en RECARGAS_VENTANA.
+fn permitir_recarga(label: &str) -> bool {
+    let mut m = RECARGAS.get_or_init(Default::default).lock().unwrap();
+    let v = m.entry(label.to_string()).or_default();
+    v.retain(|t| t.elapsed() < RECARGAS_VENTANA);
+    if v.len() >= RECARGAS_MAX {
+        return false;
+    }
+    v.push(Instant::now());
+    true
+}
+
+/// Se engancha al aviso `ProcessFailed` de WebView2 de una pestaña recién creada.
+#[cfg(windows)]
+pub fn vigilar_pestana<R: Runtime>(app: &AppHandle<R>, wv: &tauri::Webview<R>) {
+    let label = wv.label().to_string();
+    let h = app.clone();
+    let _ = wv.with_webview(move |pw| unsafe {
+        use webview2_com::{Microsoft::Web::WebView2::Win32::*, ProcessFailedEventHandler};
+        let Ok(core) = pw.controller().CoreWebView2() else { return };
+        let mut token = 0i64;
+        let handler = ProcessFailedEventHandler::create(Box::new(move |sender, args| {
+            let mut kind = COREWEBVIEW2_PROCESS_FAILED_KIND::default();
+            if let Some(a) = args {
+                let _ = a.ProcessFailedKind(&mut kind);
+            }
+            let recargar = |por: &str| {
+                if !permitir_recarga(&label) {
+                    anotar("ERROR", &format!("pestaña {label}"), &format!("{por} otra vez: ya se recargó {RECARGAS_MAX} veces en 10 min, se deja quieta"));
+                    crate::aviso_pestana_rota(&h, &label);
+                    return;
+                }
+                if let Some(c) = &sender {
+                    if c.Reload().is_ok() {
+                        RECUPERACIONES.fetch_add(1, Ordering::Relaxed);
+                        anotar("AVISO", &format!("pestaña {label}"), &format!("{por}: recargada sola"));
+                    }
+                }
+            };
+            match kind {
+                COREWEBVIEW2_PROCESS_FAILED_KIND_RENDER_PROCESS_EXITED => {
+                    anotar("ERROR", &format!("pestaña {label}"), "su proceso se cerró (pestaña en blanco)");
+                    recargar("proceso cerrado");
+                }
+                COREWEBVIEW2_PROCESS_FAILED_KIND_RENDER_PROCESS_UNRESPONSIVE => {
+                    anotar("ERROR", &format!("pestaña {label}"), "su proceso dejó de responder");
+                    recargar("proceso colgado");
+                }
+                COREWEBVIEW2_PROCESS_FAILED_KIND_BROWSER_PROCESS_EXITED => {
+                    // Lo avisan TODAS las pestañas a la vez: solo la primera reinicia.
+                    if !REINICIANDO.swap(true, Ordering::SeqCst) {
+                        anotar("ERROR", "webview2", "se cerró el proceso principal de WebView2: se reinicia la app");
+                        RECUPERACIONES.fetch_add(1, Ordering::Relaxed);
+                        crate::save_persisted(&h);
+                        let hh = h.clone();
+                        // Desde un hilo aparte, restart() pide la salida al bucle de eventos: pasa por
+                        // RunEvent::Exit (salida_limpia anota el reinicio y quita el testigo) y el
+                        // plugin de instancia única suelta su mutex ANTES de lanzar la copia nueva.
+                        std::thread::spawn(move || {
+                            std::thread::sleep(Duration::from_millis(500));
+                            hh.restart();
+                        });
+                    }
+                }
+                COREWEBVIEW2_PROCESS_FAILED_KIND_FRAME_RENDER_PROCESS_EXITED => {
+                    anotar("AVISO", &format!("pestaña {label}"), "se cerró el proceso de un marco interno (p. ej. un editor incrustado)");
+                }
+                COREWEBVIEW2_PROCESS_FAILED_KIND_GPU_PROCESS_EXITED => {
+                    anotar("AVISO", "webview2", "se reinició el proceso de gráficos (WebView2 lo levanta solo)");
+                }
+                otro => anotar("AVISO", "webview2", &format!("se cerró un proceso auxiliar (tipo {})", otro.0)),
+            }
+            Ok(())
+        }));
+        if core.add_ProcessFailed(&handler, &mut token).is_err() {
+            anotar("AVISO", "webview2", "no se pudo vigilar una pestaña");
+        }
+    });
+}
+#[cfg(not(windows))]
+pub fn vigilar_pestana<R: Runtime>(_app: &AppHandle<R>, _wv: &tauri::Webview<R>) {}
+
+// ── Medición del árbol de procesos ──
+
+#[derive(Default)]
+struct Medidor {
+    cpu_previa: HashMap<u32, u64>, // pid → tiempo de CPU acumulado (100 ns)
+    cuando: Option<Instant>,
+}
+
+#[cfg(windows)]
+impl Medidor {
+    fn medir(&mut self) -> Option<Muestra> {
+        use windows::Win32::{
+            Foundation::{CloseHandle, FILETIME},
+            System::{
+                Diagnostics::ToolHelp::{CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS},
+                ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS, PROCESS_MEMORY_COUNTERS_EX},
+                Threading::{GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION},
+            },
+        };
+        unsafe {
+            // 1. Todos los procesos con su padre; 2. el árbol que cuelga de este exe.
+            let snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0).ok()?;
+            let mut padres: Vec<(u32, u32)> = Vec::with_capacity(512);
+            let mut e = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..Default::default() };
+            if Process32FirstW(snap, &mut e).is_ok() {
+                loop {
+                    padres.push((e.th32ProcessID, e.th32ParentProcessID));
+                    if Process32NextW(snap, &mut e).is_err() {
+                        break;
+                    }
+                }
+            }
+            let _ = CloseHandle(snap);
+            let mut arbol = vec![std::process::id()];
+            let mut i = 0;
+            while i < arbol.len() {
+                let p = arbol[i];
+                for &(hijo, padre) in &padres {
+                    if padre == p && hijo != p && !arbol.contains(&hijo) {
+                        arbol.push(hijo);
+                    }
+                }
+                i += 1;
+            }
+
+            let mut memoria = 0u64;
+            let mut cpu_ahora: HashMap<u32, u64> = HashMap::new();
+            for &pid in &arbol {
+                let Ok(hp) = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid) else { continue };
+                let mut mc = PROCESS_MEMORY_COUNTERS_EX { cb: std::mem::size_of::<PROCESS_MEMORY_COUNTERS_EX>() as u32, ..Default::default() };
+                if GetProcessMemoryInfo(hp, &mut mc as *mut _ as *mut PROCESS_MEMORY_COUNTERS, mc.cb).is_ok() {
+                    memoria += mc.PrivateUsage as u64;
+                }
+                let (mut c, mut x, mut k, mut u) = (FILETIME::default(), FILETIME::default(), FILETIME::default(), FILETIME::default());
+                if GetProcessTimes(hp, &mut c, &mut x, &mut k, &mut u).is_ok() {
+                    let t = |f: FILETIME| ((f.dwHighDateTime as u64) << 32) | f.dwLowDateTime as u64;
+                    cpu_ahora.insert(pid, t(k) + t(u));
+                }
+                let _ = CloseHandle(hp);
+            }
+
+            // CPU: lo gastado desde la muestra anterior, sobre el tiempo de reloj × núcleos (como
+            // la columna CPU del Administrador de tareas). Un proceso que no estaba en la muestra
+            // anterior empieza a contar en la siguiente (si no, sumaría toda su vida de golpe).
+            let ahora = Instant::now();
+            let cpu = match self.cuando {
+                Some(antes) => {
+                    let pared = ahora.duration_since(antes).as_secs_f64() * 1e7; // en 100 ns
+                    let nucleos = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1) as f64;
+                    let gastado: u64 = cpu_ahora.iter().filter_map(|(p, t)| self.cpu_previa.get(p).map(|antes| t.saturating_sub(*antes))).sum();
+                    (gastado as f64 / (pared * nucleos) * 100.0).clamp(0.0, 100.0)
+                }
+                None => 0.0,
+            };
+            self.cpu_previa = cpu_ahora;
+            self.cuando = Some(ahora);
+            Some(Muestra { procesos: arbol.len() as u32, memoria_mb: memoria / (1024 * 1024), cpu })
+        }
+    }
+}
+
+#[cfg(not(windows))]
+impl Medidor {
+    fn medir(&mut self) -> Option<Muestra> {
+        None // macOS: pendiente (proc_pidinfo); el equipo de edición es Windows
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fecha_iso_con_formato_fijo() {
+        let f = ahora_iso();
+        assert_eq!(f.len(), 20, "{f}");
+        assert!(f.starts_with("20") && f.ends_with('Z') && &f[10..11] == "T", "{f}");
+    }
+
+    #[test]
+    fn el_freno_corta_la_cuarta_recarga() {
+        let l = "tab-prueba-freno";
+        assert!(permitir_recarga(l));
+        assert!(permitir_recarga(l));
+        assert!(permitir_recarga(l));
+        assert!(!permitir_recarga(l), "la cuarta en 10 minutos no se permite");
+        assert!(permitir_recarga("otra-pestana"), "el freno es por pestaña");
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn mide_al_menos_este_proceso() {
+        // un binario de prueba casi no reserva memoria: se le da 32 MB tocados para que se note
+        let lastre = vec![1u8; 32 * 1024 * 1024];
+        let mut m = Medidor::default();
+        let a = m.medir().expect("primera muestra");
+        assert!(a.procesos >= 1 && a.memoria_mb > 0, "procesos={} memoria={}", a.procesos, a.memoria_mb);
+        assert_eq!(a.cpu, 0.0, "sin muestra previa no hay CPU");
+        std::thread::sleep(Duration::from_millis(200));
+        let b = m.medir().expect("segunda muestra");
+        assert!((0.0..=100.0).contains(&b.cpu));
+        assert!(lastre.iter().all(|&x| x == 1));
+    }
+}

src-tauri/src/tracker.rs

@@ -0,0 +1,704 @@
+// ── 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)
+}
+
+// Segundos desde la última entrada del usuario (teclado/mouse/trackpad), preguntados al
+// subsistema HID de macOS. CGEventSourceSecondsSinceLastEventType es de solo LECTURA y NO
+// exige permiso de Accesibilidad ni de Monitorización de entrada (lo usan el salvapantallas y
+// `ioreg HIDIdleTime`). Con esto el sensor sabe si hubo actividad SIN el diálogo «… quiere
+// controlar este ordenador» que salía al leer el teclado global con device_query.
+#[cfg(target_os = "macos")]
+fn idle_seconds_macos() -> f64 {
+    const HID_SYSTEM_STATE: i32 = 1; // kCGEventSourceStateHIDSystemState
+    const ANY_INPUT_EVENT: u32 = 0xFFFF_FFFF; // kCGAnyInputEventType
+    #[link(name = "CoreGraphics", kind = "framework")]
+    extern "C" {
+        fn CGEventSourceSecondsSinceLastEventType(state_id: i32, event_type: u32) -> f64;
+    }
+    unsafe { CGEventSourceSecondsSinceLastEventType(HID_SYSTEM_STATE, ANY_INPUT_EVENT) }
+}
+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)]
+pub(crate) 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))]
+pub(crate) 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);
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        let device_state = device_query::DeviceState::new();
+        let mut ultimo_input = ahora_seg();
+        #[cfg(not(target_os = "macos"))]
+        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 interesa el HECHO de que hubo entrada,
+            // nunca QUÉ se tecleó ni dónde.
+            //
+            // macOS: se pregunta al sistema cuántos segundos lleva SIN entrada (HID). Esa API
+            // NO exige permiso de Accesibilidad ni de Monitorización de entrada, así que ya no
+            // aparece el diálogo «… quiere controlar este ordenador». Inactividad < 1 tic =
+            // hubo entrada. Aquí `device_state`/`huella_anterior` no existen.
+            #[cfg(target_os = "macos")]
+            let hubo_input = idle_seconds_macos() < (TICK_SEG as f64) + 1.0;
+            // Windows/Linux: huella de entrada con device_query (posición del mouse + cuántas
+            // teclas hay presionadas). Leer esto ahí no pide permiso especial.
+            #[cfg(not(target_os = "macos"))]
+            let hubo_input = {
+                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 cambio = huella != huella_anterior || teclas > 0;
+                huella_anterior = huella;
+                cambio
+            };
+            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.5.1",
+  "version": "1.24.0",
   "identifier": "co.labstream.os",
   "build": {
     "frontendDist": "../dist"

tests/images.browser.cjs

@@ -0,0 +1,84 @@
+// Run with Playwright available: node tests/images.browser.cjs
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const http = require('node:http');
+const { chromium, webkit } = require('playwright');
+
+const root = path.join(__dirname, '..');
+const source = fs.readFileSync(path.join(root, 'src-tauri/src/lib.rs'), 'utf8');
+const template = source.match(/const INIT_JS_TPL: &str = r#"([\s\S]*?)"#;/)[1];
+const png = fs.readFileSync(path.join(root, 'app-icon.png'));
+const urls = [
+  '/api/files-asset/session?thumb=1',
+  '/api/files-asset/signed?thumb=1&t=expired.sig',
+  '/api/files-asset/poster?poster=1',
+  '/api/files-asset/large?thumb=xl',
+  '/api/files-asset/original',
+];
+const counts = { authenticated: 0, revalidated: 0, unauthorized: 0 };
+const server = http.createServer((req, res) => {
+  if (req.url.startsWith('/api/files-asset/')) {
+    if (req.headers.cookie !== 'test-session=ok') {
+      counts.unauthorized++;
+      res.writeHead(401, { 'Cache-Control': 'no-store' }).end();
+      return;
+    }
+    counts.authenticated++;
+    const headers = { 'Content-Type': 'image/png', 'Cache-Control': 'private, no-cache', ETag: '"cover-1"' };
+    if (req.headers['if-none-match'] === '"cover-1"') {
+      counts.revalidated++;
+      res.writeHead(304, headers).end();
+    } else res.writeHead(200, headers).end(png);
+    return;
+  }
+  res.writeHead(200, { 'Content-Type': 'text/html', 'Cache-Control': 'no-store' });
+  res.end(`<html><title>Portadas: prueba local</title><body>
+    ${urls.map((url, i) => `<img id="image-${i}" width="120" height="120" src="${url}">`).join('')}
+    <canvas width="16" height="16"></canvas></body></html>`);
+});
+
+(async () => {
+  let browser;
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const origin = `http://127.0.0.1:${server.address().port}`;
+    browser = await (process.env.TEST_BROWSER === 'webkit' ? webkit : chromium).launch({ headless: true });
+    const context = await browser.newContext();
+    await context.addCookies([{ name: 'test-session', value: 'ok', url: origin, httpOnly: true }]);
+    await context.addInitScript(`window.__TAURI__ = { event: { emit() {} } };`);
+    await context.addInitScript(template.replaceAll('__ORIGIN__', origin).replaceAll('__LABEL__', 'tab-test'));
+    const page = await context.newPage();
+    const errors = [];
+    page.on('pageerror', (error) => errors.push(error.message));
+    await page.goto(origin);
+    await page.waitForFunction(() => [...document.images].every((image) => image.complete && image.naturalWidth > 0));
+    assert.deepEqual(await page.locator('img').evaluateAll((images) => images.map((image) => image.getAttribute('src'))), urls);
+    // Cached images must still be readable by the annotation canvas.
+    assert.equal(await page.evaluate(() => {
+      const canvas = document.querySelector('canvas');
+      canvas.getContext('2d').drawImage(document.images[0], 0, 0, 16, 16);
+      return canvas.toDataURL().startsWith('data:image/png;');
+    }), true);
+    await page.reload();
+    await page.waitForFunction(() => [...document.images].every((image) => image.complete && image.naturalWidth > 0));
+    assert.ok(counts.revalidated >= urls.length, 'HTTP cache revalidation expected on reload');
+    await page.evaluate(() => {
+      const image = new Image();
+      image.id = 'dynamic';
+      image.setAttribute('src', '/api/files-asset/dynamic?thumb=1');
+      document.body.appendChild(image);
+    });
+    await page.waitForFunction(() => document.getElementById('dynamic').naturalWidth > 0);
+    // A native downloader without the webview session reproduces the 401.
+    assert.equal((await fetch(origin + urls[0])).status, 401);
+    await context.clearCookies();
+    await page.reload();
+    assert.equal(await page.locator('img').evaluateAll((images) => images.filter((image) => image.naturalWidth > 0).length), 0);
+    assert.deepEqual(errors, []);
+    console.log(JSON.stringify({ ok: true, covers: urls.length, dynamic: true, canvas: true, ...counts }));
+  } finally {
+    if (browser) await browser.close();
+    await new Promise((resolve) => server.close(resolve));
+  }
+})().catch((error) => { console.error(error); process.exitCode = 1; });

tests/images.test.cjs

@@ -0,0 +1,102 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const source = fs.readFileSync(path.join(__dirname, '../src-tauri/src/lib.rs'), 'utf8');
+const template = source.match(/const INIT_JS_TPL: &str = r#"([\s\S]*?)"#;/)[1];
+const origin = 'https://os.labstreamsas.com';
+
+function shell({ frame = false, host = origin, images = [] } = {}) {
+  class Image {
+    constructor(src = '') { this.attrs = { src }; }
+    get src() { return this.attrs.src; }
+    set src(value) { this.attrs.src = value; }
+    getAttribute(name) { return this.attrs[name]; }
+    setAttribute(name, value) { this.attrs[name] = value; }
+  }
+  const setter = Object.getOwnPropertyDescriptor(Image.prototype, 'src').set;
+  const setAttribute = Image.prototype.setAttribute;
+  const emitted = [];
+  const opened = [];
+  const listeners = {};
+  const nodes = images.map((src) => new Image(src));
+  const root = { classList: { contains: () => false } };
+  const win = {
+    __TAURI__: { event: { emit: (...args) => emitted.push(args) }, core: { invoke: (...args) => opened.push(args) } },
+    open: () => 'original',
+  };
+  win.self = win;
+  win.top = frame ? {} : win;
+  const sandbox = {
+    window: win, URL, HTMLImageElement: Image,
+    location: new URL(host + '/proyectos/ejemplo'),
+    document: {
+      readyState: 'complete', title: 'Entregables', documentElement: root, body: root,
+      querySelector: () => null, querySelectorAll: () => nodes,
+      addEventListener: (name, callback) => { listeners[name] = callback; },
+    },
+    history: {}, navigator: { platform: 'MacIntel' },
+    getComputedStyle: () => ({ backgroundColor: 'rgb(255, 255, 255)' }),
+    addEventListener: (name, callback) => { listeners[name] = callback; },
+    setTimeout: () => 0,
+  };
+  vm.runInNewContext(template.replaceAll('__ORIGIN__', origin).replaceAll('__LABEL__', 'tab-1'), sandbox);
+  return { Image, nodes, setter, setAttribute, win, emitted, opened, listeners };
+}
+
+test('does not replace native image setters or rewrite server-rendered covers', () => {
+  const urls = ['/api/files-asset/cover?thumb=1', '/api/files-asset/cover?t=123.sig&thumb=1'];
+  const state = shell({ images: urls });
+  assert.equal(Object.getOwnPropertyDescriptor(state.Image.prototype, 'src').set, state.setter);
+  assert.equal(state.Image.prototype.setAttribute, state.setAttribute);
+  assert.deepEqual(state.nodes.map((image) => image.src), urls);
+});
+
+for (const url of [
+  '/api/files-asset/cover?thumb=1',
+  '/api/files-asset/cover?t=expired.sig&thumb=1&v=abc',
+  '/api/files-asset/cover?thumb=xl',
+  '/api/files-asset/video?poster=1',
+  '/api/files-asset/original',
+  'https://other.example/image.webp',
+]) {
+  test(`keeps authenticated browser transport for ${url}`, () => {
+    const { Image } = shell();
+    const image = new Image();
+    image.src = url;
+    assert.equal(image.src, url);
+    image.setAttribute('src', url + '&r=1');
+    assert.equal(image.src, url + '&r=1');
+  });
+}
+
+test('tab opening and title reports still work', () => {
+  const { win, emitted } = shell();
+  win.open('/revisiones/123', '_blank');
+  assert.equal(emitted[0][0], 'ls-title');
+  assert.equal(emitted[0][1].title, 'Entregables');
+  assert.equal(emitted[1][0], 'ls-new-tab');
+  assert.equal(emitted[1][1].url, origin + '/revisiones/123');
+});
+
+test('does not interfere with embedded editors or unrelated origins', () => {
+  for (const options of [{ frame: true }, { host: 'https://docs.example.com' }, { host: 'https://docs.google.com' }]) {
+    const { win, emitted } = shell(options);
+    assert.equal(win.__lsShell, undefined);
+    assert.equal(win.open(), 'original');
+    assert.equal(emitted.length, 0);
+  }
+});
+
+test('Google editors and login use the system browser, never an embedded tab', () => {
+  for (const host of ['docs', 'sheets', 'drive', 'accounts']) {
+    const { win, emitted, opened } = shell();
+    const url = `https://${host}.google.com/example`;
+    win.open(url, '_blank');
+    assert.equal(emitted.filter(([name]) => name === 'ls-new-tab').length, 0);
+    assert.equal(opened[0][0], 'plugin:opener|open_url');
+    assert.equal(opened[0][1].url, url);
+  }
+});