diff --git a/background.js b/background.js
index 86e6345..1fa9aa3 100644
--- a/background.js
+++ b/background.js
@@ -85,7 +85,7 @@ async function fetchPlanningXml(origin, phpsessid, unixDate) {
     `&day_start_hour=8` +
     `&day_end_hour=19`;
   console.log("[bg] fetchPlanningXml →", url.substring(0, 140));
-  const r = await fetch(url, { credentials: "include" });
+  const r = await evFetch(url, origin);
   console.log("[bg]   status =", r.status);
   if (!r.ok) {
     // v4.2 : classifier l'erreur HTTP pour que le viewer affiche le bon
@@ -100,6 +100,32 @@ async function fetchPlanningXml(origin, phpsessid, unixDate) {
   return xml;
 }
 
+/**
+ * v5.0.9 : wrapper autour de fetch() qui ajoute systématiquement les
+ * headers de sécurité attendus par EasyVista (Referer, Sec-Fetch-Site,
+ * X-Requested-With). Sans ces headers, EV renvoie soit un <script> de
+ * redirection (CSRF check), soit une page de login, même avec une session
+ * valide.
+ *
+ * Observé dans les captures réseau du navigateur :
+ *   Referer: https://itsma.etat-de-vaud.ch/index.php?eventName=HelpDesk_PlanningItem
+ *   Sec-Fetch-Site: same-origin
+ *   X-Requested-With: XMLHttpRequest (parfois)
+ *
+ * @param {string} url - URL complète à fetcher
+ * @param {string} origin - origine EasyVista (pour construire le Referer)
+ * @param {object} [opts] - options fetch (method, body, headers supplémentaires)
+ */
+async function evFetch(url, origin, opts = {}) {
+  const defaultHeaders = {
+    "Referer": `${origin}/index.php?eventName=HelpDesk_PlanningItem`,
+    "X-Requested-With": "XMLHttpRequest"
+  };
+  const headers = Object.assign({}, defaultHeaders, opts.headers || {});
+  const fetchOpts = Object.assign({ credentials: "include" }, opts, { headers });
+  return await fetch(url, fetchOpts);
+}
+
 /**
  * v4.2 : classifie un statut HTTP comme "session_expired" ou "ev_unreachable".
  * - 401, 403, 404 → session_expired (EV renvoie souvent 404 au lieu de rediriger
@@ -118,7 +144,7 @@ function classifyHttpStatus(status) {
  */
 async function fetchXhr2(origin, phpsessid, actionId) {
   const url = `${origin}/planning_xhr_2.php?PHPSESSID=${encodeURIComponent(phpsessid)}&id=${encodeURIComponent(actionId)}`;
-  const r = await fetch(url, { credentials: "include" });
+  const r = await evFetch(url, origin);
   if (!r.ok) {
     const err = new Error("HTTP " + r.status);
     err.kind = classifyHttpStatus(r.status);
@@ -131,7 +157,7 @@ async function fetchXhr2(origin, phpsessid, actionId) {
 async function fetchFicheHtml(origin, phpsessid, formLink) {
   const url = `${origin}/index.php?${formLink}&PHPSESSID=${encodeURIComponent(phpsessid)}`;
   console.log("[bg] fetchFicheHtml →", url.substring(0, 120));
-  const r = await fetch(url, { credentials: "include" });
+  const r = await evFetch(url, origin);
   if (!r.ok) {
     const err = new Error("HTTP " + r.status);
     err.kind = classifyHttpStatus(r.status);
@@ -140,6 +166,9 @@ async function fetchFicheHtml(origin, phpsessid, formLink) {
   }
   const html = await r.text();
   console.log("[bg]   fiche status =", r.status, "| taille =", html.length);
+  if (html.length < 500) {
+    console.warn("[bg]   ⚠ fiche très courte, contenu =", JSON.stringify(html));
+  }
   return html;
 }
 
diff --git a/manifest.json b/manifest.json
index bf08ca5..a3269e8 100644
--- a/manifest.json
+++ b/manifest.json
@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Planification",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "description": "Vue claire du planning EasyVista (itsma.etat-de-vaud.ch et itsma.vd.ch). v4.3.0 : (1) conflits horaires entre interventions d'un même tech affichés en rouge + ⚠. (2) Réservations disparues retirées directement (pas de re-fetch inutile). (3) Popups épinglés détachés : plusieurs peuvent coexister, ancrés au contenu (scrollent avec la page), auto-positionnés sans se marcher dessus (toast si pas de place), Échap pour tout fermer, Ctrl×2 pour fermer si un seul épinglé. Inclut v4.2.9.",
   "permissions": [
     "activeTab",
diff --git a/viewer.css b/viewer.css
index a253443..4330a6e 100644
--- a/viewer.css
+++ b/viewer.css
@@ -262,7 +262,7 @@ html, body {
   background: rgba(255,255,255,0.15);
 }
 
-/* Barre de progression pendant le rafraîchissement — v4.1.12 : texte
+/* Barre de progression pendant le rafraichissement — v4.1.12 : texte
    toujours lisible, que la zone verte l'ait atteint ou non (utilise
    mix-blend-mode:difference pour inverser la couleur du texte là où la
    barre verte est dessous). */
@@ -438,7 +438,7 @@ html, body {
   opacity: 0.9;
 }
 
-/* Bouton "Arrêter" (apparaît pendant un refresh manuel) */
+/* Bouton "Arrêter" (apparaît pdt un refresh manuel) */
 .btn-abort {
   background: var(--danger-soft);
   color: var(--danger);
@@ -909,10 +909,9 @@ html, body {
   to { transform: rotate(360deg); }
 }
 
-.intervention-v2.is-ghost {
-  opacity: 0.5;
-  text-decoration: line-through;
-}
+/* .intervention-v2.is-ghost : retirée en v4.3.3 — on ne barre plus les
+   cartes. La gestion des tickets disparus se fait via _disappearStatus
+   (vert ✓/✓✓) ou _disappearRemove (retrait total). */
 
 /* Ligne 1 : REF en titre centré gros gras */
 .iv-ref-header {
@@ -1806,7 +1805,10 @@ body.modal-open {
    ───────────────────────────────────────────────────────────────────────── */
 .tooltip.pinned-popup {
   position: absolute !important;     /* override le fixed du .tooltip */
-  z-index: 500;                      /* au-dessus du contenu, sous les modals (10000) */
+  /* v4.3.3 corr : les popups épinglées doivent passer DERRIÈRE la topbar
+     quand on scrolle (topbar sticky z-index 10). Donc on met 5 : au-dessus
+     du contenu normal, mais sous la topbar / bannières / modals. */
+  z-index: 5 !important;
   opacity: 1 !important;
   pointer-events: auto !important;
   /* Bordure plus visible pour distinguer du tooltip live */
diff --git a/viewer.html b/viewer.html
index bb01067..77691dc 100644
--- a/viewer.html
+++ b/viewer.html
@@ -13,7 +13,7 @@
       <button id="user-badge" class="user-badge hidden"
               type="button" aria-label="Utilisateur connecté"
               title="Utilisateur connecté"></button>
-      <h1>Planification</h1>
+      <h1 id="app-title">Planification</h1>
       <div class="date-nav">
         <button id="nav-prev" class="btn btn-nav" title="Jour précédent" aria-label="Jour précédent">◀</button>
         <input type="date" id="date-picker" class="date-input">
diff --git a/viewer.js b/viewer.js
index c16032b..6655c60 100644
--- a/viewer.js
+++ b/viewer.js
@@ -1,24 +1,19 @@
 // ============================================================================
-// viewer.js v4.1 — vue claire du planning techniciens
+// viewer.js — vue claire du planning techniciens
 // ============================================================================
-// Différences clés avec v3 :
-//   1. Une SEULE requête initiale (calendar_block) pour TOUT récupérer :
-//      ref, contact, lieu, catégorie, formLink, deadline — tout est déjà dans
-//      les attributs attr1/attr2/attr3/textContent du XML EasyVista.
-//   2. Suppression du fetch xhr2 en masse au chargement (74 requêtes éliminées)
-//   3. Suppression du fetch timeline (plus nécessaire)
-//   4. Lazy-load du texte d'action détaillé : on fetch xhr2 UNIQUEMENT sur hover,
-//      et seulement pour l'intervention survolée (pour enrichir le tooltip avec
-//      Problème/À faire/Matériel/etc.)
-//   5. Rendu utilisateur IDENTIQUE à v3 (même UI, mêmes infos au tooltip).
+// Idée de base : on récupère tout depuis le XML EasyVista (calendar_block) en
+// 1 seule requête. attr1/attr2/attr3 + textContent contiennent déjà ref,
+// contact, lieu, catégorie, formLink, deadline. Plus besoin de faire 74
+// requêtes xhr2 au chargement comme la v3. Le texte complet de l'action
+// (Problème / À faire / Matériel) est lazy-load au hover, seulement si
+// l'user survole la ligne.
 //
-// Différences v4 → v4.1 :
-//   - Fetch des fiches SÉQUENTIEL (1 par 1) au lieu de 5 workers en parallèle.
-//     Raison : le serveur EasyVista sérialise de toute façon, et le séquentiel
-//     rend l'abort instantané quand l'user change de date.
-//   - Cache INCRÉMENTAL : écrit toutes les 5 fiches pendant le fetch, pas juste
-//     à la fin. Si l'user change de date en cours, les statuts déjà récupérés
-//     ne sont pas perdus.
+// Fetch des fiches : séquentiel (1 par 1) au lieu d'en paralléliser. Le
+// serveur EasyVista sérialise de toute façon, et ça rend l'abort instantané
+// si l'user change de date en cours.
+// Le cache est écrit toutes les 5 fiches (incrémental), pas juste à la fin.
+// Comme ça si l'user change de date au milieu, ce qu'on a déjà fetché est
+// pas perdu.
 // ============================================================================
 
 // ============================================================================
@@ -155,9 +150,25 @@ let state = {
   session: null,           // { phpsessid, origin, tabId }
   currentDate: null,       // "YYYY-MM-DD" affiché
   currentData: null,       // résultat parsé (techs, stats, ...)
-  loading: false
+  loading: false,
+  // v5.0.9 : timestamp (ms) auquel la session EV va expirer.
+  // On suppose une durée de 30 min à chaque requête EV réussie.
+  // null = inconnu (pas encore récupéré).
+  sessionExpireAt: null,
+  // v5.0.9 : true pendant une reconnexion en cours (après clic sur "Me
+  // reconnecter" tant que la nouvelle session n'est pas détectée)
+  reconnecting: false,
+  // v5.0.9 : true si la session est expirée (bannière rouge affichée)
+  sessionExpired: false,
+  // v5.0.9 : true si on a déjà fait le ping de confirmation < 5 min
+  sessionPingDone: false
 };
 
+// v5.0.9 : constantes session
+const SESSION_DURATION_MS = 30 * 60 * 1000;  // 30 min
+const SESSION_WARN_THRESHOLD_MS = 5 * 60 * 1000;  // 5 min → affichage compteur
+const SESSION_CRITICAL_THRESHOLD_MS = 2 * 60 * 1000;  // 2 min → rouge + modal
+
 // ─── Annulation coopérative d'un refresh manuel (v3.1) ──────────────────────
 // Chaque refresh reçoit un "jeton" (entier incrémenté). Les workers lisent
 // isRefreshAborted() avant chaque fetch : si le jeton a changé ou si
@@ -216,6 +227,9 @@ async function init() {
   bindTooltipInteractions();
   initModalScrollLock();  // v4.2.9 : bloquer le scroll arrière quand modal
   initAppFooter();        // v4.2.9 : pied de page discret bas-droite
+  initAppClock();         // v5.0.0 : horloge HH:MM au milieu topbar
+  initAdminMenu();        // v5.0.0 : menu admin caché (5 clics sur titre)
+  initSessionTimer();     // v5.0.9 : compteur de session EV (tick 1s)
 
   // Initialiser la date = aujourd'hui
   state.currentDate = todayISO();
@@ -225,7 +239,7 @@ async function init() {
   // désormais soit manuels (boutons Actualiser / Tout recharger), soit au
   // premier chargement si aucun cache n'existe pour la date.
 
-  // Charger la session puis le planning
+  // Charger la sesson puis le planning
   await refreshSessionAndLoad();
 }
 
@@ -253,10 +267,25 @@ async function refreshSessionAndLoad() {
   hideEvUnreachable();
   hideSessionExpiredBanner();
   hideEvUnreachableBanner();
+  state.sessionExpired = false;
+  state.reconnecting = false;
   fetchAndShowCurrentUser();
+  // v5.0.9 : à chaque démarrage/reconnexion, on suppose que la session vient
+  // d'être rafraîchie à 30 min. updateSessionIndicator va masquer le compteur.
+  markSessionActivity();
   await loadForDate(state.currentDate);
 }
 
+/**
+ * v5.0.9 : doit être appelée à chaque requête EasyVista réussie. Reset le
+ * timer local à 30 min (la session serveur a été renouvelée implicitement).
+ */
+function markSessionActivity() {
+  state.sessionExpireAt = Date.now() + SESSION_DURATION_MS;
+  state.sessionPingDone = false;  // reset le flag de ping
+  updateSessionIndicator();
+}
+
 // v4.2 : fetche l'utilisateur EasyVista connecté (via background.js) et
 // l'affiche dans la topbar. En cas d'échec ou si aucun nom n'est trouvé,
 // le badge reste caché.
@@ -385,7 +414,7 @@ function toggleTheme() {
 
 function bindTopbar() {
   document.getElementById("theme-toggle").addEventListener("click", toggleTheme);
-  // v4.1.10 : 2 boutons de rafraîchissement.
+  // v4.1.10 : 2 boutons de rafraichissement.
   //  - refresh-btn (Total) : force le re-fetch de toutes les fiches (même celles
   //    déjà enrichies), utile pour voir les statuts évoluer.
   //  - refresh-partial-btn (Partiel) : re-fetch juste le XML planning pour
@@ -442,7 +471,7 @@ function bindTopbar() {
         hideUserNamePopup();
       }
     }
-    // v4.2.4 : clic ailleurs ferme aussi la grande bulle d'intervention
+    // v4.2.4 : clic ailleurs ferme aussi la grande bulle d'interventoin
     // quand elle est ouverte via clic timeline (mode "anchored"). Clic sur
     // la bulle elle-même ou sur une timeline-slot ne ferme pas.
     const tip = tooltipEl();
@@ -703,7 +732,7 @@ function initModalScrollLock() {
   updateLock();  // au cas où un modal serait déjà là au boot
 }
 
-// v4.2.9 : pied de page discret "QRO / Mois Année / vX.X.X" en bas à droite.
+// v4.2.9 : pied de page discret "QRO / vX.X.X" en bas à droite.
 // La version est lue depuis le manifest (source unique de vérité).
 function initAppFooter() {
   if (document.querySelector(".app-footer")) return;
@@ -713,13 +742,749 @@ function initAppFooter() {
       ? chrome.runtime.getManifest() : null;
     if (manifest && manifest.version) version = "v" + manifest.version;
   } catch (e) {}
-  const dateStr = "Avril 26";  // mois/année de release de cette itération
   const el = document.createElement("div");
   el.className = "app-footer";
-  el.textContent = `QRO / ${dateStr}${version ? " / " + version : ""}`;
+  el.textContent = `QRO${version ? " / " + version : ""}`;
   document.body.appendChild(el);
 }
 
+// v5.0.0 : horloge HH:MM au milieu de la topbar. Mise à jour toutes les 30s
+// (les secondes ne sont pas affichées donc pas besoin d'un tick plus rapide).
+function initAppClock() {
+  const el = document.getElementById("app-clock");
+  if (!el) return;
+  const tick = () => {
+    const d = new Date();
+    const h = String(d.getHours()).padStart(2, "0");
+    const m = String(d.getMinutes()).padStart(2, "0");
+    el.textContent = `${h}:${m}`;
+    // v5.0.0 : profite du tick pour mettre à jour la ligne rouge "now"
+    updateNowLine();
+  };
+  tick();
+  // Tick toutes les 30s : ça garantit une MAJ rapide au changement de min
+  setInterval(tick, 30 * 1000);
+}
+
+// v5.0.0 : ligne verticale rouge "heure actuelle" sur la timeline, visible
+// UNIQUEMENT quand on affiche aujourd'hui. Appelée à chaque tick de l'horloge
+// + après chaque render (cf renderFromData).
+function updateNowLine() {
+  const isToday = state.currentDate === todayISO();
+  // Retirer toutes les lignes existantes d'abord
+  document.querySelectorAll(".timeline-now-line").forEach(el => el.remove());
+  if (!isToday) return;
+  // Calculer la position en % sur la timeline (DAY_START à DAY_END)
+  const now = new Date();
+  const nowMin = now.getHours() * 60 + now.getMinutes();
+  if (nowMin < DAY_START || nowMin > DAY_END) return; // hors plage affichée
+  const pct = ((nowMin - DAY_START) / DAY_LEN) * 100;
+  // Ajouter une ligne sur chaque barre timeline visible
+  document.querySelectorAll(".timeline-bar").forEach(bar => {
+    const line = document.createElement("div");
+    line.className = "timeline-now-line";
+    line.style.left = pct + "%";
+    bar.appendChild(line);
+  });
+}
+
+// v5.0.0 : menu admin caché. 5 clics consécutifs sur le titre "Planification"
+// (avec max 2 secondes entre chaque clic) ouvrent le panneau admin.
+function initAdminMenu() {
+  const title = document.getElementById("app-title");
+  if (!title) return;
+  let clicks = 0;
+  let resetTimer = null;
+  title.addEventListener("click", () => {
+    clicks++;
+    if (resetTimer) clearTimeout(resetTimer);
+    resetTimer = setTimeout(() => { clicks = 0; }, 2000);
+    if (clicks >= 5) {
+      clicks = 0;
+      clearTimeout(resetTimer);
+      showAdminPanel();
+    }
+  });
+  // Cursor pointer pour indiquer (discrètement) qu'il est cliquable
+  title.style.cursor = "default";
+}
+
+// ============================================================================
+// v5.0.9 : Surveillance du timeout de session EasyVista
+// ============================================================================
+
+/**
+ * Initialise le tick du compteur de session (toutes les secondes).
+ * Pas de requête réseau : décompte purement local depuis state.sessionExpireAt.
+ * En parallèle, un polling 2s actif uniquement en reconnexion, pour détecter
+ * dès que l'user s'est reconnecté dans l'onglet EasyVista ouvert.
+ */
+function initSessionTimer() {
+  setInterval(() => {
+    updateSessionIndicator();
+  }, 1000);
+
+  // Polling actif UNIQUEMENT pendant une reconnexion pour détecter le nouveau
+  // PHPSESSID dès qu'il apparaît dans un onglet EV. Rien d'envoyé au serveur
+  // en dehors de ça.
+  setInterval(async () => {
+    if (!state.reconnecting) return;
+    try {
+      const resp = await sendMessage({ type: "getSession" });
+      if (resp && resp.ok && resp.session && resp.session.phpsessid) {
+        const oldPhpsessid = state.session ? state.session.phpsessid : null;
+        if (resp.session.phpsessid !== oldPhpsessid) {
+          console.log("[session] nouvelle session détectée après reconnexion :", resp.session.phpsessid);
+          state.session = resp.session;
+          state.reconnecting = false;
+          state.sessionExpired = false;
+          hideReconnectingBanner();
+          hideSessionExpiredBanner();
+          markSessionActivity();
+          showToast("Reconnecté", "Session EasyVista renouvelée");
+          // Recharger le planning à la date courante sans perdre la position
+          await loadForDate(state.currentDate);
+        }
+      }
+    } catch (e) {
+      // Silencieux, on réessayera au prochain tick
+    }
+  }, 2000);
+}
+
+/**
+ * Met à jour l'affichage du compteur session dans la topbar.
+ * Règles :
+ *   - Session expirée ou reconnexion → compteur caché (bannière gère l'affichage)
+ *   - > 5 min restantes → compteur invisible
+ *   - 2-5 min → jaune, bouton "Prolonger" visible
+ *   - < 2 min → rouge pulse + modal automatique (une seule fois)
+ *   - <= 0 → déclenche l'état "expirée"
+ */
+function updateSessionIndicator() {
+  const el = document.getElementById("app-session");
+  if (!el) return;
+
+  if (state.sessionExpired || state.reconnecting) {
+    el.classList.add("hidden");
+    return;
+  }
+  if (!state.sessionExpireAt) {
+    el.classList.add("hidden");
+    return;
+  }
+
+  const remainingMs = state.sessionExpireAt - Date.now();
+
+  if (remainingMs <= 0) {
+    handleSessionExpired();
+    return;
+  }
+
+  if (remainingMs > SESSION_WARN_THRESHOLD_MS) {
+    el.classList.add("hidden");
+    return;
+  }
+
+  // Zone d'alerte (< 5 min)
+  // v5.0.9 : avant d'afficher l'alerte, on fait UN ping de confirmation
+  // pour vérifier que le serveur est bien d'accord (compteur local parfois
+  // désynchronisé si plusieurs requêtes EV ont rafraîchi sans qu'on update
+  // notre horloge). Une seule fois par cycle.
+  if (!state.sessionPingDone) {
+    state.sessionPingDone = true;
+    sendMessage({ type: "getSessionRemaining" }).then(resp => {
+      if (resp && resp.ok && typeof resp.remainingMs === "number") {
+        state.sessionExpireAt = Date.now() + resp.remainingMs;
+        updateSessionIndicator();
+      }
+    }).catch(() => {});
+    // En attendant, on continue avec l'estimation locale
+  }
+
+  const mm = Math.floor(remainingMs / 60000);
+  const ss = Math.floor((remainingMs % 60000) / 1000);
+  const timeStr = `${String(mm).padStart(2, "0")}:${String(ss).padStart(2, "0")}`;
+  el.classList.remove("hidden", "session-warn", "session-critical");
+
+  if (remainingMs <= SESSION_CRITICAL_THRESHOLD_MS) {
+    el.classList.add("session-critical");
+    if (!state._criticalModalShown) {
+      state._criticalModalShown = true;
+      showSessionCriticalModal();
+    }
+  } else {
+    el.classList.add("session-warn");
+    state._criticalModalShown = false;
+  }
+
+  el.innerHTML = `
+    <span class="session-icon">⏱</span>
+    <span class="session-time">${timeStr}</span>
+    <button type="button" class="session-extend-btn" title="Prolonger la session de 30 min">🔄 Prolonger</button>
+  `;
+  const extendBtn = el.querySelector(".session-extend-btn");
+  if (extendBtn) {
+    extendBtn.onclick = async () => {
+      extendBtn.disabled = true;
+      extendBtn.textContent = "…";
+      try {
+        const resp = await sendMessage({ type: "extendSession" });
+        if (resp && resp.ok && typeof resp.remainingMs === "number") {
+          state.sessionExpireAt = Date.now() + resp.remainingMs;
+          state.sessionPingDone = false;
+          state._criticalModalShown = false;
+          showToast("Session prolongée", "30 minutes de plus");
+          updateSessionIndicator();
+        } else {
+          throw new Error((resp && resp.error) || "erreur inconnue");
+        }
+      } catch (err) {
+        extendBtn.disabled = false;
+        extendBtn.textContent = "🔄 Prolonger";
+        if (err.message === "session_expired" || err.message === "no_session") {
+          handleSessionExpired();
+        }
+      }
+    };
+  }
+}
+
+/**
+ * Appelée quand le compteur atteint 0 ou quand une requête EV échoue en
+ * session expirée. Affiche la bannière "Session expirée" avec bouton "Me
+ * reconnecter".
+ */
+function handleSessionExpired() {
+  if (state.sessionExpired) return;
+  state.sessionExpired = true;
+  state.sessionExpireAt = null;
+  state._criticalModalShown = false;
+  console.warn("[session] session EV expirée");
+  showSessionExpiredBanner();
+  const el = document.getElementById("app-session");
+  if (el) el.classList.add("hidden");
+}
+
+/**
+ * Modal auto quand < 2 min : alerte visuelle forte.
+ */
+function showSessionCriticalModal() {
+  showAlertModal({
+    title: "⚠️ Session EasyVista expire bientôt",
+    message: "Votre session EasyVista expire dans moins de 2 minutes. Cliquez sur « Prolonger » pour éviter d'être déconnecté.",
+    buttons: [
+      { label: "Ignorer", variant: "secondary", action: () => {} },
+      {
+        label: "🔄 Prolonger maintenant",
+        variant: "primary",
+        action: async () => {
+          try {
+            const resp = await sendMessage({ type: "extendSession" });
+            if (resp && resp.ok && typeof resp.remainingMs === "number") {
+              state.sessionExpireAt = Date.now() + resp.remainingMs;
+              state.sessionPingDone = false;
+              state._criticalModalShown = false;
+              showToast("Session prolongée", "30 minutes de plus");
+              updateSessionIndicator();
+            }
+          } catch (e) {
+            handleSessionExpired();
+          }
+        }
+      }
+    ]
+  });
+}
+
+/**
+ * Appelé au clic "Me reconnecter" dans la bannière. Ouvre EasyVista dans un
+ * nouvel onglet (déclenche Windows SSO Kerberos automatique). Le polling
+ * dans initSessionTimer détectera la nouvelle session et rechargera le viewer.
+ */
+async function triggerReconnect() {
+  state.reconnecting = true;
+  hideSessionExpiredBanner();
+  showReconnectingBanner();
+  try {
+    const origin = (state.session && state.session.origin) || "https://itsma.etat-de-vaud.ch";
+    await sendMessage({ type: "openEasyVistaLogin", origin });
+  } catch (err) {
+    console.warn("[session] openEasyVistaLogin failed:", err);
+    state.reconnecting = false;
+    hideReconnectingBanner();
+    showSessionExpiredBanner();
+  }
+}
+
+
+// v5.0.0 : stockage des paramètres admin dans chrome.storage.local.
+// Clé unique : "admin_config". Contient la config éditable (équipe,
+// absences récurrentes, statuts etc.). Au 1er lancement : initialisée
+// avec les valeurs hardcodées actuelles.
+const ADMIN_CONFIG_KEY = "admin_config";
+
+function getDefaultAdminConfig() {
+  return {
+    team: { ...TEAM },                          // Clone pour ne pas modifier le hardcode
+    recurringAbsences: { ...RECURRING_ABSENCES }, // idem
+    groupId: "191",
+    evOrigins: ["https://itsma.etat-de-vaud.ch", "https://itsma.vd.ch"],
+    closedStatus: [...CLOSED_STATUS],
+    resolvedStatus: [...RESOLVED_STATUS],
+    cancelledStatus: [...CANCELLED_STATUS],
+    dayStart: 8,
+    dayEnd: 18,
+    cacheDays: 7
+  };
+}
+
+async function loadAdminConfig() {
+  try {
+    const stored = await chrome.storage.local.get(ADMIN_CONFIG_KEY);
+    if (stored && stored[ADMIN_CONFIG_KEY]) {
+      // Fusion avec les defaults (pour rajouter d'éventuelles nouvelles clés)
+      return { ...getDefaultAdminConfig(), ...stored[ADMIN_CONFIG_KEY] };
+    }
+  } catch (e) {
+    console.warn("[admin] loadAdminConfig err", e);
+  }
+  return getDefaultAdminConfig();
+}
+
+async function saveAdminConfig(cfg) {
+  try {
+    await chrome.storage.local.set({ [ADMIN_CONFIG_KEY]: cfg });
+    console.log("[admin] config sauvegardée");
+    return true;
+  } catch (e) {
+    console.error("[admin] saveAdminConfig err", e);
+    return false;
+  }
+}
+
+// v5.0.0 : affiche le panel admin plein écran.
+async function showAdminPanel() {
+  // Ferme un éventuel panel existant
+  const existing = document.getElementById("admin-panel");
+  if (existing) existing.remove();
+
+  // Charge la config actuelle
+  const cfg = await loadAdminConfig();
+
+  // Overlay plein écran
+  const overlay = document.createElement("div");
+  overlay.id = "admin-panel";
+  overlay.className = "modal-overlay admin-overlay";
+
+  const card = document.createElement("div");
+  card.className = "admin-panel-card";
+
+  // En-tête
+  const header = document.createElement("div");
+  header.className = "admin-header";
+  const title = document.createElement("h2");
+  title.textContent = "⚙ Administration";
+  title.className = "admin-title";
+  const closeBtn = document.createElement("button");
+  closeBtn.type = "button";
+  closeBtn.className = "admin-close-btn";
+  closeBtn.textContent = "×";
+  closeBtn.title = "Fermer (Échap)";
+  closeBtn.addEventListener("click", () => overlay.remove());
+  header.appendChild(title);
+  header.appendChild(closeBtn);
+  card.appendChild(header);
+
+  // Navigation latérale (onglets)
+  const body = document.createElement("div");
+  body.className = "admin-body";
+
+  const sidebar = document.createElement("nav");
+  sidebar.className = "admin-sidebar";
+
+  const content = document.createElement("div");
+  content.className = "admin-content";
+
+  const sections = [
+    { id: "team",       label: "Équipe",         render: renderAdminSectionTeam },
+    { id: "easyvista",  label: "EasyVista",      render: renderAdminSectionEV },
+    { id: "appearance", label: "Apparence",      render: renderAdminSectionAppearance },
+    { id: "statuses",   label: "Statuts",        render: renderAdminSectionStatuses },
+    { id: "diagnostics",label: "Diagnostics",    render: renderAdminSectionDiagnostics }
+  ];
+
+  let currentSection = "team";
+
+  const navButtons = {};
+  for (const section of sections) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "admin-nav-btn";
+    btn.textContent = section.label;
+    btn.dataset.section = section.id;
+    if (section.id === currentSection) btn.classList.add("active");
+    btn.addEventListener("click", () => {
+      currentSection = section.id;
+      for (const k in navButtons) navButtons[k].classList.remove("active");
+      btn.classList.add("active");
+      content.innerHTML = "";
+      section.render(content, cfg, () => saveAndReload(cfg));
+    });
+    navButtons[section.id] = btn;
+    sidebar.appendChild(btn);
+  }
+
+  body.appendChild(sidebar);
+  body.appendChild(content);
+  card.appendChild(body);
+  overlay.appendChild(card);
+  document.body.appendChild(overlay);
+
+  // Rendu initial : section "Équipe"
+  sections[0].render(content, cfg, () => saveAndReload(cfg));
+
+  // Échap ferme le panel
+  const escHandler = (e) => {
+    if (e.key === "Escape") {
+      overlay.remove();
+      document.removeEventListener("keydown", escHandler);
+    }
+  };
+  document.addEventListener("keydown", escHandler);
+
+  async function saveAndReload(updatedCfg) {
+    const ok = await saveAdminConfig(updatedCfg);
+    if (ok) {
+      showToast("Config enregistrée", "Rechargez l'extension pour appliquer");
+    } else {
+      showAlertModal({
+        title: "Erreur",
+        message: "Impossible d'enregistrer la configuration.",
+        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
+      });
+    }
+  }
+}
+
+// v5.0.0 : section "Équipe" du panel admin.
+// v5.0.1 : affiche la liste complète du groupe EasyVista (20+ personnes),
+// avec case à cocher "inclure dans la planification" pour chacune.
+function renderAdminSectionTeam(container, cfg, saveFn) {
+  const h = document.createElement("h3");
+  h.textContent = "Équipe";
+  h.className = "admin-section-title";
+  container.appendChild(h);
+
+  const desc = document.createElement("p");
+  desc.className = "admin-section-desc";
+  desc.textContent = "Sélectionnez les personnes qui doivent apparaître dans la planification. Les IDs viennent d'EasyVista (bouton Détecter) ou peuvent être saisis manuellement.";
+  container.appendChild(desc);
+
+  // État local : liste {id, name, included, days:[0..6]}
+  // Au départ on remplit depuis cfg.team actuel, puis la détection EV
+  // enrichit cette liste.
+  const rows = [];
+  for (const [id, name] of Object.entries(cfg.team || {})) {
+    rows.push({
+      id,
+      name,
+      included: true,
+      days: (cfg.recurringAbsences[id] || []).slice()
+    });
+  }
+
+  const tableWrap = document.createElement("div");
+  tableWrap.className = "admin-team-wrap";
+  container.appendChild(tableWrap);
+
+  function render() {
+    tableWrap.innerHTML = "";
+
+    // Bouton "Détecter depuis EasyVista"
+    const detectBtn = document.createElement("button");
+    detectBtn.type = "button";
+    detectBtn.className = "btn btn-secondary";
+    detectBtn.textContent = "🔍 Détecter depuis EasyVista (groupe complet)";
+    detectBtn.style.marginBottom = "12px";
+    detectBtn.addEventListener("click", async () => {
+      detectBtn.disabled = true;
+      detectBtn.textContent = "Détection en cours…";
+      try {
+        const resp = await sendMessage({ type: "detectTeam" });
+        if (resp && resp.ok && resp.members && resp.members.length) {
+          // Merge : pour chaque membre détecté, ajoute à `rows` s'il n'y est
+          // pas déjà. S'il y est déjà, met à jour le nom (si meilleur).
+          for (const m of resp.members) {
+            const existing = rows.find(r => r.id === m.id);
+            if (existing) {
+              // Améliorer le nom si le nom actuel commence par "?"
+              if (m.name && !m.name.startsWith("?") && existing.name.startsWith("?")) {
+                existing.name = m.name;
+              }
+            } else {
+              rows.push({
+                id: m.id,
+                name: m.name || "? (" + m.id + ")",
+                included: !!m.alreadyInTeam,  // coché si déjà dans l'équipe
+                days: []
+              });
+            }
+          }
+          showToast("Détecté", resp.members.length + " personne(s) dans le groupe");
+          render();
+        } else {
+          showAlertModal({
+            title: "Détection impossible",
+            message: (resp && resp.error) || "Aucune personne trouvée. Vérifiez que vous êtes connecté à EasyVista.",
+            buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
+          });
+        }
+      } catch (err) {
+        console.warn("[admin] detectTeam err", err);
+      } finally {
+        detectBtn.disabled = false;
+        detectBtn.textContent = "🔍 Détecter depuis EasyVista (groupe complet)";
+      }
+    });
+    tableWrap.appendChild(detectBtn);
+
+    // Stats : nb inclus / total
+    const included = rows.filter(r => r.included).length;
+    const stats = document.createElement("div");
+    stats.className = "admin-section-desc";
+    stats.style.marginTop = "0";
+    stats.textContent = `${included} personne(s) incluse(s) sur ${rows.length} connue(s).`;
+    tableWrap.appendChild(stats);
+
+    // Table
+    const table = document.createElement("table");
+    table.className = "admin-team-table";
+    const thead = document.createElement("thead");
+    thead.innerHTML = "<tr><th>Inclure</th><th>ID</th><th>Nom affiché</th><th>Absences récurrentes</th><th></th></tr>";
+    table.appendChild(thead);
+    const tbody = document.createElement("tbody");
+    table.appendChild(tbody);
+
+    const days = ["Dim","Lun","Mar","Mer","Jeu","Ven","Sam"];
+    rows.forEach((r, idx) => {
+      const tr = document.createElement("tr");
+      if (!r.included) tr.classList.add("admin-row-excluded");
+
+      // Checkbox inclure
+      const tdInc = document.createElement("td");
+      const cb = document.createElement("input");
+      cb.type = "checkbox";
+      cb.checked = r.included;
+      cb.addEventListener("change", () => {
+        r.included = cb.checked;
+        tr.classList.toggle("admin-row-excluded", !r.included);
+        stats.textContent = `${rows.filter(x => x.included).length} personne(s) incluse(s) sur ${rows.length} connue(s).`;
+      });
+      tdInc.appendChild(cb);
+      tr.appendChild(tdInc);
+
+      // ID
+      const tdId = document.createElement("td");
+      const inpId = document.createElement("input");
+      inpId.type = "text";
+      inpId.value = r.id;
+      inpId.placeholder = "76272";
+      inpId.className = "admin-input admin-input-id";
+      inpId.addEventListener("input", () => { r.id = inpId.value.trim(); });
+      tdId.appendChild(inpId);
+      tr.appendChild(tdId);
+
+      // Nom
+      const tdName = document.createElement("td");
+      const inpName = document.createElement("input");
+      inpName.type = "text";
+      inpName.value = r.name;
+      inpName.placeholder = "Dupont, Jean";
+      inpName.className = "admin-input";
+      inpName.addEventListener("input", () => { r.name = inpName.value.trim(); });
+      tdName.appendChild(inpName);
+      tr.appendChild(tdName);
+
+      // Jours d'absence récurrente
+      const tdAbs = document.createElement("td");
+      for (let d = 0; d < 7; d++) {
+        const lbl = document.createElement("label");
+        lbl.className = "admin-day-cb";
+        const cbd = document.createElement("input");
+        cbd.type = "checkbox";
+        cbd.checked = r.days.includes(d);
+        cbd.addEventListener("change", () => {
+          if (cbd.checked && !r.days.includes(d)) r.days.push(d);
+          if (!cbd.checked) r.days = r.days.filter(x => x !== d);
+        });
+        lbl.appendChild(cbd);
+        lbl.appendChild(document.createTextNode(days[d]));
+        tdAbs.appendChild(lbl);
+      }
+      tr.appendChild(tdAbs);
+
+      // Bouton supprimer ligne
+      const tdDel = document.createElement("td");
+      const delBtn = document.createElement("button");
+      delBtn.type = "button";
+      delBtn.className = "admin-del-btn";
+      delBtn.textContent = "🗑";
+      delBtn.title = "Retirer cette ligne";
+      delBtn.addEventListener("click", () => {
+        rows.splice(idx, 1);
+        render();
+      });
+      tdDel.appendChild(delBtn);
+      tr.appendChild(tdDel);
+
+      tbody.appendChild(tr);
+    });
+
+    tableWrap.appendChild(table);
+
+    // Bouton Ajouter manuellement
+    const addBtn = document.createElement("button");
+    addBtn.type = "button";
+    addBtn.className = "btn btn-secondary";
+    addBtn.textContent = "+ Ajouter manuellement";
+    addBtn.style.marginTop = "10px";
+    addBtn.addEventListener("click", () => {
+      rows.push({ id: "", name: "", included: true, days: [] });
+      render();
+    });
+    tableWrap.appendChild(addBtn);
+
+    // Bouton Enregistrer
+    const saveBtn = document.createElement("button");
+    saveBtn.type = "button";
+    saveBtn.className = "btn btn-primary";
+    saveBtn.textContent = "💾 Enregistrer";
+    saveBtn.style.marginTop = "20px";
+    saveBtn.style.marginLeft = "10px";
+    saveBtn.addEventListener("click", () => {
+      // Reconstruire cfg.team et cfg.recurringAbsences à partir de rows
+      const newTeam = {};
+      const newRecAbs = {};
+      for (const r of rows) {
+        if (!r.included || !r.id) continue;
+        newTeam[r.id] = r.name || ("? (" + r.id + ")");
+        if (r.days && r.days.length > 0) newRecAbs[r.id] = r.days.slice();
+      }
+      cfg.team = newTeam;
+      cfg.recurringAbsences = newRecAbs;
+      saveFn();
+    });
+    tableWrap.appendChild(saveBtn);
+  }
+
+  render();
+}
+
+// v5.0.0 : sections suivantes (placeholders, à enrichir v5.0.1+)
+function renderAdminSectionEV(container, cfg, saveFn) {
+  const h = document.createElement("h3");
+  h.textContent = "EasyVista";
+  h.className = "admin-section-title";
+  container.appendChild(h);
+  const desc = document.createElement("p");
+  desc.className = "admin-section-desc";
+  desc.textContent = "Section à venir dans v5.0.1. Origines EasyVista + group_id.";
+  container.appendChild(desc);
+  // Infos lecture seule pour l'instant
+  const pre = document.createElement("pre");
+  pre.className = "admin-readonly";
+  pre.textContent = JSON.stringify({
+    evOrigins: cfg.evOrigins,
+    groupId: cfg.groupId
+  }, null, 2);
+  container.appendChild(pre);
+}
+
+function renderAdminSectionAppearance(container, cfg, saveFn) {
+  const h = document.createElement("h3");
+  h.textContent = "Apparence";
+  h.className = "admin-section-title";
+  container.appendChild(h);
+  const desc = document.createElement("p");
+  desc.className = "admin-section-desc";
+  desc.textContent = "Section à venir dans v5.0.x. Heures journée, durée cache, thème.";
+  container.appendChild(desc);
+  const pre = document.createElement("pre");
+  pre.className = "admin-readonly";
+  pre.textContent = JSON.stringify({
+    dayStart: cfg.dayStart,
+    dayEnd: cfg.dayEnd,
+    cacheDays: cfg.cacheDays
+  }, null, 2);
+  container.appendChild(pre);
+}
+
+function renderAdminSectionStatuses(container, cfg, saveFn) {
+  const h = document.createElement("h3");
+  h.textContent = "Statuts";
+  h.className = "admin-section-title";
+  container.appendChild(h);
+  const desc = document.createElement("p");
+  desc.className = "admin-section-desc";
+  desc.textContent = "Section à venir dans v5.0.x. Mots-clés Clôturé / Résolu / Annulé.";
+  container.appendChild(desc);
+  const pre = document.createElement("pre");
+  pre.className = "admin-readonly";
+  pre.textContent = JSON.stringify({
+    closed: cfg.closedStatus,
+    resolved: cfg.resolvedStatus,
+    cancelled: cfg.cancelledStatus
+  }, null, 2);
+  container.appendChild(pre);
+}
+
+function renderAdminSectionDiagnostics(container, cfg, saveFn) {
+  const h = document.createElement("h3");
+  h.textContent = "Diagnostics";
+  h.className = "admin-section-title";
+  container.appendChild(h);
+
+  const version = (chrome && chrome.runtime && chrome.runtime.getManifest)
+    ? chrome.runtime.getManifest().version : "?";
+
+  const info = document.createElement("div");
+  info.className = "admin-diag-grid";
+  info.innerHTML = `
+    <div><strong>Version</strong></div><div>${escapeHtml(version)}</div>
+    <div><strong>Date courante</strong></div><div>${escapeHtml(state.currentDate || "?")}</div>
+    <div><strong>Aujourd'hui</strong></div><div>${escapeHtml(todayISO())}</div>
+    <div><strong>Session EasyVista</strong></div><div>${state.session ? "✓ connecté (" + (state.session.origin || "?") + ")" : "✗ non détecté"}</div>
+    <div><strong>Popups épinglées</strong></div><div>${pinnedPopups.length}</div>
+  `;
+  container.appendChild(info);
+
+  // Bouton reset
+  const resetBtn = document.createElement("button");
+  resetBtn.type = "button";
+  resetBtn.className = "btn btn-danger";
+  resetBtn.textContent = "⚠ Réinitialiser la configuration (équipe, etc.)";
+  resetBtn.style.marginTop = "20px";
+  resetBtn.addEventListener("click", () => {
+    showAlertModal({
+      title: "Confirmer la réinitialisation",
+      message: "Remettre TOUTES les configurations aux valeurs par défaut ? (les techniciens ajoutés manuellement seront perdus)",
+      buttons: [
+        { label: "Annuler", variant: "secondary", action: () => {} },
+        {
+          label: "Réinitialiser",
+          variant: "danger",
+          action: async () => {
+            await chrome.storage.local.remove(ADMIN_CONFIG_KEY);
+            showToast("Réinitialisé", "Rechargez la page pour voir les défauts");
+          }
+        }
+      ]
+    });
+  });
+  container.appendChild(resetBtn);
+}
+
 // ============================================================================
 // v4.2.6 : Modals Absence et Douchette
 // ============================================================================
@@ -829,6 +1594,11 @@ function showAbsenceModal() {
   card.className = "modal-card modal-wide";
   card.setAttribute("role", "dialog");
 
+  // v5.0.0 : on mémorise la date affichée au moment de l'ouverture de la
+  // modal. Le reload après création se fait sur cette date précise, pas
+  // sur state.currentDate (qui aurait pu changer entre-temps).
+  const dateAtOpen = state.currentDate || todayISO();
+
   const title = document.createElement("h2");
   title.className = "modal-title";
   title.textContent = "Créer une absence";
@@ -895,6 +1665,49 @@ function showAbsenceModal() {
   endGroup.appendChild(endRow);
   card.appendChild(endGroup);
 
+  // v5.0.4 : presets rapides pour les horaires (matin / après-midi / journée)
+  const presetGroup = document.createElement("div");
+  presetGroup.className = "modal-form-group";
+  const presetLabel = document.createElement("label");
+  presetLabel.className = "modal-form-label";
+  presetLabel.textContent = "Presets rapides";
+  presetGroup.appendChild(presetLabel);
+  const presetRow = document.createElement("div");
+  presetRow.className = "modal-form-row modal-preset-row";
+  const presets = [
+    { label: "Matin",           start: "08:00", end: "12:00" },
+    { label: "Après-midi",      start: "13:00", end: "18:00" },
+    { label: "Toute la journée", start: "08:00", end: "18:00" }
+  ];
+  for (const p of presets) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "btn btn-secondary modal-preset-btn";
+    btn.textContent = p.label;
+    btn.addEventListener("click", () => {
+      startTime.value = p.start;
+      endTime.value = p.end;
+      // Synchroniser visuellement la mise à jour et déclencher
+      // endDateTouched si besoin (la date reste inchangée)
+      startTime.dispatchEvent(new Event("input", { bubbles: true }));
+      endTime.dispatchEvent(new Event("input", { bubbles: true }));
+    });
+    presetRow.appendChild(btn);
+  }
+  presetGroup.appendChild(presetRow);
+  card.appendChild(presetGroup);
+
+  // v5.0.0 : la date de fin suit la date de début tant que l'user ne l'a
+  // pas explicitement modifiée. 95% des absences sont d'un seul jour, donc
+  // changer juste le start doit mettre à jour le end aussi.
+  let endDateTouched = false;
+  endDate.addEventListener("input", () => { endDateTouched = true; });
+  startDate.addEventListener("input", () => {
+    if (!endDateTouched || endDate.value < startDate.value) {
+      endDate.value = startDate.value;
+    }
+  });
+
   // Type d'absence
   const typeGroup = document.createElement("div");
   typeGroup.className = "modal-form-group";
@@ -959,6 +1772,17 @@ function showAbsenceModal() {
       });
       return;
     }
+    // v5.0.0 : validation fin >= début pour ne pas envoyer des absences
+    // inversées à EasyVista (il les accepte mais elles n'apparaissent jamais
+    // dans le planning, cf bug constaté).
+    if (ed < sd || (ed === sd && et <= st)) {
+      showAlertModal({
+        title: "Dates incohérentes",
+        message: "La date/heure de fin doit être après la date/heure de début.",
+        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
+      });
+      return;
+    }
     // Désactiver le bouton pendant l'envoi
     applyBtn.disabled = true;
     applyBtn.textContent = "Envoi…";
@@ -973,9 +1797,11 @@ function showAbsenceModal() {
       });
       overlay.remove();
       showToast("Absence créée", techIds.length + " tech" + (techIds.length > 1 ? "s" : ""));
-      // Reload le planning du jour pour voir l'absence
+      // v5.0.0 : reload le planning DE LA DATE AFFICHÉE AVANT (dateAtOpen),
+      // pas de state.currentDate qui a pu être modifié entre-temps (bug
+      // où le planning sautait à la date de début de l'absence).
       if (state.session) {
-        await loadForDate(state.currentDate, { forceRefetch: true });
+        await loadForDate(dateAtOpen, { forceRefetch: true });
       }
     } catch (err) {
       applyBtn.disabled = false;
@@ -1218,6 +2044,13 @@ async function writeCache(isoDate, data) {
 // ============================================================================
 
 async function loadForDate(isoDate, opts = {}) {
+  // v4.3.1 : changer de date ferme tous les popups épinglés. Ils réfèrent à
+  // des interventions du jour courant, ils n'ont aucun sens sur un autre jour.
+  const previousDate = state.currentDate;
+  if (previousDate && previousDate !== isoDate && typeof closeAllPinnedPopups === "function") {
+    closeAllPinnedPopups();
+  }
+
   state.currentDate = isoDate;
   document.getElementById("date-picker").value = isoDate;
 
@@ -1363,17 +2196,31 @@ async function loadForDate(isoDate, opts = {}) {
       )
     );
 
+    // v5.0.6 : logs détaillés pour diagnostiquer pourquoi le fetch ne se
+    // lance pas.
+    const totalIv = merged.techs.reduce((s, t) => s + (t.interventions || []).length, 0);
+    const totalInterIv = merged.techs.reduce((s, t) =>
+      s + (t.interventions || []).filter(i => i.type === "AL-Intervention").length, 0);
+    const notFetched = merged.techs.reduce((s, t) =>
+      s + (t.interventions || []).filter(i => i.type === "AL-Intervention" && !i.ficheFetched).length, 0);
+    console.log(`[load] merged : ${merged.techs.length} techs, ${totalIv} iv totales, ${totalInterIv} interventions réelles, ${notFetched} sans fiche`);
+    console.log(`[load] needFetch = ${needFetch} | doStatusRefresh = ${!!opts.doStatusRefresh} | forceRefetch = ${!!opts.forceRefetch} | aborted = ${isRefreshAborted(myToken)}`);
+
+    // v4.3.2 : avant de lancer le fetch des fiches (lourd, ~460 KB chacune),
+    // on fait d'abord un batch xhr2 (léger, ~2-5 KB chacun) pour récupérer
+    // les vraies infos contact/lieu de toutes les interventions en parallèle.
+    if (!isRefreshAborted(myToken)) {
+      await prefetchAllXhr2(merged.techs, myToken, opts.doStatusRefresh);
+    }
+
     if ((opts.doStatusRefresh || needFetch) && !isRefreshAborted(myToken)) {
       const tFiches = performance.now();
       const nFiches = merged.techs.flatMap(t=>t.interventions).filter(i=>i.type==="AL-Intervention").length;
       console.log(`[load] début fetch des ${nFiches} fiches (statuts)…`);
-      // forceAll : uniquement si refresh manuel (bouton "Rafraîchir").
-      // À la navigation normale entre dates, on ne refetch que les iv non
-      // encore enrichies (ficheFetched=false) — ça reprend là où on s'était
-      // arrêté si un refresh précédent a été interrompu par un changement de
-      // date.
       await refreshStatuses(merged.techs, isoDate, { forceAll: !!opts.doStatusRefresh, myToken });
       console.log(`[load] fiches finies en ${Math.round(performance.now() - tFiches)} ms`);
+    } else {
+      console.log(`[load] PAS DE FETCH : needFetch=${needFetch}, doStatusRefresh=${!!opts.doStatusRefresh}, aborted=${isRefreshAborted(myToken)}`);
     }
 
     // 6. Sauvegarder dans le cache (une seule fois, après que tout soit enrichi)
@@ -1456,9 +2303,9 @@ async function fetchPlanningForDate(isoDate) {
     }
 
     // Safeguard (v3.1) : le serveur EasyVista répond parfois 200 avec un
-    // corps vide — typiquement quand la session vient d'être invalidée, ou
+    // corps vide — typiquement quand la sesson vient d'être invalidée, ou
     // quand il soupçonne du scraping (trop de requêtes parallèles). Dans
-    // les deux cas, on traite ça comme une session expirée : inutile de
+    // les deux cas, on traite ça comme une sesson expirée : inutile de
     // parser (ça ferait "Document is empty") ni de retry en boucle.
     if (!resp.xml || resp.xml.length < 20) {
       console.warn("[viewer] XML planning vide — session probablement invalide");
@@ -1570,15 +2417,18 @@ function actionNodeToIntervention(node) {
     if (refFromLabel) ref = refFromLabel[1];
   }
 
-  // Détection du type "Réservation" : un coordinateur a bloqué un créneau.
-  // Dans le XML, action_type = "AL-Absence" pour ce genre de créneau, mais
-  // action_label contient le vrai pattern :
-  //   action_label = "Xxxxx / Créé par : Nom, Prénom"
-  //   Ex: "Ecrans / Créé par : Nom20, Prénom20"
-  //       "Rollout / Créé par : Nom24, Prénom24"
-  //       "Congés / Créé par : ..."         → pas une réservation, c'est une absence
-  //       "Maladie / Créé par : ..."        → idem
-  //       "Pompier / Créé par : ..."        → idem
+  // Détection du type "Réservation" vs "Absence".
+  //
+  // v5.0.3 (simplifiée) : le label suit le pattern "Nom / Créé par : X Y".
+  //
+  //   - Congés / Maladie / Pompier         → AL-Absence (tech réellement absent)
+  //   - TOUT LE RESTE (Ecrans, PC, MAC, Rollout, Téléphones, UTP, Réunion,
+  //     Déménagement, Evènements spéciaux, Formation, ...)
+  //                                         → AL-Reservation (créneau bloqué, tech pas absent)
+  //
+  // Cette règle simple évite les cas "absence toute la journée" déclenchés
+  // par erreur pour des réservations de type événement / réunion.
+  const ABSENCE_LABELS = /^(cong[ée]s|maladie|pompier)$/i;
   let effectiveType = actionType;
   let reservationLabel = null;
   let reservationCreator = null;
@@ -1586,11 +2436,11 @@ function actionNodeToIntervention(node) {
   if (reservationMatch) {
     const label1 = reservationMatch[1].trim();
     const creator = reservationMatch[2].trim();
-    // Les "absences" connues (Congés/Maladie/Pompier) restent des absences
-    if (/^(cong[ée]s|maladie|pompier)$/i.test(label1)) {
+    if (ABSENCE_LABELS.test(label1)) {
+      // Vraie absence du tech
       effectiveType = "AL-Absence";
     } else {
-      // Tout autre label (Ecrans, Rollout, ...) → Réservation
+      // Réservation : créneau bloqué (matériel ou activité), tech pas absent
       effectiveType = "AL-Reservation";
       reservationLabel = label1;
       reservationCreator = creator;
@@ -1706,7 +2556,7 @@ function mergeCacheAndFresh(cached, fresh) {
   //     xhr2Fetched.
   //   - Règle générale : fresh wins sur les champs live, cache wins sur les
   //     champs enrichis qui ne sont pas dans le fresh.
-  //   - Une intervention en cache mais plus en fresh → marquée "ghost"
+  //   - Une interventoin en cache mais plus en fresh → marquée "ghost"
 
   if (!cached || !cached.techs) {
     return { techs: fresh.techs };
@@ -1776,6 +2626,14 @@ function mergeCacheAndFresh(cached, fresh) {
     if (!outTech) continue;
     for (const iv of tech.interventions || []) {
       if (!freshActionIds.has(iv.actionId)) {
+        // v5.0.1 : les absences et réservations supprimées côté EasyVista
+        // sont définitivement retirées (pas ghost). La logique ghost est
+        // conçue pour les interventions dont on veut garder trace en attendant
+        // la vérification du statut (clos/annulé). Absences/réservations n'ont
+        // pas de notion de statut, une disparition = suppression pure.
+        if (iv.type === "AL-Absence" || iv.type === "AL-Reservation") {
+          continue;  // ne pas rajouter
+        }
         const ghost = { ...iv, ghost: true };
         outTech.interventions.push(ghost);
       }
@@ -2163,7 +3021,7 @@ async function refreshStatuses(techs, isoDate, opts = {}) {
       if (statusClosed && iv.ficheFetched) continue;
       // v4.1.7 : pause/reprise par date. Sans forceAll (= chargement normal
       // au retour sur une date), on skip les iv déjà enrichies (ficheFetched)
-      // pour ne pas refetcher inutilement. Un clic sur "Rafraîchir" active
+      // pour ne pas refetcher inutilement. Un clic sur "rafraichir" active
       // forceAll, ce qui refetche les non-closes même si déjà enrichies (pour
       // voir passer les statuts "En cours" → "Exécution" → "Clôturé").
       if (!forceAll && iv.ficheFetched) continue;
@@ -2176,8 +3034,8 @@ async function refreshStatuses(techs, isoDate, opts = {}) {
   setRefreshing(true);
 
   // v4.1.7 : barre de progression visible uniquement si on est en train de
-  // rafraîchir la date actuellement affichée. Si l'user change de date
-  // pendant le refresh, isRefreshAborted() deviendra true et on sortira.
+  // rafraichir la date actuellement affichée. Si l'user change de date
+  // pdt le refresh, isRefreshAborted() deviendra true et on sortira.
   const showBar = (state.currentDate === isoDate);
   if (showBar) {
     updateProgressBar(0, toFetch.length);