Salud: el reinicio no se anota dos veces; en macOS la bandeja no se queda en «midiendo»

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
La ventana se muestra aunque tao crea que ya está visible
2026-10-14 08:33:16 -05:00 · 2026-10-14 08:28:30 -05:00 · 2026-10-14 08:16:27 -05:00 · 2026-10-03 11:53:53 -05:00 · 2026-10-03 11:46:29 -05:00 · 2026-09-22 17:54:57 -05:00
--- a/.github/workflows/build.yml
+++ b/.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
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -44,6 +44,9 @@ jobs:
      - 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
--- a/README.md
+++ b/README.md
@@ -39,6 +39,47 @@ 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
@@ -84,6 +125,28 @@ 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).
@@ -207,20 +270,72 @@ Es la forma de mirar un cambio visual —la barra, los colores— sin sacárselo

 ---

-## 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
-vez cada sistema muestra una advertencia. Es normal para apps internas:
+### Lo que pasaba hasta la 1.15.0

- **Windows (SmartScreen):** pantalla azul *"Windows protegió su PC"* →
-  **Más información → Ejecutar de todos modos**.
- **macOS (Gatekeeper):** *"no se puede abrir porque proviene de un desarrollador
-  no identificado"* → clic derecho sobre la app → **Abrir** → **Abrir**. (Si
-  insiste, ejecutar una vez: `xattr -cr "/Applications/Labstream OS.app"`.)
+El 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. En la app instalada se veía así:

-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
-en Mac (99 USD/año) para quitar estos avisos.
+```
+$ codesign -dv "/Applications/Labstream OS.app"
+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.

 ---

@@ -235,10 +350,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
 ```
--- a/dist/index.html
+++ b/dist/index.html
@@ -35,7 +35,16 @@
        /* 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
@@ -57,6 +66,13 @@
          --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 {
@@ -69,6 +85,13 @@
        --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 {
@@ -119,53 +142,46 @@
        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); }
-      /* Separador fino a la IZQUIERDA de cada inactiva; se oculta pegado a la activa,
-         al hover y en la primera (igual que Chrome). */
-      .tab:not(.active)::before {
-        content: "";
-        position: absolute;
-        left: -1px;
-        top: 50%;
-        transform: translateY(-50%);
-        width: 1px;
-        height: 16px;
-        background: var(--sep);
+      /* ── PROFUNDIDAD: las que no mandan están detrás ──────────────────────────────────
+         Antes la inactiva no era nada: texto suelto sobre la franja, al mismo plano que la
+         activa, y lo único que las separaba era un filete de 1px. Ahora la inactiva se HUNDE
+         —velo tenue y sombra interior— y al pasar el ratón el gesto se invierte: la sombra sale
+         hacia fuera y el fondo tira hacia el blanco de la activa, así que la pestaña sube hacia
+         ti. Es sombra y no relleno a propósito: un bloque gris sólido pesa tanto como la activa
+         y acaba compitiendo con ella.
+         Con fondo propio el separador vertical entre pestañas sobra —ya se ve dónde acaba cada
+         una—, así que se retiró. */
+      .tab:not(.active) {
+        background: var(--tab-atras);
+        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
-         un cuarto de círculo transparente que "derrama" el fondo hacia los lados. */
-      .tab.active::before,
-      .tab.active::after {
-        content: "";
-        position: absolute;
-        bottom: 0;
-        width: 8px;
-        height: 8px;
-      }
-      .tab.active::before {
-        left: -8px;
-        background: radial-gradient(circle at 0 0, transparent 8px, var(--tab-active-bg) 8.5px);
-      }
-      .tab.active::after {
-        right: -8px;
-        background: radial-gradient(circle at 8px 0, transparent 8px, var(--tab-active-bg) 8.5px);
-      }
+      /* AQUÍ ESTABAN LAS CURVAS CÓNCAVAS DE CHROME: dos piezas de 8px a los lados de la activa
+         con un cuarto de círculo transparente que derramaba su fondo hacia fuera. El truco de
+         Chrome funciona porque allí NO hay línea bajo la barra; aquí sí la hay, y esas dos
+         piezas blancas la partían en dos justo a los costados de la pestaña — la «fluctuación»
+         de la esquina. La activa ya se funde con el contenido por su propio fondo, que tapa la
+         línea exactamente por su ancho; sin las piezas no asoma nada. */
      /* ── Color de pestaña ────────────────────────────────────────────────────────────
         Misma idea que los grupos de Chrome: teñir para agrupar de un vistazo («todo lo de
         este cliente, en verde»). El color se elige con clic derecho sobre la pestaña ▸ Color,
@@ -185,8 +201,6 @@
      .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); }
-      /* Con fondo propio el separador vertical sobra: ya se ve dónde acaba cada pestaña. */
-      .tab[data-color]:not(.active)::before { display: none; }
      .tab[data-color].active { box-shadow: inset 0 3px 0 rgb(var(--tc)); }
      @media (prefers-color-scheme: dark) {
        :root:not(.claro) .tab[data-color]:not(.active) { background: rgba(var(--tc), 0.36); }
@@ -227,6 +241,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;
--- a/package-lock.json
+++ b/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"
      }
--- a/package.json
+++ b/package.json
@@ -1,9 +1,10 @@
 {
  "name": "labstream-desktop",
-  "version": "1.13.0",
+  "version": "1.20.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",
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -2366,11 +2366,13 @@ dependencies = [

 [[package]]
 name = "labstream-desktop"
-version = "1.13.0"
+version = "1.20.0"
 dependencies = [
 "active-win-pos-rs",
 "device_query",
 "gethostname 0.5.0",
+ "percent-encoding",
+ "rfd",
 "serde",
 "serde_json",
 "tauri",
@@ -2382,6 +2384,7 @@ dependencies = [
 "tauri-plugin-single-instance",
 "tauri-plugin-updater",
 "ureq",
+ "webview2-com",
 "windows 0.61.3",
 ]

@@ -3603,6 +3606,29 @@ dependencies = [
 "web-sys",
 ]

+[[package]]
+name = "rfd"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20dafead71c16a34e1ff357ddefc8afc11e7d51d6d2b9fbd07eaa48e3e540220"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "js-sys",
+ "libc",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "percent-encoding",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.14"
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "labstream-desktop"
-version = "1.13.0"
+version = "1.20.0"
 description = "Cliente de escritorio de Labstream OS"
 authors = ["Labstream SAS"]
 edition = "2021"
@@ -28,6 +28,19 @@ 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ó).
@@ -51,6 +64,8 @@ device_query = "4"
 # 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]
+# 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",
@@ -60,4 +75,12 @@ windows = { version = "0.61", features = [
    "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",
 ] }
--- a/src-tauri/Entitlements.plist
+++ b/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). -->
-	<key>com.apple.security.network.client</key>
-	<true/>
-	<!-- Requerido por WKWebView (JIT de JavaScript) bajo hardened runtime. -->
+	<!-- WKWebView compila JavaScript en caliente. Bajo hardened runtime eso es memoria
+	     ejecutable y hay que pedirlo explícitamente. -->
 	<key>com.apple.security.cs.allow-jit</key>
 	<true/>
 </dict>
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -23,6 +23,8 @@
 //   - Globo de NO-LEÍDOS en el icono (evento `ls-badge` desde la web app): número en el
 //     Dock (macOS), punto rojo en la barra de tareas (Windows) y tooltip de la bandeja.
 //   - ZOOM de interfaz (Cmd/Ctrl +/−/0 y Ctrl+rueda) con persistencia entre sesiones.
+//   - DESCARGAS con «Guardar como»: el sistema pregunta dónde guardar cada archivo (con el
+//     nombre que sugiere el servidor) en vez de dejarlo caer en silencio en Descargas.
 //   - Sesión restaurada: al reabrir vuelve con las mismas pestañas y tamaño de ventana.
 //   - single-instance (solo release): abrir la app de nuevo enfoca la ventana existente.
 //   - macOS: clic en el Dock reabre la ventana oculta (RunEvent::Reopen) y menú nativo con
@@ -34,8 +36,15 @@

 mod cache;
 mod tracker;
+mod salud;
+mod memoria;

-use std::sync::Mutex;
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Mutex,
+    time::{Duration, Instant},
+};

 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -54,11 +63,7 @@ use tauri_plugin_opener::OpenerExt;

 const SERVER_URL: &str = "https://os.labstreamsas.com";

-// Los documentos del contador viven en Google (pestaña Contable). Se abren como PESTANAS
-// de esta app, no en el navegador externo: asi el WebView guarda la sesion de Google del
-// usuario (cookies persistentes) y no hay que iniciar sesion cada vez. La lista es cerrada
-// a proposito: solo hosts propios de Google (docs/drive/sheets y accounts para el login).
-// Todo lo demas sigue yendo al navegador del sistema.
+// Google requiere el navegador del sistema para autenticar y editar con compatibilidad completa.
 const GOOGLE_HOSTS: &[&str] = &[
    "docs.google.com",
    "drive.google.com",
@@ -73,13 +78,23 @@ fn is_google_host(host: &str) -> bool {
 }

 fn es_pestana_interna(target: &Url, server: &Url) -> bool {
-    if target.origin() == server.origin() {
-        return true;
+    target.origin() == server.origin()
+}
+
+#[cfg(test)]
+mod navigation_tests {
+    use super::*;
+
+    #[test]
+    fn only_labstream_is_an_embedded_tab() {
+        let server = Url::parse(SERVER_URL).unwrap();
+        assert!(es_pestana_interna(&server.join("/revisiones/1").unwrap(), &server));
+        for url in ["https://docs.google.com/document/d/1/edit", "https://accounts.google.com", "https://os.labstreamsas.com.evil.example", "http://os.labstreamsas.com"] {
+            assert!(!es_pestana_interna(&Url::parse(url).unwrap(), &server));
+        }
+        assert!(is_google_host("docs.google.com"));
+        assert!(!is_google_host("docs.google.com.evil.example"));
    }
-    if target.scheme() != "https" {
-        return false;
-    }
-    target.host_str().map(is_google_host).unwrap_or(false)
 }
 const TAB_BAR_H: f64 = 40.0; // alto lógico de la barra de pestañas (chrome)
 const CHROME: &str = "chrome";
@@ -100,6 +115,13 @@ struct TabRec {
    // Color elegido a mano desde el menú de la pestaña (None = sin teñir). Aquí solo vive el
    // NOMBRE; el tono exacto y cómo se pinta son cosa del CSS de la barra.
    color: Option<String>,
+    // Reposo (ver «Pestañas en reposo»): desde cuándo está oculta (None = es la activa) y si ya
+    // se suspendió.
+    oculta_desde: Option<Instant>,
+    dormida: bool,
+    // Ahorro de memoria (memoria.rs): su webview se cerró tras DESCARTE_TRAS dormida. Sigue en la
+    // barra con título, URL y color, y se crea otra vez al volver a ella.
+    descartada: bool,
 }

 // Paleta de colores de pestaña, la misma idea que los grupos de Chrome: sirve para agrupar de
@@ -142,6 +164,15 @@ impl Default for Shell {

 type ShellState = Mutex<Shell>;

+// Rutas elegidas en «Guardar como» de las descargas EN CURSO, por URL de origen. Hace falta para
+// nombrar el archivo al terminar: en macOS `DownloadEvent::Finished` llega SIEMPRE con
+// `path: None` (wry-0.55.1/src/wkwebview/download.rs:98-99 pasa `None` a mano), así que la única
+// forma de decir «Descargado: informe.xlsx» es recordar aquí lo que el usuario eligió. La URL es
+// la misma en Requested y en Finished en ambos motores (DownloadOperation.Uri en WebView2;
+// originalRequest.URL en WKDownload).
+#[derive(Default)]
+struct Descargas(Mutex<HashMap<String, PathBuf>>);
+
 #[derive(Clone, Copy, Serialize, Deserialize)]
 struct WinRect {
    x: f64,
@@ -163,6 +194,10 @@ struct Persisted {
    // que un estado.json viejo (sin colores) siga cargando tal cual.
    #[serde(default)]
    colors: Vec<String>,
+    // Título de cada pestaña (mismo orden): al abrir, las que no son la activa se quedan sin
+    // cargar (ver `registrar_diferida`) y la barra necesita algo que enseñar mientras tanto.
+    #[serde(default)]
+    titles: Vec<String>,
    #[serde(default)]
    active: usize,
    #[serde(default)]
@@ -194,6 +229,7 @@ fn save_persisted<R: Runtime>(app: &AppHandle<R>) {
            win: s.win,
            tabs: s.tabs.iter().map(|t| t.url.clone()).collect(),
            colors: s.tabs.iter().map(|t| t.color.clone().unwrap_or_default()).collect(),
+            titles: s.tabs.iter().map(|t| t.title.clone()).collect(),
            active: s.active,
            autostart: s.autostart,
            dark: s.dark,
@@ -233,12 +269,7 @@ const INIT_JS_TPL: &str = r#"
  // descargar fallaban solo en la app de Windows, y no en Mac ni en el navegador.
  // En macOS estas dos líneas son un no-op: allí el script nunca ha corrido en subframes.
  try { if (window.top !== window.self) return; } catch (e) { return; }
-  // Hosts de Google que la app abre como pestana propia (pestana Contable). En esas
-  // paginas solo reportamos titulo a la barra; NO tocamos clics ni window.open para no
-  // romper el editor de Google.
-  var GOOGLE_RE = /^(?:.*\.)?(?:docs|drive|sheets|accounts|myaccount)\.google\.com$/i;
-  var esGoogle = GOOGLE_RE.test(location.hostname);
-  if (location.origin !== ORIGIN && !esGoogle) return;
+  if (location.origin !== ORIGIN) return;

  if (window.__lsShell) return;
  window.__lsShell = true;
@@ -249,8 +280,7 @@ const INIT_JS_TPL: &str = r#"
  function abs(h) { try { return new URL(h, location.href); } catch (e) { return null; } }
  function isHttp(u) { return !!u && (u.protocol === 'http:' || u.protocol === 'https:'); }
  function isApp(u) { return isHttp(u) && u.origin === ORIGIN; }
-  function isGoogleUrl(u) { return isHttp(u) && GOOGLE_RE.test(u.hostname); }
-  function isInterno(u) { return isApp(u) || isGoogleUrl(u); }
+  function isInterno(u) { return isApp(u); }
  function isExt(u) { return isHttp(u) && !isInterno(u); }
  function emit(name, payload) { try { T.event.emit(name, payload); } catch (e) {} }
  function openExternal(url) {
@@ -259,73 +289,64 @@ const INIT_JS_TPL: &str = r#"
  }
  function newTab(url) { emit('ls-new-tab', { url: url }); }

-  // ── Miniaturas por el CAJÓN de la app (lsthumb://) ──
-  // Dentro de la app de escritorio, las miniaturas de la cuadrícula de fotos se piden por el
-  // esquema lsthumb:// en vez de directo al servidor. Así las sirve el cajón local (Rust): del
-  // disco si ya están —sobreviven a cerrar la app, que es lo que se pedía— y del NAS solo la
-  // primera vez. Fuera de la app (navegador normal) este script no corre y todo sigue igual.
-  //
-  // Se reescribe SOLO la miniatura de 480 px (thumb=1): es la que se repite 500 veces por set y
-  // ahoga la cuadrícula. El visor grande (thumb=xl) y la anotación sobre lienzo NO se tocan —
-  // cargar la imagen del lienzo por otro esquema lo «ensuciaría» y rompería «guardar el dibujo».
+  // ── Errores de la página → diario de salud del shell (salud.log) ──
+  // Solo el mensaje, el archivo:línea y la ruta (sin datos del formulario ni de la sesión). Como
+  // mucho 20 por carga de página; el shell además descarta repetidos durante un minuto.
+  var errores = 0;
+  function reportarError(tipo, msg, src) {
+    if (++errores > 20) return;
+    emit('ls-error', { label: LABEL, tipo: tipo, msg: String(msg || '').slice(0, 300), src: String(src || '').slice(0, 200), url: location.pathname });
+  }
+  addEventListener('error', function (e) {
+    // Con captura llegan también las imágenes o scripts que no cargan: esos no traen mensaje.
+    if (e && e.message) reportarError('error', e.message, (e.filename || '') + ':' + (e.lineno || 0));
+  }, true);
+  addEventListener('unhandledrejection', function (e) {
+    var r = e && e.reason;
+    reportarError('promesa', (r && (r.stack || r.message)) || r, '');
+  });
+
+  // ── Reposo ──
+  // El shell suspende las pestañas que llevan un rato ocultas (dejan de gastar CPU y sueltan
+  // memoria). Antes PREGUNTA: una pestaña con una subida o una descarga en curso, o con algo
+  // sonando, no se duerme. Se cuentan las peticiones vivas (fetch y XHR; el stream del chat es
+  // EventSource y no cuenta) y, ante cualquier duda, la cuenta se queda arriba: no dormir es
+  // siempre el lado seguro.
+  var enCurso = 0;
  try {
-    function porCajon(src) {
-      if (!src || src.lastIndexOf('lsthumb:', 0) === 0) return src; // ya reescrita
-      var u = abs(src);
-      if (!u || u.origin !== ORIGIN) return src;                    // solo lo del propio servidor
-      if (!/\/api\/files-asset\//.test(u.pathname) || u.searchParams.get('thumb') !== '1') return src;
-      return 'lsthumb://c/?u=' + encodeURIComponent(u.href);
-    }
-    var proto = HTMLImageElement.prototype;
-    // 1) La propiedad .src (lo que usa React al asignar la imagen).
-    var d = Object.getOwnPropertyDescriptor(proto, 'src');
-    if (d && d.get && d.set) {
-      Object.defineProperty(proto, 'src', {
-        configurable: true, enumerable: d.enumerable,
-        get: function () { return d.get.call(this); },
-        set: function (v) { d.set.call(this, porCajon(String(v))); },
-      });
-    }
-    // 2) setAttribute('src', …), que no pasa por el setter de la propiedad. Se parchea SOLO en
-    //    <img> (prototipo de HTMLImageElement), no en todos los elementos.
-    var setA = proto.setAttribute;
-    proto.setAttribute = function (name, value) {
-      if (arguments.length >= 2 && String(name).toLowerCase() === 'src') {
-        return setA.call(this, name, porCajon(String(value)));
-      }
-      return setA.apply(this, arguments);
+    var _send = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.send = function () {
+      var hecho = false;
+      enCurso++;
+      this.addEventListener('loadend', function () { if (!hecho) { hecho = true; enCurso--; } });
+      try { return _send.apply(this, arguments); }
+      catch (e) { if (!hecho) { hecho = true; enCurso--; } throw e; }
    };
-    // 3) Las que ya vienen en el HTML del servidor (SSR) o llegan luego. porCajon es idempotente
-    //    (una ya reescrita se devuelve igual), así que barrer no entra en bucle con el observer.
-    function barrer(raiz) {
-      if (!raiz || !raiz.querySelectorAll) return;
-      var imgs = raiz.querySelectorAll('img[src]');
-      for (var i = 0; i < imgs.length; i++) {
-        var cur = imgs[i].getAttribute('src');
-        var nue = porCajon(cur);
-        if (nue !== cur) imgs[i].setAttribute('src', nue);
-      }
+    var _fetch = window.fetch;
+    if (_fetch) {
+      window.fetch = function () {
+        enCurso++;
+        var baja = function () { enCurso--; };
+        var p;
+        try { p = _fetch.apply(this, arguments); } catch (e) { baja(); throw e; }
+        p.then(baja, baja);
+        return p;
+      };
    }
-    if (window.MutationObserver) {
-      new MutationObserver(function (muts) {
-        for (var i = 0; i < muts.length; i++) {
-          var m = muts[i];
-          if (m.type === 'attributes' && m.target && m.target.tagName === 'IMG') {
-            var cur = m.target.getAttribute('src'), nue = porCajon(cur);
-            if (nue !== cur) m.target.setAttribute('src', nue);
-          }
-          for (var j = 0; j < m.addedNodes.length; j++) {
-            var n = m.addedNodes[j];
-            if (!n || n.nodeType !== 1) continue;
-            if (n.tagName === 'IMG') { var c = n.getAttribute('src'), x = porCajon(c); if (x !== c) n.setAttribute('src', x); }
-            else barrer(n);
-          }
-        }
-      }).observe(document.documentElement, { childList: true, subtree: true, attributes: true, attributeFilter: ['src'] });
-    }
-    if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', function () { barrer(document); });
-    else barrer(document);
-  } catch (e) { /* si algo falla, las imágenes cargan directo del servidor como siempre */ }
+  } catch (e) {}
+  window.__lsReposo = function () {
+    var suena = false;
+    try {
+      var medios = document.querySelectorAll('video,audio');
+      for (var i = 0; i < medios.length; i++) { if (!medios[i].paused && !medios[i].ended) suena = true; }
+    } catch (e) { suena = true; }
+    emit('ls-reposo', { label: LABEL, libre: enCurso <= 0 && !suena });
+  };
+
+  // Las imagenes conservan su URL HTTPS y la sesion del webview. El descargador
+  // lsthumb no comparte cookies: falla con miniaturas sin token y omite la
+  // revalidacion de permisos al leer del disco. La cache HTTP respeta los ETag
+  // y Cache-Control del servidor sin modificar src, srcset ni la hidratacion.

  // ── ¿La página se VE oscura? ──
  // Señales, de la más directa a la más física: la clase `dark` (next-themes) y, si no
@@ -378,7 +399,6 @@ const INIT_JS_TPL: &str = r#"
    history[k] = function () { var r = o.apply(this, arguments); setTimeout(report, 0); return r; };
  });
  addEventListener('popstate', function () { setTimeout(report, 0); });
-  if (esGoogle) return; // en Google solo miramos el titulo
  // Pulsar la luna cambia clases/estilos sin navegar: se vigilan <html> y <body> (cuando
  // existan — a document-start aún no hay), y tras la carga se re-reporta un par de veces
  // por si el tema aterriza tarde con la hidratación.
@@ -401,9 +421,6 @@ const INIT_JS_TPL: &str = r#"
    if (!u) return;
    if (isExt(u)) { e.preventDefault(); openExternal(u.href); return; }
    var mod = e.metaKey || e.ctrlKey;
-    // Enlace a Google (docs, drive, sheets, accounts): SIEMPRE como pestana propia
-    // aunque no lleve target=_blank, para que la sesion viva dentro de la app.
-    if (isGoogleUrl(u)) { e.preventDefault(); newTab(u.href); return; }
    if (isApp(u) && (mod || a.target === '_blank')) { e.preventDefault(); newTab(u.href); }
  }, true);

@@ -433,6 +450,10 @@ const INIT_JS_TPL: &str = r#"
    // nota y en cualquier campo de la app. En macOS no aplica (Option no toca ctrlKey).
    if (e.altKey) return;
    var mod = e.metaKey || e.ctrlKey;
+    // F5 recarga, como en cualquier navegador de Windows (y Ctrl+F5 / Shift+F5 también). WebView2
+    // tiene apagados sus propios atajos, así que F5 no hacía NADA: el único que recargaba era
+    // Ctrl+R, y va antes del filtro de abajo porque F5 no lleva modificador.
+    if (e.key === 'F5') { e.preventDefault(); location.reload(); return; }
    if (!mod) return;
    var k = e.key;
    if (k === 't' || k === 'T') {
@@ -471,6 +492,110 @@ const INIT_JS_TPL: &str = r#"
 })();
 "#;

+// ── Pestañas en reposo ──
+//
+// Cada pestaña es la web app ENTERA: su árbol de React, su conexión del chat, sus sondeos. Con
+// seis abiertas corrían seis, aunque solo se mire una. Una pestaña que lleva REPOSO_TRAS oculta
+// se SUSPENDE (WebView2 `TrySuspend`: se congelan sus temporizadores y el sistema puede recuperar
+// su memoria) y despierta sola, donde estaba, al volver a ella. La activa nunca se duerme, así
+// que los avisos y el globo de no leídos siguen llegando por ella.
+//
+// No se duerme: la que está cargando, la que dice estar ocupada (subida, descarga o audio en
+// curso: ver `__lsReposo` en el script de la pestaña) ni un editor de documentos (`/docs/`:
+// OnlyOffice mantiene su propia conexión de edición y no conviene cortarla).
+// Solo Windows: WKWebView (macOS) no ofrece nada equivalente y ya frena lo oculto por su cuenta.
+const REPOSO_TRAS: Duration = Duration::from_secs(5 * 60);
+const REPOSO_RONDA: Duration = Duration::from_secs(60);
+
+fn puede_reposar(t: &TabRec, activa: bool) -> bool {
+    !activa
+        && !t.dormida
+        && !t.loading
+        && !t.url.contains("/docs/")
+        && t.oculta_desde.map(|d| d.elapsed() >= REPOSO_TRAS).unwrap_or(false)
+}
+
+// Cada minuto: a las candidatas se les PREGUNTA si están libres. La respuesta llega por el
+// evento `ls-reposo` y es ahí donde se suspende.
+fn ronda_de_reposo<R: Runtime>(app: &AppHandle<R>) {
+    let candidatas: Vec<String> = {
+        let shell = app.state::<ShellState>();
+        let s = shell.lock().unwrap();
+        s.tabs.iter().enumerate().filter(|(i, t)| puede_reposar(t, *i == s.active)).map(|(_, t)| t.label.clone()).collect()
+    };
+    for label in candidatas {
+        if let Some(wv) = get_webview(app, &label) {
+            let _ = wv.eval("window.__lsReposo && window.__lsReposo()");
+        }
+    }
+    // Ahorro de memoria: las que llevan DESCARTE_TRAS ocultas y ya están dormidas (pasaron el
+    // filtro de arriba: sin subida, descarga ni audio, y no son un editor) se descartan.
+    let a_descartar: Vec<String> = {
+        let shell = app.state::<ShellState>();
+        let s = shell.lock().unwrap();
+        s.tabs
+            .iter()
+            .enumerate()
+            .filter(|(i, t)| {
+                *i != s.active
+                    && t.dormida
+                    && !t.descartada
+                    && !t.url.contains("/docs/")
+                    && t.oculta_desde.map(|d| d.elapsed() >= memoria::DESCARTE_TRAS).unwrap_or(false)
+            })
+            .map(|(_, t)| t.label.clone())
+            .collect()
+    };
+    for label in a_descartar {
+        descartar_pestana(app, &label);
+    }
+}
+
+fn dormir_pestana<R: Runtime>(app: &AppHandle<R>, label: &str) {
+    {
+        let shell = app.state::<ShellState>();
+        let mut s = shell.lock().unwrap();
+        let activa = s.active;
+        let Some((i, t)) = s.tabs.iter_mut().enumerate().find(|(_, t)| t.label == label) else { return };
+        // Pudo volverse la activa (o empezar a cargar) mientras contestaba.
+        if !puede_reposar(t, i == activa) {
+            return;
+        }
+        t.dormida = true;
+    }
+    if let Some(wv) = get_webview(app, label) {
+        dormir_webview(&wv);
+    }
+}
+
+#[cfg(windows)]
+fn dormir_webview<R: Runtime>(wv: &Webview<R>) {
+    let _ = wv.with_webview(|pw| unsafe {
+        use webview2_com::{Microsoft::Web::WebView2::Win32::ICoreWebView2_3, TrySuspendCompletedHandler};
+        use windows::core::Interface;
+        let Ok(core) = pw.controller().CoreWebView2() else { return };
+        let Ok(core3) = core.cast::<ICoreWebView2_3>() else { return };
+        // Si WebView2 no puede (la pestaña está visible, o usa algo que lo impide), no pasa nada.
+        let _ = core3.TrySuspend(&TrySuspendCompletedHandler::create(Box::new(|_, _| Ok(()))));
+    });
+}
+#[cfg(not(windows))]
+fn dormir_webview<R: Runtime>(_wv: &Webview<R>) {}
+
+// WebView2 ya despierta sola una vista al hacerla visible; se pide igual, por si acaso.
+#[cfg(windows)]
+fn despertar_webview<R: Runtime>(wv: &Webview<R>) {
+    let _ = wv.with_webview(|pw| unsafe {
+        use webview2_com::Microsoft::Web::WebView2::Win32::ICoreWebView2_3;
+        use windows::core::Interface;
+        let Ok(core) = pw.controller().CoreWebView2() else { return };
+        let Ok(core3) = core.cast::<ICoreWebView2_3>() else { return };
+        let _ = core3.Resume();
+    });
+}
+#[cfg(not(windows))]
+fn despertar_webview<R: Runtime>(_wv: &Webview<R>) {}
+
 // ── Utilidades del shell ──

 fn main_window<R: Runtime>(app: &AppHandle<R>) -> Option<Window<R>> {
@@ -560,23 +685,133 @@ fn activate_tab<R: Runtime>(app: &AppHandle<R>, label: &str) {
        } else {
            return;
        }
+        // Reposo: la activa deja de contar; las demás empiezan a contar desde que se ocultan.
+        let ahora = Instant::now();
+        let activa = s.active;
+        for (i, t) in s.tabs.iter_mut().enumerate() {
+            if i == activa {
+                t.oculta_desde = None;
+                t.dormida = false;
+            } else if t.oculta_desde.is_none() {
+                t.oculta_desde = Some(ahora);
+            }
+        }
    }
+    // Descartada por ahorro de memoria: se crea otra vez en su última URL antes de mostrarla.
+    revivir_pestana(app, label);
    let Some(win) = main_window(app) else { return };
    for wv in win.webviews() {
        if wv.label() == CHROME {
            continue;
        }
        if wv.label() == label {
+            despertar_webview(&wv);
+            memoria::nivel_bajo(&wv, false);
            let _ = wv.show();
            let _ = wv.set_focus();
        } else {
            let _ = wv.hide();
+            // Oculta: que WebView2 suelte cachés y memoria que puede regenerar (memoria.rs).
+            memoria::nivel_bajo(&wv, true);
        }
    }
    broadcast(app);
    save_persisted(app);
 }

+// ── Descargas: «Guardar como» ──
+//
+// tauri::webview::DownloadEvent avisa DOS veces por descarga:
+//   - Requested { url, destination: &mut PathBuf }: antes de empezar. `destination` trae la ruta
+//     que el motor usaría por defecto (carpeta Descargas + nombre sugerido) y se puede
+//     SOBRESCRIBIR (ruta absoluta); devolver false cancela la descarga.
+//   - Finished { url, path: Option<PathBuf>, success }: al terminar, bien o mal.
+//
+// Cómo llega `destination` según el motor:
+//   - Windows (WebView2): ICoreWebView2DownloadStartingEventArgs::ResultFilePath, que ya lleva el
+//     nombre del Content-Disposition (o del último segmento de la URL) y « (1)», « (2)»… si el
+//     archivo ya existe en Descargas. Si devolvemos true, wry hace SetResultFilePath(destination)
+//     + SetHandled(true) (wry-0.55.1/src/webview2/mod.rs:849-864); si false, SetCancel(true).
+//   - macOS (WKWebView): wry compone ~/Downloads/<suggestedFilename de WebKit> con el mismo
+//     esquema de « (n)» y, si devolvemos true, entrega esa ruta al completion handler de
+//     WKDownload como destino (wry-0.55.1/src/wkwebview/download.rs:49-91). El nombre viene
+//     siempre relleno. LÍMITE: WKWebView solo trata como descarga (a) los enlaces con atributo
+//     `download` (shouldPerformDownload) y (b) las respuestas cuyo MIME no sabe mostrar
+//     (canShowMIMEType == false; wkwebview/navigation.rs:59-73 y 93-100). WebKit NO mira
+//     Content-Disposition al decidir (WebPage::canShowResponse consulta solo el MIME), así que un
+//     PDF o una imagen servidos como attachment se MUESTRAN en la pestaña en vez de bajar; un
+//     .xlsx/.docx/.zip sí dispara la descarga porque WebKit no los renderiza.
+
+// Abre el «Guardar como» nativo y deja en `destination` la ruta elegida. Devuelve false (y wry
+// cancela la descarga) si el usuario cierra el diálogo; en ese caso no se avisa de nada.
+//
+// El diálogo es SÍNCRONO a propósito: el manejador de wry tiene que responder antes de volver y
+// en el mismo hilo (el principal, donde WebView2 y WKWebView despachan estos eventos; wry no
+// expone el deferral de WebView2). Por eso va rfd::FileDialog directo y no tauri-plugin-dialog:
+// su `blocking_save_file()` monta un rfd::AsyncFileDialog y espera en un canal (macro
+// blocking_fn en plugins/dialog/src/lib.rs); en macOS ese diálogo asíncrono se presenta como
+// hoja sobre la ventana principal (beginSheetModalForWindow) y solo se muestra y resuelve si el
+// run loop principal gira (rfd/src/backend/macos/modal_future.rs:79-102)… que es justo el hilo
+// que estaría parado en recv() → cuelgue. rfd::FileDialog::save_file corre un bucle modal
+// anidado en el propio hilo (NSSavePanel.runModal / IFileDialog::Show), que es lo que hace
+// falta aquí. La ventana va como padre para que en Windows el diálogo sea modal a la app y no
+// se quede detrás. No se fuerza carpeta inicial: el sistema recuerda la última usada.
+fn pedir_destino_descarga<R: Runtime>(webview: &Webview<R>, url: &Url, destination: &mut PathBuf) -> bool {
+    let ventana = webview.window();
+    let dialogo = rfd::FileDialog::new()
+        .set_title("Guardar como")
+        .set_file_name(nombre_sugerido(url, destination))
+        .set_parent(&ventana);
+    match dialogo.save_file() {
+        Some(ruta) => {
+            webview.state::<Descargas>().0.lock().unwrap().insert(url.to_string(), ruta.clone());
+            *destination = ruta;
+            true
+        }
+        None => false,
+    }
+}
+
+// Nombre que propone el diálogo: el que trae `destination` (WebView2 lo saca del
+// Content-Disposition que manda el servidor; en macOS wry lo toma del suggestedFilename de
+// WebKit) y, si viniera vacío, el último segmento de la URL decodificado. Nunca vacío.
+fn nombre_sugerido(url: &Url, destination: &Path) -> String {
+    let del_motor = destination
+        .file_name()
+        .map(|n| n.to_string_lossy().trim().to_string())
+        .filter(|n| !n.is_empty());
+    if let Some(n) = del_motor {
+        return n;
+    }
+    url.path_segments()
+        .and_then(|segs| segs.rev().find(|s| !s.is_empty()))
+        .map(|s| percent_encoding::percent_decode_str(s).decode_utf8_lossy().trim().to_string())
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| "descarga".to_string())
+}
+
+// Notificación nativa al terminar la descarga. En Windows `path` es la ruta final real (puede
+// diferir de la elegida si el motor tuvo que renombrar); en macOS llega None y se usa la ruta
+// que el usuario eligió en el diálogo (ver `Descargas`).
+fn avisar_descarga_terminada<R: Runtime>(webview: &Webview<R>, url: &Url, path: Option<PathBuf>, success: bool) {
+    let elegida = webview.state::<Descargas>().0.lock().unwrap().remove(url.as_str());
+    let cuerpo = if !success {
+        "No se pudo completar la descarga.".to_string()
+    } else {
+        match path.or(elegida).as_deref().and_then(Path::file_name) {
+            Some(n) => format!("Descargado: {}", n.to_string_lossy()),
+            None => "Descarga terminada.".to_string(),
+        }
+    };
+    let _ = webview
+        .app_handle()
+        .notification()
+        .builder()
+        .title("Labstream OS")
+        .body(cuerpo)
+        .show();
+}
+
 // Crea una pestaña nueva cargando `url` (o el servidor si viene vacío).
 fn create_tab<R: Runtime>(app: &AppHandle<R>, url: Option<String>, activate: bool) {
    let target = url.unwrap_or_else(|| SERVER_URL.to_string());
@@ -592,19 +827,51 @@ fn create_tab<R: Runtime>(app: &AppHandle<R>, url: Option<String>, activate: boo
        let mut s = shell.lock().unwrap();
        let label = format!("tab-{}", s.next_id);
        s.next_id += 1;
-        s.tabs.push(TabRec { label: label.clone(), title: "Labstream OS".into(), url: target.clone(), loading: true, color: None });
+        s.tabs.push(TabRec { label: label.clone(), title: "Labstream OS".into(), url: target.clone(), loading: true, color: None, oculta_desde: if activate { None } else { Some(Instant::now()) }, dormida: false, descartada: false });
        label
    };

-    let Some(win) = main_window(app) else { return };
+    match montar_webview(app, &label, parsed) {
+        Ok(_) => {
+            if activate {
+                activate_tab(app, &label);
+            } else {
+                broadcast(app);
+                save_persisted(app);
+            }
+        }
+        Err(e) => {
+            salud::anotar("ERROR", "pestaña", &format!("no se pudo crear el webview: {e}"));
+            // Revertir el registro si el webview no se pudo crear.
+            let shell = app.state::<ShellState>();
+            let mut s = shell.lock().unwrap();
+            s.tabs.retain(|t| t.label != label);
+        }
+    }
+}
+
+// Crea el webview de una pestaña: una nueva (create_tab) o una descartada que vuelve
+// (revivir_pestana, al activarla). Lo vigila salud.rs: si su proceso muere, se recarga sola.
+fn montar_webview<R: Runtime>(app: &AppHandle<R>, label: &str, parsed: Url) -> tauri::Result<Webview<R>> {
+    let win = main_window(app).ok_or(tauri::Error::WindowNotFound)?;
    let scale = win.scale_factor().unwrap_or(1.0);
    let size = win.inner_size().map(|s| s.to_logical::<f64>(scale)).unwrap_or(LogicalSize::new(1400.0, 900.0));

-    let init = INIT_JS_TPL.replace("__LABEL__", &label).replace("__ORIGIN__", SERVER_URL);
+    let init = INIT_JS_TPL.replace("__LABEL__", label).replace("__ORIGIN__", SERVER_URL);
    let app_zoom = app.clone();
-    let builder = WebviewBuilder::new(&label, WebviewUrl::External(parsed))
+    let app_navigation = app.clone();
+    let builder = WebviewBuilder::new(label, WebviewUrl::External(parsed))
        .initialization_script(&init)
-        // Deja pasar las descargas (entregables, exportaciones) Y avisa al terminar.
+        .on_navigation(move |url| {
+            if url.scheme() == "https" && url.host_str().map(is_google_host).unwrap_or(false) {
+                let _ = app_navigation.opener().open_url(url.as_str(), None::<&str>);
+                return false;
+            }
+            true
+        })
+        // Descargas (entregables, exportaciones, enlaces `?download=1`): antes de empezar se
+        // PREGUNTA dónde guardar con el «Guardar como» nativo (ver pedir_destino_descarga) y al
+        // terminar se avisa con una notificación (ver avisar_descarga_terminada).
        // El aviso no es un adorno: en WebView2 la interfaz de descargas queda SIEMPRE
        // apagada. wry trae un manejador de descargas por defecto (wry-0.55.1/src/lib.rs:830),
        // asi que DownloadStarting se registra siempre y siempre responde SetHandled(true)
@@ -612,30 +879,14 @@ fn create_tab<R: Runtime>(app: &AppHandle<R>, url: Option<String>, activate: boo
        // se encarga la app: ni barra de progreso, ni globo de «descarga terminada». El
        // archivo bajaba bien a la carpeta de Descargas, pero NADA lo decia y parecia roto.
        // Quitar este manejador NO devuelve la interfaz nativa: el de wry sigue puesto.
-        .on_download(|webview, event| {
-            if let DownloadEvent::Finished { path, success, .. } = &event {
-                let cuerpo = if !*success {
-                    "No se pudo completar la descarga.".to_string()
-                } else if let Some(p) = path {
-                    // En macOS `path` llega siempre vacio (limite de WKDownload:
-                    // wry-0.55.1/src/wkwebview/download.rs:98), asi que en la practica
-                    // este brazo con nombre de archivo es el de Windows.
-                    match p.file_name() {
-                        Some(n) => format!("Descargado: {}", n.to_string_lossy()),
-                        None => "Descarga terminada.".to_string(),
-                    }
-                } else {
-                    "Descarga terminada. Esta en tu carpeta de Descargas.".to_string()
-                };
-                let _ = webview
-                    .app_handle()
-                    .notification()
-                    .builder()
-                    .title("Labstream OS")
-                    .body(cuerpo)
-                    .show();
+        .on_download(|webview, event| match event {
+            DownloadEvent::Requested { url, destination } => pedir_destino_descarga(&webview, &url, destination),
+            DownloadEvent::Finished { url, path, success, .. } => {
+                avisar_descarga_terminada(&webview, &url, path, success);
+                true
            }
-            true
+            // El enum es #[non_exhaustive]: si wry añade eventos, dejarlos pasar.
+            _ => true,
        })
        // El zoom guardado se re-aplica en cada carga (el factor no siempre sobrevive a la navegación).
        .on_page_load(move |wv, payload| {
@@ -646,30 +897,111 @@ fn create_tab<R: Runtime>(app: &AppHandle<R>, url: Option<String>, activate: boo
            set_loading(&app_zoom, wv.label(), cargando);
        });

-    let created = win.add_child(
+    let wv = win.add_child(
        builder,
        LogicalPosition::new(0.0, TAB_BAR_H),
        LogicalSize::new(size.width, (size.height - TAB_BAR_H).max(0.0)),
-    );
+    )?;
+    // Si su proceso de WebView2 muere o se cuelga, se anota y la pestaña se recarga sola.
+    salud::vigilar_pestana(app, &wv);
+    Ok(wv)
+}

-    match created {
-        Ok(_) => {
-            if activate {
-                activate_tab(app, &label);
-            } else {
-                broadcast(app);
-                save_persisted(app);
-            }
+// Ahorro de memoria: una pestaña dormida desde hace DESCARTE_TRAS se cierra de verdad (su proceso
+// sale de la memoria) y queda en la barra con su título, URL y color. `activate_tab` la revive.
+fn descartar_pestana<R: Runtime>(app: &AppHandle<R>, label: &str) {
+    {
+        let shell = app.state::<ShellState>();
+        let mut s = shell.lock().unwrap();
+        let activa = s.active;
+        let Some((i, t)) = s.tabs.iter_mut().enumerate().find(|(_, t)| t.label == label) else { return };
+        if i == activa || !t.dormida || t.descartada {
+            return;
        }
-        Err(_) => {
-            // Revertir el registro si el webview no se pudo crear.
+        t.descartada = true;
+        t.dormida = false;
+    }
+    if let Some(wv) = get_webview(app, label) {
+        let _ = wv.close();
+    }
+    salud::anotar("INFO", "memoria", &format!("pestaña {label} descartada (lleva {} min dormida)", memoria::DESCARTE_TRAS.as_secs() / 60));
+}
+
+// Una pestaña de la sesión anterior que no es la activa: entra en la barra SIN webview (como si se
+// hubiera descartado) y se crea la primera vez que se activa.
+fn registrar_diferida<R: Runtime>(app: &AppHandle<R>, url: &str, title: &str) {
+    let shell = app.state::<ShellState>();
+    let mut s = shell.lock().unwrap();
+    let label = format!("tab-{}", s.next_id);
+    s.next_id += 1;
+    let title = if title.is_empty() { "Labstream OS".to_string() } else { title.to_string() };
+    s.tabs.push(TabRec { label, title, url: url.to_string(), loading: false, color: None, oculta_desde: Some(Instant::now()), dormida: false, descartada: true });
+}
+
+// Vuelve a crear el webview de una pestaña descartada, en su última URL. Devuelve false si no se
+// pudo (la pestaña se deja como estaba y se anota).
+fn revivir_pestana<R: Runtime>(app: &AppHandle<R>, label: &str) -> bool {
+    let url = {
+        let shell = app.state::<ShellState>();
+        let s = shell.lock().unwrap();
+        match s.tabs.iter().find(|t| t.label == label) {
+            Some(t) if t.descartada => t.url.clone(),
+            _ => return true, // no estaba descartada: nada que hacer
+        }
+    };
+    let Ok(parsed) = Url::parse(&url) else { return false };
+    match montar_webview(app, label, parsed) {
+        Ok(_) => {
            let shell = app.state::<ShellState>();
            let mut s = shell.lock().unwrap();
-            s.tabs.retain(|t| t.label != label);
+            if let Some(t) = s.tabs.iter_mut().find(|t| t.label == label) {
+                t.descartada = false;
+                t.loading = true;
+            }
+            true
+        }
+        Err(e) => {
+            salud::anotar("ERROR", "memoria", &format!("no se pudo revivir la pestaña {label}: {e}"));
+            false
        }
    }
 }

+#[cfg_attr(not(windows), allow(dead_code))]
+// Una pestaña que se cayó varias veces seguidas ya no se recarga sola (salud.rs): se avisa para
+// que la persona la recargue (F5) o la cierre, en vez de dejarla en blanco sin explicación.
+pub(crate) fn aviso_pestana_rota<R: Runtime>(app: &AppHandle<R>, label: &str) {
+    let titulo = {
+        let shell = app.state::<ShellState>();
+        let s = shell.lock().unwrap();
+        s.tabs.iter().find(|t| t.label == label).map(|t| t.title.clone()).unwrap_or_else(|| "Una pestaña".into())
+    };
+    let _ = app
+        .notification()
+        .builder()
+        .title("Labstream OS")
+        .body(format!("«{titulo}» falló varias veces seguidas. Recárgala con F5 o ciérrala."))
+        .show();
+}
+
+// Memoria alta (salud.rs): las pestañas ocultas se duermen YA, sin esperar sus 5 minutos. Se les
+// adelanta el reloj de «oculta desde» y se pasa la ronda normal, que sigue preguntando a cada una
+// si está libre (una subida, una descarga o algo sonando no se duermen nunca).
+fn dormir_ocultas_ya<R: Runtime>(app: &AppHandle<R>) {
+    {
+        let shell = app.state::<ShellState>();
+        let mut s = shell.lock().unwrap();
+        let activa = s.active;
+        let antes = Instant::now().checked_sub(REPOSO_TRAS).unwrap_or_else(Instant::now);
+        for (i, t) in s.tabs.iter_mut().enumerate() {
+            if i != activa && t.oculta_desde.is_some() {
+                t.oculta_desde = Some(antes);
+            }
+        }
+    }
+    ronda_de_reposo(app);
+}
+
 // Cierra una pestaña; si era la activa, activa la vecina. Nunca deja cero pestañas.
 fn close_tab<R: Runtime>(app: &AppHandle<R>, label: &str) {
    let next_active: Option<String> = {
@@ -883,6 +1215,9 @@ fn show_app_menu<R: Runtime>(app: &AppHandle<R>) {
                &CheckMenuItem::with_id(app, "autostart-toggle", "Iniciar con el sistema", true, autostart_on, None::<&str>)?,
                &MenuItem::with_id(app, "check-update", "Buscar actualización…", true, None::<&str>)?,
                &PredefinedMenuItem::separator(app)?,
+                &MenuItem::with_id(app, "salud-resumen", salud::resumen(), false, None::<&str>)?,
+                &MenuItem::with_id(app, "diagnostico", "Abrir diagnóstico", true, None::<&str>)?,
+                &PredefinedMenuItem::separator(app)?,
                &MenuItem::with_id(app, "version", &version, false, None::<&str>)?,
                &MenuItem::with_id(app, "quit-app", "Salir de Labstream OS", true, None::<&str>)?,
            ],
@@ -1077,21 +1412,47 @@ async fn check_update_manual(handle: tauri::AppHandle) {
    match updater.check().await {
        Ok(Some(update)) => {
            notify(format!("Instalando la versión {}…", update.version));
-            if update.download_and_install(|_, _| {}, || {}).await.is_ok() {
-                handle.restart();
-            } else {
-                notify("No se pudo instalar la actualización. Intenta de nuevo más tarde.".into());
+            let version = update.version.clone();
+            match update.download_and_install(|_, _| {}, move || salud::antes_de_actualizar(&version)).await {
+                Ok(()) => handle.restart(),
+                Err(e) => {
+                    salud::anotar("ERROR", "actualizacion", &format!("no se pudo instalar: {e}"));
+                    notify("No se pudo instalar la actualización. Intenta de nuevo más tarde.".into());
+                }
            }
        }
        Ok(None) => notify(format!("Estás en la última versión ({}).", handle.package_info().version)),
-        Err(_) => notify("No se pudo comprobar la actualización (revisa la red).".into()),
+        Err(e) => {
+            salud::anotar("AVISO", "actualizacion", &format!("no se pudo comprobar: {e}"));
+            notify("No se pudo comprobar la actualización (revisa la red).".into());
+        }
+    }
+}
+
+// ⋮ ▸ Abrir diagnóstico (y la bandeja): la carpeta con salud.log y recursos.csv, para mirarla o
+// mandarla cuando algo falle.
+fn abrir_diagnostico<R: Runtime>(app: &AppHandle<R>) {
+    if let Some(dir) = salud::carpeta() {
+        let _ = app.opener().open_path(dir.to_string_lossy().to_string(), None::<&str>);
    }
 }

 // Muestra y enfoca la ventana principal (tray, dock, segunda instancia).
 fn show_main<R: Runtime>(app: &AppHandle<R>) {
+    memoria::a_la_vista(app);
    if let Some(w) = main_window(app) {
        let _ = w.show();
+        // tao guarda su propia nota de «visible» y `show()` solo llama a ShowWindow si esa nota
+        // cambia (WindowFlags::apply_diff). Visto en el equipo de edición (2026-10-14, 1.19.0): la
+        // ventana estaba OCULTA en Windows con la nota en «visible», así que ni la bandeja, ni el
+        // icono, ni la tecla del MasterHUB la sacaban (set_focus sí corría: tomaba el foco sin
+        // verse). `is_visible()` lee el estado REAL (IsWindowVisible); si no cuadra, se baja y
+        // se sube la nota para que ShowWindow corra de verdad, y se anota para medir cada cuánto pasa.
+        if !w.is_visible().unwrap_or(true) {
+            salud::anotar("AVISO", "ventana", "show() no la mostró (estado de tao desincronizado): se rehace ocultar + mostrar");
+            let _ = w.hide();
+            let _ = w.show();
+        }
        let _ = w.unminimize();
        let _ = w.set_focus();
    }
@@ -1105,8 +1466,21 @@ async fn check_update(handle: tauri::AppHandle) {
        Ok(u) => u,
        Err(_) => return,
    };
-    if let Ok(Some(update)) = updater.check().await {
-        if update.download_and_install(|_, _| {}, || {}).await.is_ok() {
+    let update = match updater.check().await {
+        Ok(Some(u)) => u,
+        Ok(None) => return,
+        Err(e) => {
+            salud::anotar("AVISO", "actualizacion", &format!("no se pudo comprobar: {e}"));
+            return;
+        }
+    };
+    {
+        let version = update.version.clone();
+        let r = update.download_and_install(|_, _| {}, move || salud::antes_de_actualizar(&version)).await;
+        if let Err(e) = &r {
+            salud::anotar("ERROR", "actualizacion", &format!("no se pudo instalar: {e}"));
+        }
+        if r.is_ok() {
            let _ = handle
                .notification()
                .builder()
@@ -1226,8 +1600,11 @@ pub fn run() {

    let app = builder
        .manage(ShellState::default())
+        .manage(Descargas::default())
        .setup(|app| {
            let handle = app.handle().clone();
+            // Lo primero: el diario de salud (pánicos, cierres de golpe, reinicio automático).
+            salud::preparar(&handle);
            let saved = load_persisted(&handle);

            // Arranque automático al iniciar sesión: por defecto activado, pero se respeta
@@ -1394,6 +1771,7 @@ pub fn run() {
                }
                id if id.starts_with("tab-color-") => tab_menu_action(app, id),
                "autostart-toggle" => toggle_autostart(app),
+                "diagnostico" => abrir_diagnostico(app),
                "clear-cache" => {
                    let antes = cache::tamano(app);
                    cache::vaciar(app);
@@ -1433,7 +1811,11 @@ pub fn run() {
            // Pestañas de la sesión anterior (o una nueva si no hay), cada una con su color.
            // El color se empareja con su URL ANTES de filtrar: el filtro por origen puede
            // descartar entradas y entonces los índices de las dos listas dejarían de casar.
-            let restore: Vec<(String, String)> = {
+            // Ahorro de memoria al abrir: solo se CARGA la pestaña que estaba activa; las demás se
+            // registran descartadas (título, URL y color en la barra) y se crean al hacer clic en
+            // ellas, como hacen Chrome y Edge. Antes se cargaban todas a la vez: con 5 pestañas, 5
+            // copias enteras de la web app arrancando juntas.
+            let restore: Vec<(String, String, String)> = {
                let server = Url::parse(SERVER_URL).expect("URL del servidor válida");
                saved
                    .tabs
@@ -1441,16 +1823,23 @@ pub fn run() {
                    .enumerate()
                    .filter(|(_, u)| Url::parse(u).map(|p| es_pestana_interna(&p, &server)).unwrap_or(false))
                    .take(12)
-                    .map(|(i, u)| (u.clone(), saved.colors.get(i).cloned().unwrap_or_default()))
+                    .map(|(i, u)| {
+                        (u.clone(), saved.colors.get(i).cloned().unwrap_or_default(), saved.titles.get(i).cloned().unwrap_or_default())
+                    })
                    .collect()
            };
            if restore.is_empty() {
                create_tab(&handle, None, true);
            } else {
-                for (url, color) in &restore {
-                    create_tab(&handle, Some(url.clone()), false);
+                let idx = saved.active.min(restore.len() - 1);
+                for (i, (url, color, title)) in restore.iter().enumerate() {
+                    if i == idx {
+                        create_tab(&handle, Some(url.clone()), false);
+                    } else {
+                        registrar_diferida(&handle, url, title);
+                    }
                    if !color.is_empty() {
-                        // create_tab acaba de empujar su pestaña al final de la lista.
+                        // La pestaña se acaba de empujar al final de la lista.
                        let shell = handle.state::<ShellState>();
                        let mut s = shell.lock().unwrap();
                        if let Some(t) = s.tabs.last_mut() {
@@ -1460,7 +1849,6 @@ pub fn run() {
                        }
                    }
                }
-                let idx = saved.active.min(restore.len() - 1);
                let label = {
                    let shell = handle.state::<ShellState>();
                    let s = shell.lock().unwrap();
@@ -1478,6 +1866,19 @@ pub fn run() {
                broadcast(&h);
            });
            let h = handle.clone();
+            handle.listen_any("ls-reposo", move |e| {
+                if field_bool(e.payload(), "libre") == Some(true) {
+                    if let Some(l) = field(e.payload(), "label") {
+                        dormir_pestana(&h, &l);
+                    }
+                }
+            });
+            let h = handle.clone();
+            std::thread::spawn(move || loop {
+                std::thread::sleep(REPOSO_RONDA);
+                ronda_de_reposo(&h);
+            });
+            let h = handle.clone();
            handle.listen_any("ls-new-tab", move |e| {
                let url = field(e.payload(), "url");
                create_tab(&h, url, true);
@@ -1613,9 +2014,16 @@ pub fn run() {
            let abrir = MenuItem::with_id(app, "abrir", "Abrir Labstream", true, None::<&str>)?;
            let salir = MenuItem::with_id(app, "salir", "Salir", true, None::<&str>)?;
            let (trk_estado, trk_toggle) = tracker::armar_menu(app.handle())?;
+            // Lo que gasta la app entera (exe + todos sus procesos de WebView2), cada minuto.
+            let recursos = MenuItem::with_id(app, "salud-recursos", salud::resumen(), false, None::<&str>)?;
+            let diagnostico = MenuItem::with_id(app, "diagnostico", "Abrir diagnóstico", true, None::<&str>)?;
            let sep1 = PredefinedMenuItem::separator(app)?;
            let sep2 = PredefinedMenuItem::separator(app)?;
-            let menu = Menu::with_items(app, &[&abrir, &sep1, &trk_estado, &trk_toggle, &sep2, &salir])?;
+            let sep3 = PredefinedMenuItem::separator(app)?;
+            let menu = Menu::with_items(
+                app,
+                &[&abrir, &sep1, &trk_estado, &trk_toggle, &sep2, &recursos, &diagnostico, &sep3, &salir],
+            )?;

            TrayIconBuilder::with_id("main-tray")
                .icon(app.default_window_icon().unwrap().clone())
@@ -1624,6 +2032,7 @@ pub fn run() {
                .show_menu_on_left_click(false)
                .on_menu_event(|app, event| match event.id.as_ref() {
                    "abrir" => show_main(app),
+                    "diagnostico" => abrir_diagnostico(app),
                    "salir" => {
                        save_persisted(app);
                        app.exit(0);
@@ -1647,6 +2056,20 @@ pub fn run() {
            // El sensor del rastreador: listener de vinculación + hilo de medición.
            tracker::iniciar(app.handle());

+            // Salud: medición de recursos cada minuto y vigilante del hilo principal.
+            salud::iniciar(app.handle(), recursos, dormir_ocultas_ya);
+            // Errores de JavaScript de las pestañas (los manda el script de cada página).
+            handle.listen_any("ls-error", |e| {
+                let p = e.payload();
+                salud::error_js(
+                    &field(p, "label").unwrap_or_default(),
+                    &field(p, "tipo").unwrap_or_default(),
+                    &field(p, "msg").unwrap_or_default(),
+                    &field(p, "src").unwrap_or_default(),
+                    &field(p, "url").unwrap_or_default(),
+                );
+            });
+
            Ok(())
        })
        .on_window_event(|window, event| {
@@ -1657,6 +2080,8 @@ pub fn run() {
                    let _ = window.hide();
                    api.prevent_close();
                }
+                // Vuelve a primer plano (p. ej. tras minimizar): memoria normal para lo que se ve.
+                WindowEvent::Focused(true) => memoria::a_la_vista(window.app_handle()),
                // La barra y las pestañas siguen el tamaño de la ventana.
                WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
                    let app = window.app_handle();
@@ -1719,6 +2144,10 @@ pub fn run() {
        if let tauri::RunEvent::ExitRequested { .. } = event {
            save_persisted(app);
        }
+        // Salida limpia: sin esto, el próximo arranque anotaría un «cierre de golpe».
+        if let tauri::RunEvent::Exit = event {
+            salud::salida_limpia();
+        }
        let _ = app;
    });
 }
--- a/src-tauri/src/memoria.rs
+++ b/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
+    }
+}
--- a/src-tauri/src/salud.rs
+++ b/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));
+    }
+}
--- a/src-tauri/src/tracker.rs
+++ b/src-tauri/src/tracker.rs
@@ -279,7 +279,7 @@ fn es_navegador(app: &str) -> bool {
 // si hay sonido saliendo AHORA. Un video mudo no se detecta (no suena); es el límite honesto de
 // medirlo desde fuera del navegador.
 #[cfg(windows)]
-fn hay_audio_sonando() -> bool {
+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};
@@ -300,7 +300,7 @@ fn hay_audio_sonando() -> bool {
 }

 #[cfg(not(windows))]
-fn hay_audio_sonando() -> bool {
+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
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "Labstream OS",
-  "version": "1.13.0",
+  "version": "1.20.0",
  "identifier": "co.labstream.os",
  "build": {
    "frontendDist": "../dist"
--- a/tests/images.browser.cjs
+++ b/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; });
--- a/tests/images.test.cjs
+++ b/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);
+  }
+});
Autor	SHA1	Mensaje	Fecha
Munka	d3216c10ef	Salud: el reinicio no se anota dos veces; en macOS la bandeja no se queda en «midiendo» Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 08:33:16 -05:00
Munka	d7bf8c6740	La ventana se muestra aunque tao crea que ya está visible Visto en el equipo de edición con la 1.19.0: la ventana estaba oculta en Windows pero tao la tenía anotada como visible, así que show() no llamaba a ShowWindow (apply_diff sin cambios) y ni la bandeja, ni el icono, ni la tecla del MasterHUB la sacaban; set_focus sí corría y tomaba el foco sin verse. show_main compara con el estado real (is_visible) y, si no cuadra, rehace ocultar + mostrar y lo anota en salud.log. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 08:28:30 -05:00
Munka	9c7bdf552c	v1.20.0: salud de la app y ahorro de memoria Salud (src-tauri/src/salud.rs): - Mide cada minuto el árbol de procesos de la app (exe + WebView2): memoria privada, CPU y procesos. Se ve en la bandeja y en ⋮; va a recursos.csv. - Diario de errores (salud.log): pánicos, procesos de WebView2 caídos o colgados, errores de JavaScript, hilo principal sin responder, fallos del actualizador y cierres de golpe (testigo en-marcha). - Se repone sola: recarga la pestaña cuyo proceso muere o se cuelga (freno de 3 en 10 min), reinicia la app si cae el proceso principal de WebView2 y registra el reinicio automático de Windows (RegisterApplicationRestart). - ⋮ y bandeja: «Abrir diagnóstico» abre la carpeta de logs. Memoria (src-tauri/src/memoria.rs), medido: 2,2 GB con 5 pestañas, 1,3 GB en el proceso gráfico; reiniciarlo bajó la app a 1,1 GB sin perder nada. - Recicla el proceso gráfico al pasar de 600 MB si nadie mira (ventana oculta o minimizada, o 10 min sin entrada y sin sonido), como mucho cada 30 min. - Al abrir solo carga la pestaña activa; las demás se crean al activarlas. - Descarta las pestañas que llevan 30 min dormidas (vuelven a su URL). - Nivel de memoria bajo de WebView2 para lo que no se ve. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 08:16:27 -05:00
Munka	5797c478bc	Reposo: el índice activo se lee antes de recorrer las pestañas	2026-10-03 11:53:53 -05:00
Munka	4d066157cf	v1.19.0: pestañas en reposo (Windows) Cada pestaña es la web app entera, con su conexión del chat y sus sondeos; con seis abiertas corrían seis. Una pestaña que lleva 5 minutos oculta se suspende con WebView2 TrySuspend y despierta sola al volver a ella. No se duerme la activa, ni una con subidas, descargas o audio en curso, ni un editor de documentos. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 11:46:29 -05:00
Munka	5a6f6c918f	v1.18.0: F5 recarga, como en cualquier navegador WebView2 tiene apagados sus propios atajos de navegador, así que F5 no hacía nada dentro de la app: el único que recargaba era Ctrl+R. Ahora F5 (y Ctrl+F5, Shift+F5) recarga la pestaña. Va antes del filtro de modificadores de los atajos, porque F5 no lleva ninguno y ese filtro lo descartaba. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-09-22 17:54:57 -05:00
Jonathan David Florez Salomón	7b0c031a41	v1.17.0: la esquina rota, la profundidad de las pestañas y la activa en negrilla Tres cambios en la barra, todos de la misma idea: que se vea de un vistazo cuál manda. · LA ESQUINA. Se retiran los dos pseudo-elementos de 8px que imitaban la curva cóncava de Chrome. El truco funciona allí porque NO hay línea bajo la barra; aquí sí la hay, y esas piezas blancas la partían en dos a los costados de la pestaña activa. La activa ya se funde con el contenido por su propio fondo. · LA PROFUNDIDAD. Las inactivas se hunden con un velo tenue y sombra interior, y al pasar el ratón el gesto se invierte: la sombra sale y el fondo tira hacia el blanco de la activa. Sombra y no relleno sólido — un bloque gris pesa tanto como la activa y compite con ella. La activa gana sombra HACIA ARRIBA: abajo está fundida con el contenido. · LA NEGRILLA. El título de la activa a 600. Va en el título y no en la pestaña entera para que el aspa de cerrar no engorde con él. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-20 15:37:36 -05:00
Jonathan David Florez Salomón	641c9660cc	La pestaña activa, en negrilla El relieve dice dónde está el plano de delante; 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, y a 600 y no a 700: a 12,5 px el bold entero emborrona, y lo que hace falta es que destaque, no que grite. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-20 15:22:28 -05:00
Jonathan David Florez Salomón	73486aa3fe	La esquina de la pestaña activa deja de romperse, y las que esperan se hunden DOS COSAS EN LA BARRA DE PESTAÑAS. 1) LA ESQUINA. La activa llevaba dos pseudo-elementos de 8px a los lados con un degradado radial: la curva cóncava de Chrome. El truco funciona en Chrome porque allí NO hay línea bajo la barra; aquí sí la hay, y esas dos piezas blancas la partían en dos justo a los costados de la pestaña — la fluctuación que se veía en la esquina. Se retiran: la activa ya se funde con el contenido por su propio fondo, que tapa la línea exactamente por su ancho, y sin las piezas no asoma nada. 2) LA PROFUNDIDAD. La inactiva no era nada: texto suelto sobre la franja, al mismo plano que la activa, separado por un filete de 1px. Ahora se HUNDE —velo muy tenue y sombra interior— y al pasar el ratón el gesto se invierte: la sombra sale hacia fuera y el fondo tira hacia el blanco de la activa, así que la pestaña sube hacia ti. Es sombra y no relleno sólido a propósito: un bloque gris pesa tanto como la activa y acaba compitiendo con ella. La activa gana su propia sombra, HACIA ARRIBA: abajo está fundida con el contenido y una sombra ahí dibujaría una línea donde no debe haberla. Con fondo propio el separador vertical sobra y se retira. `--sep` se queda: lo sigue usando el aro del favicon mientras carga. Sin cambio de versión: queda listo para la próxima que se saque. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-20 15:20:30 -05:00
Jonathan David Florez Salomón	a37a0bcc0b	v1.16.0: la app de macOS por fin se firma de verdad El build NUNCA firmó la app de macOS. Al no pasarle ninguna identidad, el bundler de Tauri se saltaba `codesign` entero y el .dmg salía con la firma ad hoc que deja el enlazador: Identifier=labstream_desktop-0a5819ba37119701 flags=0x20002(adhoc,linker-signed) Info.plist=not bound Sealed Resources=none Tres cosas mal, y ninguna avisaba en ningún log: · El Entitlements.plist del repo era DECORACIÓN. Los entitlements se escriben al firmar; sin firma, el micrófono, la cámara y el JIT nunca pidieron nada porque nunca estuvieron pedidos. · Ni el Info.plist ni los recursos iban dentro de la firma: se podían cambiar sin romperla. · El identificador era el del enlazador y no `co.labstream.os`, que es por el que macOS recuerda los permisos que le concedes a una app. AHORA. `APPLE_SIGNING_IDENTITY` se calcula en un paso propio y no en el `env:` del build, porque un secret que no existe llega como cadena VACÍA y Tauri lee `APPLE_CERTIFICATE=""` como «hay certificado» y revienta al importarlo. Solo se exporta lo que tiene valor: · con Developer ID → firma real, y notarizado si están las tres claves; · sin él → identidad "-", firma AD HOC. No engaña a Gatekeeper, pero sella los recursos, ata el Info.plist y APLICA LOS ENTITLEMENTS. En cuanto Jonathan añada los secrets, la siguiente etiqueta sale firmada de verdad sin tocar un solo archivo. ENSAYADO sobre una copia de la app instalada, con el mismo comando que va a correr el CI. Antes y después: flags=0x20002(adhoc,linker-signed) → flags=0x10002(adhoc,runtime) Identifier=labstream_desktop-0a58… → Identifier=co.labstream.os Info.plist=not bound → Info.plist entries=17 Sealed Resources=none → Sealed Resources version=2 rules=13 (sin entitlements) → allow-jit, audio-input, camera Y EL ENSAYO ENCONTRÓ UNA TRAMPA que `plutil -lint` no ve: el Entitlements.plist llevaba `--entitlements` dentro de un comentario XML, y dos guiones seguidos ahí son XML inválido. plutil lo aceptaba; AMFI, que es quien lo lee de verdad dentro de codesign, contestaba «Failed to parse entitlements» y la firma fallaba. Queda avisado en el propio archivo. De paso se cae `com.apple.security.network.client`: es exclusiva del App Sandbox y esta app no lo usa, así que no hacía nada. LA RED QUE FALTABA: un paso nuevo comprueba la firma del .app y TUMBA la publicación si los entitlements no llegaron. Que esto estuviera roto no lo dijo nada durante meses; se descubrió a mano persiguiendo otra cosa. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-19 11:41:13 -05:00
Munka	b4c4875cf6	v1.15.0: las descargas preguntan dónde guardar Al bajar un archivo desde una pestaña, la app abre el «Guardar como» nativo (rfd directo, modal en el hilo del webview) con el nombre sugerido; cancelar cancela la descarga. Antes caía en silencio en Descargas. El aviso al terminar usa la ruta elegida (en macOS WKDownload no la devuelve). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-15 17:46:21 -05:00
Labstream2026	261acc0201	Merge pull request #1 from Labstream2026/codex/portadas-mac-autenticadas Desktop 1.14.1: portadas autenticadas y apertura fiable de Google	2026-09-15 07:39:54 -05:00
Jonathan David Florez Salomón	1bdc7d0bba	fix(ci): use a portable Node test path on Windows	2026-09-15 07:27:39 -05:00
Jonathan David Florez Salomón	013d1e7759	fix(desktop): authenticated previews and reliable Google document opening	2026-09-15 07:25:34 -05:00
Munka	a10805c51b	v1.14.0: las pestanas se presentan como navegador de escritorio Google degrada sus apps cuando detecta un WebView embebido: Sheets abria en blanco y la sesion no terminaba de asentarse aunque la cuenta ya estuviera iniciada. Ahora cada pestana declara un User-Agent de Chrome de escritorio (por plataforma), que es lo que hacen los clientes de escritorio que embeben Google. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-14 12:12:37 -05:00