Version 2026.5.34 — Bouton 📌 restauré + badge user cliquable

- _softUnpinPopup refait, _maybeRetryFetchUser, positionTooltipAnchored unifiée
[code interpolé]

manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Planification",
-  "version": "2026.5.28",
+  "version": "2026.5.34",
   "description": "Vue claire et rapide du planning des techniciens EasyVista. Regroupe interventions et réservations par tech, affiche horaires, contact, lieu, catégorie et statut en un coup d'œil.",
   "browser_specific_settings": {
     "gecko": {

viewer.css

@@ -2525,10 +2525,10 @@ header.topbar::before {
    et on réduit encore l'horloge. Les icônes restent, titres restent. */
 @media (max-width: 1000px) {
   .topbar { padding: 8px 14px; gap: 8px; }
-  .topbar h1 { font-size: 16px; }
-  .app-clock { font-size: smaller; }
-  .app-clock-date { font-size: 10px; }
-  .app-clock-time { font-size: 18px; }
+  .topbar h1 { font-size: 18px; }
+  .app-clock-date { font-size: 16px; }
+  .app-clock-time { font-size: 16px; }
+  .app-clock-date::after { font-size: 18px; }
   .btn-action .btn-action-label,
   .btn-refresh .btn-refresh-label {
     display: none;
@@ -2619,45 +2619,112 @@ header.topbar::before {
    v2026.5.19 : refonte — élément .pinned-popup-minref créé à la volée
    v2026.5.21 : agrandi pour que la ref tienne sans déborder
    v2026.5.22 : encore agrandi + plus d'espace entre dragbar et topbar
+   v2026.5.23 : refonte complète en style "onglet" single-line, compact
    ========================================================================== */
 .pinned-popup.pinned-popup-minimized {
+  display: flex !important;
+  flex-direction: row !important;
+  align-items: center !important;
   min-width: 300px !important;
-  max-width: 360px !important;
-  width: 300px !important;
-  height: auto !important;
-  min-height: 80px !important;
-  padding: 44px 16px 16px 16px !important;
+  max-width: 400px !important;
+  width: auto !important;
+  height: 36px !important;
+  min-height: 36px !important;
+  padding: 0 6px 0 4px !important;
   overflow: visible;
   background: var(--bg-elevated) !important;
   border: 1px solid var(--border) !important;
+  border-radius: 6px !important;
 }
-/* Séparer visuellement la dragbar (collée en haut) des boutons topbar */
+
+/* Dans le mode minimisé, la topbar n'est plus en absolute : elle se pose en fin
+   de ligne à droite, après la ref */
 .pinned-popup.pinned-popup-minimized .pinned-popup-topbar {
-  top: 14px !important;   /* sous la dragbar (qui fait ~6-8px) */
+  position: static !important;
+  top: auto !important;
+  right: auto !important;
+  margin-left: auto !important;
+  order: 3;
+  flex-shrink: 0;
+  padding: 0 2px;
 }
-/* Masquer tous les enfants directs du popup minimisé */
+
+/* La dragbar devient un simple "handle" à gauche (≡) */
+.pinned-popup.pinned-popup-minimized .pinned-popup-dragbar {
+  position: static !important;
+  top: auto !important;
+  left: auto !important;
+  right: auto !important;
+  order: 1;
+  flex-shrink: 0;
+  width: 18px !important;
+  height: 22px !important;
+  background: transparent !important;
+  border: none !important;
+  cursor: grab;
+  display: flex !important;
+  align-items: center;
+  justify-content: center;
+  color: var(--text-faint);
+  opacity: 0.6;
+  transition: opacity 0.12s, color 0.12s;
+}
+.pinned-popup.pinned-popup-minimized .pinned-popup-dragbar::before {
+  content: "≡" !important;
+  font-size: 15px;
+  line-height: 1;
+  /* v2026.5.24 : annuler les propriétés du ::before normal (barre grise) */
+  width: auto !important;
+  height: auto !important;
+  background: transparent !important;
+  border-radius: 0 !important;
+}
+.pinned-popup.pinned-popup-minimized .pinned-popup-dragbar:hover {
+  opacity: 1;
+  color: var(--text);
+}
+.pinned-popup.pinned-popup-minimized.dragging .pinned-popup-dragbar {
+  cursor: grabbing;
+}
+
+/* Masquer tous les enfants directs SAUF topbar, dragbar et minref */
 .pinned-popup.pinned-popup-minimized > *:not(.pinned-popup-topbar):not(.pinned-popup-dragbar):not(.pinned-popup-minref) {
   display: none !important;
 }
-/* L'élément ref dédié, centré et gros */
+
+/* La ref au centre, cliquable pour agrandir */
 .pinned-popup-minref {
-  display: block;
-  text-align: center;
-  padding: 10px 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;  /* v2026.5.24 : centrer horizontalement la ref */
+  flex: 1;
+  min-width: 0;
+  padding: 0 10px;
   font-family: var(--mono, monospace);
-  font-size: 15px;
+  font-size: 14px;
   font-weight: 700;
   color: var(--text);
   cursor: pointer;
   user-select: none;
-  border-radius: 4px;
-  transition: background 0.12s;
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
+  order: 2;
+  text-align: center;  /* v2026.5.24 : centrer le texte */
 }
 .pinned-popup-minref:hover {
-  background: var(--bg-muted);
+  color: var(--accent, #3b82f6);
+}
+
+/* Boutons plus petits en mode minimisé */
+.pinned-popup.pinned-popup-minimized .pinned-popup-btn {
+  width: 22px !important;
+  height: 22px !important;
+  font-size: 12px !important;
+}
+.pinned-popup.pinned-popup-minimized .pinned-popup-refresh svg {
+  width: 12px;
+  height: 12px;
 }
 
 /* ==========================================================================

viewer.html

@@ -17,7 +17,7 @@
            fetch aboutit. En cas d'échec persistant, reste sur "?". -->
       <button id="user-badge" class="user-badge user-badge-unknown"
               type="button" aria-label="Utilisateur connecté"
-              title="Utilisateur connecté"></button>
+              title="Utilisateur — cliquer pour accéder aux paramètres">?</button>
       <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>

viewer.js

@@ -5198,26 +5198,38 @@ function bindTimelinePopover(el) {
   });
 }
 
-// v4.2.3 : positionne la petite popup timeline à côté du curseur
+/**
+ * v4.2.3 : positionne la petite popup timeline à côté du curseur.
+ * Utilisée UNIQUEMENT en vue classique pour la petite popup qui suit la souris
+ * quand on survole un segment timeline (informations courtes : durée, ref).
+ *
+ * v2026.5.34 : documentation + logs. Le clamp dans le viewport reste local
+ * (pas unifié avec positionTooltipAnchored car la logique "suit-souris" est
+ * fondamentalement différente d'un ancrage fixe à une source).
+ *
+ * @param {MouseEvent} e - événement souris pour position courante
+ */
 function moveTimelineTooltip(e) {
   const tip = tooltipEl();
   if (!tip || !tip.classList.contains("visible")) return;
   // La popup ancrée (grande bulle) ne doit pas être déplacée par la souris
   if (bulleState.pinned) return;
-  // Si la popup affiche une grande bulle d'intervention (classe pinned-like),
+  // Si la popup affiche une grande bulle d'intervention (mode anchored),
   // on ne la bouge pas non plus : on la laisse ancrée.
   if (tip.dataset.mode === "anchored") return;
+
   const offsetX = 14, offsetY = 16;
   let x = e.clientX + offsetX;
   let y = e.clientY + offsetY;
   const rect = tip.getBoundingClientRect();
-  // Ajuster si on sort de la fenêtre
+
+  // Ajuster si on sort de la fenêtre (logique simple : flip autour du curseur)
   if (x + rect.width  > window.innerWidth  - 8) x = e.clientX - rect.width  - offsetX;
   if (y + rect.height > window.innerHeight - 8) y = e.clientY - rect.height - offsetY;
   if (x < 4) x = 4;
   if (y < 4) y = 4;
-  // v4.2.4 : utiliser setTooltipViewportPosition pour bénéficier de la
-  // détection automatique fixed/abs (et donc de la stabilité au scroll).
+
+  // setTooltipViewportPosition gère la détection auto fixed vs abs.
   setTooltipViewportPosition(x, y);
 }
 
@@ -5251,19 +5263,46 @@ function findIvByActionId(actionId) {
 // v4.2.3/4 : ouvre la GRANDE popup au clic sur un segment timeline, ancrée
 // juste en dessous du segment. Pas épinglée : se ferme sur clic ailleurs,
 // Échap, OU quand la souris quitte la popup elle-même (mouseleave).
+// v4.2.3/4 : ouvre la GRANDE popup au clic sur un segment timeline (vue
+// classique) ou au hover (vue horizontale). Ancrée à côté du segment, pas
+// sur. Se ferme au clic ailleurs.
+//
+// v2026.5.34 : utilise positionTooltipAnchored() unifié au lieu de recalculer
+// sa propre position. Plus de code dupliqué.
 function openPersistentTimelinePopup(el) {
+  if (!el) {
+    console.warn("[persistentTimeline] segment el null — abandon");
+    return;
+  }
   const ivIdx = el.dataset.ivIdx;
-  if (ivIdx === undefined) return;
+  if (ivIdx === undefined) {
+    console.log("[persistentTimeline] segment sans ivIdx (hole/absence vide) — abandon");
+    return;
+  }
   const cardEl = el.closest(".card");
-  if (!cardEl) return;
+  if (!cardEl) {
+    console.warn("[persistentTimeline] pas de .card parent trouvée");
+    return;
+  }
   const row = cardEl.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`);
-  if (!row) return;
+  if (!row) {
+    console.warn(`[persistentTimeline] row intervention-v2[data-iv-idx="${ivIdx}"] introuvable`);
+    return;
+  }
   const actionId = row.dataset.actionId;
   const iv = findIvByActionId(actionId);
-  if (!iv) return;
+  if (!iv) {
+    console.warn(`[persistentTimeline] iv pour actionId=${actionId} introuvable`);
+    return;
+  }
 
   const tip = tooltipEl();
-  if (!tip) return;
+  if (!tip) {
+    console.warn("[persistentTimeline] tooltipEl() null");
+    return;
+  }
+
+  console.log(`[persistentTimeline] ouverture grande popup pour iv actionId=${actionId}`);
 
   // Nettoyer tout état précédent (ancrage, épinglage, timers)
   bulleState.pinned = false;
@@ -5276,29 +5315,20 @@ function openPersistentTimelinePopup(el) {
   tip.innerHTML = buildTooltipHTML(iv);
   tip.classList.remove("hidden");
   tip.classList.add("visible");
-  // mode "anchored" : le hover ne doit pas la remplacer par une autre popup
+  // mode "anchored" : le hover timeline ne doit pas la remplacer par la petite popup
   tip.dataset.mode = "anchored";
   state.currentTooltipIv = iv;
 
-  // Position : juste sous le segment timeline. D'abord on reset les coords
-  // pour que getBoundingClientRect() reflète la vraie taille du nouveau
-  // contenu.
+  // v2026.5.34 : utiliser positionTooltipAnchored() unifié, en préférant
+  // dessous (sous le segment timeline) via opts.anchorBelow = true.
+  //
+  // D'abord on reset les coords pour que le tipRect soit correctement mesuré
+  // avec le nouveau contenu.
   tip.style.left = "-9999px";
   tip.style.top = "0px";
-  // Forcer un reflow pour que tipRect soit à jour avec le nouveau contenu
-  const tipRect = tip.getBoundingClientRect();
-  const r = el.getBoundingClientRect();
-  let x = r.left;
-  let y = r.bottom + 8;
-  if (x + tipRect.width > window.innerWidth - 8) x = window.innerWidth - tipRect.width - 8;
-  if (x < 4) x = 4;
-  if (y + tipRect.height > window.innerHeight - 8) {
-    y = r.top - tipRect.height - 8;
-  }
-  if (y < 4) y = 4;
-
-  // Positionner proprement (avec détection auto fixed vs abs)
-  setTooltipViewportPosition(x, y);
+  // Force reflow
+  void tip.offsetWidth;
+  positionTooltipAnchored(el, { anchorBelow: true });
 }
 
 function showTimelinePopover(e, el) {
@@ -5934,6 +5964,21 @@ function extractContacts(raw) {
  */
 function splitOneContact(raw) {
   if (!raw) return { name: null, phone: null };
+
+  // v2026.5.25 : avant d'extraire les numéros, on REMPLACE les séquences qui
+  // sont des identifiants de matériel (LETTRES_CHIFFRES) par des espaces.
+  // Exemples : XXXX_NNNNNNNNNNN, XNNNNNN, XNNNNNN, XNNNNNN.
+  // Sans ça, XXXX_NNNNNNNNNNN laisse des "NNNN NNN NN NN" qui se font prendre
+  // pour un numéro de téléphone par le regex qui greedy sur [0-9\s.\-].
+  // On remplace par des espaces de même longueur pour préserver les offsets
+  // (important pour le calcul de position du nom avant le 1er numéro).
+  raw = String(raw);
+  raw = raw.replace(/\b[A-Z]{1,6}_\d+/g, (m) => " ".repeat(m.length));
+  // Idem pour les identifiants sans underscore style XNNNNNN, XNNNNNN, XNNNNNN
+  // (1-2 lettres majuscules suivies de 5+ chiffres collés). On garde assez
+  // permissif pour matcher les variantes sans enlever des vrais mots.
+  raw = raw.replace(/\b[A-Z]{1,3}\d{5,}\b/g, (m) => " ".repeat(m.length));
+
   // v4.1.20 : regex plus permissives pour tolérer les erreurs humaines :
   //  - pas d'espace après le numéro (ex: "021555555Textecoller")
   //  - pas d'espace/parenthèse avant un court numéro
@@ -6455,12 +6500,29 @@ function showTooltip(e, iv, rowEl) {
   // v2026.5.19 : pendant qu'un popup épinglé est en cours de drag, on ignore
   // les mouseenter sur les cartes — sinon en survolant une carte on déclenche
   // l'ouverture d'un nouveau tooltip par-dessus ce qu'on est en train de bouger.
-  if (state._popupDragging) return;
+  if (state._popupDragging) {
+    console.log("[showTooltip] ignoré : popup drag en cours");
+    return;
+  }
+
+  // v2026.5.27 : fermer tout popup "soft-unpinned" encore visible (il traîne
+  // parce que la souris était dessus). Dès qu'on survole autre chose, on veut
+  // que seul le popup actuel ou les popups épinglés restent.
+  // v2026.5.34 : le softUnpin ne supprime plus le popup au mouseleave, donc
+  // ici on les supprime explicitement quand un nouveau tooltip démarre.
+  const softUnpinned = document.querySelectorAll(".soft-unpinned");
+  if (softUnpinned.length) {
+    console.log(`[showTooltip] suppression de ${softUnpinned.length} popup(s) soft-unpinned`);
+    softUnpinned.forEach(el => {
+      try { el.remove(); } catch (err) {}
+    });
+  }
 
   // v4.1.15 : si la bulle est épinglée sur une autre iv, on NE REMPLACE PAS
   // son contenu (l'user veut garder la fiche épinglée même en survolant
   // d'autres cartes).
   if (bulleState.pinned && state.currentTooltipIv && state.currentTooltipIv !== iv) {
+    console.log("[showTooltip] ignoré : tooltip épinglé sur une autre iv");
     return;
   }
 
@@ -6647,56 +6709,108 @@ function reapplyTooltipPosition() {
   el.style.top  = ((el._absBasisTop  || 0) + dy) + "px";
 }
 
-function positionTooltipAnchored(rowEl) {
+/**
+ * v2026.5.34 : fonction UNIQUE et unifiée de positionnement ancré du tooltip.
+ *
+ * Utilisée par :
+ *   - showTooltip() — hover d'une row intervention en vue classique
+ *   - openPersistentTimelinePopup() — clic (classique) ou hover (horizontal)
+ *     d'un segment timeline
+ *   - showTooltip() pour les cartes/badges absence
+ *
+ * Algorithme :
+ *   1. Essaie 4 positions dans l'ordre : droite, gauche, dessous, dessus
+ *   2. Chaque position : padding de 8px min par rapport à la source
+ *   3. Chaque position : doit tenir dans la safe area (pas sous topbar/dock)
+ *   4. Chaque position : ne doit pas chevaucher les popups épinglés existants
+ *   5. Première position qui satisfait tout → on la prend
+ *   6. Fallback si aucune ne marche : droite clampée (la moins pire)
+ *
+ * La popup ne couvre JAMAIS la source (pad >= 8px en distance euclidienne).
+ *
+ * @param {HTMLElement} sourceEl - l'élément déclencheur (row, card, segment)
+ * @param {object} opts - options { anchorBelow: true pour préférer dessous }
+ */
+function positionTooltipAnchored(sourceEl, opts) {
+  opts = opts || {};
   const el = tooltipEl();
-  if (!rowEl || !el) return;
-  const pad = 14;
-  const rowRect = rowEl.getBoundingClientRect();
+  if (!el) {
+    console.warn("[positionTooltip] tooltip DOM introuvable");
+    return;
+  }
+  if (!sourceEl) {
+    console.warn("[positionTooltip] sourceEl null — pas de positionnement");
+    return;
+  }
+
+  const pad = 10;                           // padding entre source et popup
+  const viewportMargin = 8;                 // marge par rapport aux bords
+  const srcRect = sourceEl.getBoundingClientRect();
   const tipRect = el.getBoundingClientRect();
-
-  // Position X : à droite de la ligne par défaut
-  let x = rowRect.right + pad;
-  if (x + tipRect.width > window.innerWidth - 8) {
-    x = rowRect.left - tipRect.width - pad;
-  }
-  if (x < 4) x = 4;
-
-  // Position Y : aligné en haut de la ligne
-  let y = rowRect.top;
-  if (y + tipRect.height > window.innerHeight - 8) {
-    y = window.innerHeight - tipRect.height - 8;
-  }
-  if (y < 4) y = 4;
-
-  // v2026.5.17 : éviter le chevauchement avec les popups épinglés existants.
-  // On teste la position candidate, et si elle chevauche un popup épinglé,
-  // on essaie d'autres candidats (gauche de la carte, au-dessous, au-dessus).
-  const tipW = tipRect.width || 320;
+  const tipW = tipRect.width  || 320;       // fallback taille si pas encore rendu
   const tipH = tipRect.height || 200;
-  const pinnedRects = _getPinnedPopupsViewportRects();
-  if (pinnedRects.length) {
-    const candidates = [
-      { x, y, label: "right" },
-      { x: rowRect.left - tipW - pad, y: rowRect.top, label: "left" },
-      { x: rowRect.left, y: rowRect.bottom + pad, label: "below" },
-      { x: rowRect.left, y: rowRect.top - tipH - pad, label: "above" }
-    ];
+
+  // Safe area : respecter topbar en haut, dock en bas
+  const safe = (typeof _getPopupSafeArea === "function")
+    ? _getPopupSafeArea()
+    : { left: viewportMargin, top: viewportMargin,
+        right: window.innerWidth - viewportMargin,
+        bottom: window.innerHeight - viewportMargin };
+
+  // 4 candidats (ordre : droite → gauche → dessous → dessus)
+  //   Préférence opts.anchorBelow = true : dessous en premier (ex: clic timeline)
+  const rightCandidate  = { x: srcRect.right + pad, y: srcRect.top,             label: "droite"  };
+  const leftCandidate   = { x: srcRect.left - tipW - pad, y: srcRect.top,       label: "gauche"  };
+  const belowCandidate  = { x: srcRect.left, y: srcRect.bottom + pad,           label: "dessous" };
+  const aboveCandidate  = { x: srcRect.left, y: srcRect.top - tipH - pad,       label: "dessus"  };
+
+  const candidates = opts.anchorBelow
+    ? [belowCandidate, aboveCandidate, rightCandidate, leftCandidate]
+    : [rightCandidate, leftCandidate, belowCandidate, aboveCandidate];
+
+  const pinnedRects = (typeof _getPinnedPopupsViewportRects === "function")
+    ? _getPinnedPopupsViewportRects()
+    : [];
+
+  let chosen = null;
   for (const c of candidates) {
-      // Borne dans le viewport
-      if (c.x < 4) c.x = 4;
-      if (c.x + tipW > window.innerWidth - 8) c.x = window.innerWidth - tipW - 8;
-      if (c.y < 4) c.y = 4;
-      if (c.y + tipH > window.innerHeight - 8) c.y = window.innerHeight - tipH - 8;
-      const testRect = { left: c.x, top: c.y, right: c.x + tipW, bottom: c.y + tipH };
-      const overlaps = pinnedRects.some(pr => _rectsOverlap(testRect, pr));
-      if (!overlaps) {
-        x = c.x; y = c.y;
+    // Clamp dans la safe area
+    let cx = c.x, cy = c.y;
+    if (cx < safe.left) cx = safe.left;
+    if (cx + tipW > safe.right) cx = safe.right - tipW;
+    if (cx < safe.left) continue; // popup plus large que safe area — skip
+    if (cy < safe.top) cy = safe.top;
+    if (cy + tipH > safe.bottom) cy = safe.bottom - tipH;
+    if (cy < safe.top) continue;
+
+    // Ne chevauche PAS la source (garantit qu'on ne la cache pas)
+    const candRect = { left: cx, top: cy, right: cx + tipW, bottom: cy + tipH };
+    if (_rectsOverlap(candRect, srcRect)) continue;
+
+    // Ne chevauche pas les popups épinglés existants
+    const hitsPinned = pinnedRects.some(pr => _rectsOverlap(candRect, pr));
+    if (hitsPinned) continue;
+
+    chosen = { x: cx, y: cy, label: c.label };
     break;
   }
-    }
+
+  if (!chosen) {
+    // Fallback : droite clampée à tout prix, même si ça chevauche (cas rare
+    // avec écran minuscule ou beaucoup de popups épinglés)
+    let fx = srcRect.right + pad;
+    let fy = srcRect.top;
+    if (fx + tipW > safe.right) fx = safe.right - tipW;
+    if (fx < safe.left) fx = safe.left;
+    if (fy + tipH > safe.bottom) fy = safe.bottom - tipH;
+    if (fy < safe.top) fy = safe.top;
+    chosen = { x: fx, y: fy, label: "fallback" };
+    console.log("[positionTooltip] fallback utilisé (aucun candidat optimal trouvé)");
+  } else {
+    console.log(`[positionTooltip] position choisie : ${chosen.label} (${Math.round(chosen.x)}, ${Math.round(chosen.y)})`);
   }
 
-  setTooltipViewportPosition(x, y);
+  setTooltipViewportPosition(chosen.x, chosen.y);
 }
 
 /**
@@ -6893,13 +7007,60 @@ function pinTooltip() {
     if (closeAllBtn) closeAllBtn.remove();
   }
 
-  // Chercher la ligne source (row iv-v2)
+  // Chercher la ligne source pour le positionnement.
+  // v2026.5.35 : en vue horizontale, les rows .intervention-v2 sont CACHÉES
+  // (display: none via CSS .view-horizontal). getBoundingClientRect d'un
+  // élément caché retourne (0,0,0,0) → popup part en haut à gauche.
+  // Solution : priorité au tooltip actuellement visible (qui EST la vraie
+  // source visuelle du clic/hover). Fallback sur le segment timeline. Enfin
+  // la row (qui marche en vue classique).
   let rowEl = null;
+  const _isHorizontalView = document.documentElement.classList.contains("view-horizontal");
+
+  if (_isHorizontalView) {
+    console.log("[pinTooltip] vue horizontale → source = tooltip visible ou segment timeline");
+    // Priorité 1 : le tooltip actuellement affiché (meilleure source visuelle)
+    const currentTip = tooltipEl();
+    if (currentTip && currentTip.classList.contains("visible")) {
+      const r = currentTip.getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) {
+        rowEl = currentTip;
+        console.log(`[pinTooltip] source = tooltip visible (${Math.round(r.left)}, ${Math.round(r.top)})`);
+      }
+    }
+    // Priorité 2 : segment timeline pour cette actionId
+    if (!rowEl && iv.actionId) {
+      // Il peut y avoir plusieurs .timeline-slot avec le même ivIdx si plusieurs
+      // cartes. On prend celui dont la row parente a le bon actionId.
+      const allSlots = document.querySelectorAll(".timeline-slot[data-iv-idx]");
+      for (const slot of allSlots) {
+        const card = slot.closest(".card");
+        if (!card) continue;
+        const ivIdx = slot.dataset.ivIdx;
+        const row = card.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`);
+        if (row && row.dataset.actionId === iv.actionId) {
+          const r = slot.getBoundingClientRect();
+          if (r.width > 0 && r.height > 0) {
+            rowEl = slot;
+            console.log(`[pinTooltip] source = segment timeline actionId=${iv.actionId}`);
+            break;
+          }
+        }
+      }
+    }
+  } else {
+    // Vue classique : chercher la row .intervention-v2 (comportement d'origine)
     if (iv.actionId) {
       rowEl = document.querySelector(`.intervention-v2[data-action-id="${iv.actionId}"]`);
+      if (rowEl) {
+        console.log(`[pinTooltip] vue classique → source = row intervention-v2`);
       }
+    }
+  }
+
+  // Fallback final : le tooltip live (même s'il n'est pas visible) — position actuelle
   if (!rowEl) {
-    // Fallback : utiliser la position actuelle du tooltip live
+    console.warn("[pinTooltip] aucune source visible trouvée → fallback tooltip live");
     rowEl = srcEl;
   }
 
@@ -6917,6 +7078,49 @@ function pinTooltip() {
   // v2026.5.19 : mémoriser aussi la date pour l'afficher sur la pastille dock
   popup.dataset.originDate = state.currentDate || "";
 
+  // v2026.5.25 : mémoriser aussi lieu + service pour la pastille enrichie
+  try {
+    const info = iv.infobulle || {};
+    const lieuRaw = info.lieu || iv.bulleLieu || "";
+    // Format pour pastille : "VILLE, Adresse" (on extrait les 2 premières parties)
+    const { ville, adresse } = (typeof splitLieu === "function")
+      ? splitLieu(lieuRaw)
+      : { ville: null, adresse: null };
+    let lieuFmt = "";
+    if (ville && adresse) lieuFmt = ville.toUpperCase() + ", " + adresse;
+    else if (adresse) lieuFmt = adresse;
+    else if (ville) lieuFmt = ville.toUpperCase();
+    popup.dataset.lieu = lieuFmt;
+
+    // Service : prendre les 2 dernières parties séparées par "/"
+    // Ex: "AdmCV/DJES/SSCM/SSCM - Admin/TEO - OS" → "SSCM - Admin/TEO - OS"
+    //     "AdmCV/OJV/JPX/JPX Lavaux-Oron" → "JPX/JPX Lavaux-Oron"
+    // v2026.5.26 : dans le DERNIER segment seulement, couper au " - " (espace
+    //              tiret espace) pour retirer les descriptions longues. Les
+    //              noms propres comme "Lavaux-Oron" (sans espaces) sont préservés.
+    //   Ex: "AdmCV/DJES/SSCM/SPOP - Centre administratif" → "SSCM/SPOP"
+    //       "AdmCV/OJV/JPX/JPX Lavaux-Oron" → "JPX/JPX Lavaux-Oron" (inchangé)
+    const serviceRaw = (info.service) || iv.categoryLine || "";
+    if (serviceRaw) {
+      const parts = serviceRaw.split("/").map(s => s.trim()).filter(Boolean);
+      let last2 = parts.slice(-2);
+      // Couper au " - " dans le DERNIER élément de last2
+      if (last2.length > 0) {
+        const lastIdx = last2.length - 1;
+        const lastSeg = last2[lastIdx];
+        const dashIdx = lastSeg.indexOf(" - ");
+        if (dashIdx > 0) {
+          last2[lastIdx] = lastSeg.substring(0, dashIdx).trim();
+        }
+      }
+      popup.dataset.service = last2.join("/");
+    } else {
+      popup.dataset.service = "";
+    }
+  } catch (err) {
+    console.warn("[pin] lieu/service build failed", err);
+  }
+
   // v2026.5.17 : masquer l'icône 📌 du contenu cloné (redondante car le
   // popup a sa propre topbar avec le bouton "désépingler" 📍 explicite)
   const oldPin = popup.querySelector('.tooltip-pinbtn[data-action="pin"]');
@@ -7045,6 +7249,9 @@ function pinTooltip() {
 
   // Enregistrer dans la liste
   pinnedPopups.push({ el: popup, iv: iv, rect: pos.rect });
+  // v2026.5.34 : stocker une référence à l'iv sur l'élément DOM — utilisée
+  // par _softUnpinPopup pour pouvoir ré-épingler via le bouton 📌 restauré.
+  popup._linkedIv = iv;
 
   // v4.3.0 : libérer le tooltip live (il redevient utilisable pour d'autres survols)
   bulleState.pinned = false;
@@ -7108,40 +7315,53 @@ async function _refreshPinnedPopupIv(popup, iv) {
 }
 
 /**
- * Désépinglage "mou" : la popup n'est plus considérée épinglée (elle n'est
- * plus dans pinnedPopups, donc le comptage pour Ctrl×2 etc. ignore) mais on
- * la laisse visible. Elle disparait quand la souris sort.
+ * Désépinglage "mou" (v4.3.3) : transforme un popup épinglé en tooltip simple.
+ *
+ * v2026.5.34 : refonte — le popup ne disparaît PLUS au mouseleave. À la place,
+ * il redevient un tooltip normal avec ses boutons ↻ (Actualiser) et 📌
+ * (Épingler) restaurés dans .tooltip-actions, et reste visible à l'écran
+ * comme un tooltip classique. L'user peut le re-cliquer sur 📌 pour le
+ * ré-épingler, ou cliquer ailleurs pour s'en débarrasser normalement.
+ *
+ * @param {HTMLElement} el - le popup à désépingler
  */
 function _softUnpinPopup(el) {
-  // Retirer de la liste (pour le comptage Ctrl×2) mais garder le DOM
-  const idx = pinnedPopups.findIndex(p => p.el === el);
-  if (idx >= 0) pinnedPopups.splice(idx, 1);
+  if (!el) {
+    console.warn("[softUnpin] elément null — abandon");
+    return;
+  }
+  console.log("[softUnpin] désépinglage du popup", el.dataset.actionId || "(sans actionId)");
 
-  // v4.3.3 corr : basculer visuellement en tooltip normal (retirer tous les
-  // attributs visuels du mode épinglé : bordure bleue, dragbar, bouton ×,
-  // padding-top, etc.). La classe .soft-unpinned fait ça côté CSS.
-  // On retire .pinned-popup pour que les règles visuelles lourdes
-  // disparaissent, tout en gardant la popup au même endroit (position
-  // absolute conservée).
-  el.classList.remove("pinned-popup");
-  el.classList.add("soft-unpinned");
-  // Icône 📌 → 📍 pour le clin d'œil (même si elle va bientôt disparaitre)
-  const pinBtn = el.querySelector('[data-action="pin"]');
-  if (pinBtn) pinBtn.textContent = "📍";
-  // Supprimer les éléments propres au mode épinglé : barre de drag et ×
+  // 1. Retirer de la liste des popups épinglés (pour Ctrl×2 etc.)
+  const idx = pinnedPopups.findIndex(p => p.el === el);
+  if (idx >= 0) {
+    pinnedPopups.splice(idx, 1);
+    console.log(`[softUnpin] retiré de pinnedPopups (reste ${pinnedPopups.length})`);
+  }
+
+  // 2. Reset le flag global bulleState.pinned si plus aucun popup épinglé.
+  //    Sans ça, le tooltip live "croit" toujours qu'il est pinned et son
+  //    handler click (notamment ↻ reload) peut partir en cacahuète.
+  if (pinnedPopups.length === 0) {
+    bulleState.pinned = false;
+  }
+
+  // 3. Retirer les éléments propres au mode épinglé : topbar, dragbar,
+  //    close btn, et classes minimized/reduced.
   const dragbar = el.querySelector(".pinned-popup-dragbar");
   if (dragbar) dragbar.remove();
   const closeBtn = el.querySelector(".pinned-popup-close");
   if (closeBtn) closeBtn.remove();
-  // v2026.5.17 : retirer aussi la nouvelle topbar et le conteneur minimisé
   const topbar = el.querySelector(".pinned-popup-topbar");
   if (topbar) topbar.remove();
   el.classList.remove("pinned-popup-minimized");
   el.classList.remove("pinned-popup-reduced");
 
-  // v2026.5.18 : retirer aussi la pastille du dock si elle existe
+  // 4. Retirer la pastille du dock si elle existe
   if (el._linkedPill) {
-    try { el._linkedPill.remove(); } catch (e) {}
+    try { el._linkedPill.remove(); } catch (e) {
+      console.warn("[softUnpin] erreur remove pill:", e);
+    }
     el._linkedPill = null;
   }
   // Si le dock est vide, le cacher ; mettre à jour le bouton "Fermer tous"
@@ -7154,28 +7374,123 @@ function _softUnpinPopup(el) {
     _ensureDockCloseAllBtn();
   }
 
-  // v2026.5.22 : si le tooltip hover est actuellement affiché pour la même
-  // intervention que celle qu'on désépingle, il faut regénérer son HTML pour
-  // que l'icône passe de 📍 (active rouge) à 📌 (non active) — sinon l'user
-  // voit l'ancienne icône et croit qu'il est toujours épinglé.
+  // 5. Restaurer le bouton 📌 dans .tooltip-actions
+  //    Lors de l'épinglage, ce bouton a été SUPPRIMÉ du DOM (voir pinTooltip
+  //    v2026.5.17 ligne 6921). Il faut le recréer pour que l'user puisse
+  //    ré-épingler ou que l'icône 📌 revienne visible.
+  const actionsEl = el.querySelector('.tooltip-actions');
+  if (actionsEl) {
+    const existingPin = actionsEl.querySelector('.tooltip-pinbtn[data-action="pin"]');
+    if (!existingPin) {
+      console.log("[softUnpin] restauration du bouton 📌 dans .tooltip-actions");
+      const pinBtn = document.createElement('div');
+      pinBtn.className = 'tooltip-actionbtn tooltip-pinbtn';
+      pinBtn.setAttribute('data-action', 'pin');
+      pinBtn.title = 'Épingler la bulle (ou double-Ctrl). Cliquer à nouveau pour libérer.';
+      pinBtn.textContent = '📌';
+      actionsEl.appendChild(pinBtn);
+    } else {
+      console.log("[softUnpin] bouton 📌 déjà présent, mise à jour visuelle");
+      existingPin.textContent = '📌';
+      existingPin.classList.remove('tooltip-pinbtn-active');
+    }
+  } else {
+    console.warn("[softUnpin] .tooltip-actions introuvable dans le popup — boutons pas restaurés");
+  }
+
+  // 5bis. v2026.5.34 : attacher un nouveau handler click sur .tooltip-actions
+  //       du popup soft-unpinned pour ré-épinglement / actualisation.
+  //       L'ancien handler du popup épinglé (qui faisait softUnpin au clic
+  //       sur pin) est encore attaché, mais notre nouveau handler utilise
+  //       stopPropagation avant pour l'empêcher de s'exécuter.
+  //       On garde une référence à l'iv pour pouvoir ré-épingler proprement.
+  const ivForRepin = el._linkedIv || null;
+  if (actionsEl && ivForRepin) {
+    // Retirer d'éventuels handlers précédents en remplaçant l'element
+    const newActions = actionsEl.cloneNode(true);
+    actionsEl.parentNode.replaceChild(newActions, actionsEl);
+
+    newActions.addEventListener("click", (e) => {
+      const btn = e.target.closest('[data-action]');
+      if (!btn) return;
+      const action = btn.dataset.action;
+      e.stopPropagation();
+      e.preventDefault();
+
+      if (action === "pin") {
+        console.log("[softUnpin] clic sur 📌 d'un popup soft-unpinned → ré-épinglage");
+        // Retirer le popup soft-unpinned actuel
+        try { el.remove(); } catch (err) {}
+        // Simuler le survol de l'iv pour rendre le tooltip live, puis épingler
+        state.currentTooltipIv = ivForRepin;
+        pinTooltip();
+      } else if (action === "reload") {
+        console.log("[softUnpin] clic sur ↻ d'un popup soft-unpinned → recharger intervention");
+        if (typeof reloadSingleIntervention === "function") {
+          reloadSingleIntervention(ivForRepin, btn);
+        } else {
+          console.warn("[softUnpin] reloadSingleIntervention indisponible");
+        }
+      }
+    });
+  }
+
+  // 6. Basculer visuellement : retirer pinned-popup, mettre soft-unpinned.
+  //    La classe .soft-unpinned applique les styles "tooltip normal"
+  //    (pas de bordure bleue, pas de padding-top pour topbar disparue, etc.)
+  el.classList.remove("pinned-popup");
+  el.classList.add("soft-unpinned");
+
+  // 7. Régénérer le tooltip hover si on est en train de survoler la même iv
+  //    (pour synchroniser l'icône 📌/📍 dans le tooltip live).
+  //    Aussi, reset iv._reloading qui pourrait rester bloqué à true.
   const tip = tooltipEl();
   if (tip && tip.classList.contains("visible") && state.currentTooltipIv) {
+    try {
+      state.currentTooltipIv._reloading = false;
       tip.innerHTML = buildTooltipHTML(state.currentTooltipIv);
+    } catch (err) {
+      console.warn("[softUnpin] buildTooltipHTML failed:", err);
+    }
   }
 
-  // Helper qui joue l'animation de sortie puis supprime le DOM
-  const animateAndRemove = () => {
+  // 8. v2026.5.34 : ne PAS programmer de suppression automatique au mouseleave.
+  //    Le popup reste visible comme un tooltip normal. L'user le ferme en
+  //    cliquant ailleurs ou en appuyant sur Échap. Il peut aussi re-cliquer
+  //    sur 📌 pour le ré-épingler.
+  //
+  //    Pour que le popup disparaisse quand l'user clique ailleurs, on ajoute
+  //    un handler de clic document qui supprime tous les .soft-unpinned si
+  //    le clic est hors du popup. Ce handler ne s'arme QU'UNE FOIS (au premier
+  //    désépinglage) et reste globalement.
+  _ensureSoftUnpinnedCleanupHandler();
+
+  console.log("[softUnpin] terminé — popup reste visible en mode tooltip normal");
+}
+
+/**
+ * v2026.5.34 : pose un handler global (une seule fois) qui ferme les popups
+ * en état .soft-unpinned quand l'user clique ailleurs, ou appuie sur Échap.
+ */
+let _softUnpinnedCleanupHandlerInstalled = false;
+function _ensureSoftUnpinnedCleanupHandler() {
+  if (_softUnpinnedCleanupHandlerInstalled) return;
+  _softUnpinnedCleanupHandlerInstalled = true;
+
+  // Clic hors d'un popup soft-unpinned → supprimer
+  document.addEventListener("mousedown", (e) => {
+    const softPopups = document.querySelectorAll(".soft-unpinned");
+    if (softPopups.length === 0) return;
+    softPopups.forEach(el => {
+      // Ne pas fermer si le clic est DANS le popup lui-même
+      if (el.contains(e.target)) return;
+      console.log("[softUnpin cleanup] clic hors du popup — suppression");
       el.classList.add("unpinning");
-    setTimeout(() => el.remove(), 180);
-  };
+      setTimeout(() => { try { el.remove(); } catch (err) {} }, 180);
+    });
+  }, true);  // phase capture pour attraper avant d'autres handlers
 
-  if (!el.matches(":hover")) {
-    animateAndRemove();
-    return;
-  }
-  // Souris dessus : on ne supprime pas tout de suite. On attend mouseleave
-  // et à ce moment on joue l'animation de sortie et on supprime.
-  el.addEventListener("mouseleave", animateAndRemove, { once: true });
+  console.log("[softUnpin] handler cleanup global installé");
 }
 
 // ============================================================================
@@ -7281,24 +7596,34 @@ function _reducePinnedPopup(popup) {
 
   // Créer la pastille dock
   // v2026.5.18 : le fond de la pastille prend la couleur de catégorie
-  //   (via la classe color-XXX déjà utilisée ailleurs dans le CSS)
-  // v2026.5.19 : pastille à 2 lignes — ref (gras) + date origine (petit)
+  // v2026.5.25 : pastille à 3 lignes — lieu (fort), service (petit), date (petit)
+  //              La référence est affichée dans le mini-menu au survol.
   const pill = document.createElement("button");
   pill.type = "button";
   pill.className = "pinned-popup-dock-pill color-" + colorKey;
   pill.title = "Cliquer pour agrandir";
 
-  const pillRef = document.createElement("span");
-  pillRef.className = "pinned-popup-dock-pill-ref";
-  pillRef.textContent = label;
-  pill.appendChild(pillRef);
+  // Ligne 1 : lieu (ou ref si pas de lieu)
+  const pillLieu = document.createElement("span");
+  pillLieu.className = "pinned-popup-dock-pill-lieu";
+  pillLieu.textContent = popup.dataset.lieu || label || "—";
+  pill.appendChild(pillLieu);
 
-  // Date d'origine (ex: "21.04")
+  // Ligne 2 : service (2 dernières parties)
+  const serviceTxt = popup.dataset.service || "";
+  if (serviceTxt) {
+    const pillService = document.createElement("span");
+    pillService.className = "pinned-popup-dock-pill-service";
+    pillService.textContent = serviceTxt;
+    pill.appendChild(pillService);
+  }
+
+  // Ligne 3 : date "Mardi 22.04"
   const originDate = popup.dataset.originDate || "";
   if (originDate) {
     const pillDate = document.createElement("span");
     pillDate.className = "pinned-popup-dock-pill-date";
-    pillDate.textContent = _formatDateShort(originDate);
+    pillDate.textContent = _formatDateForPill(originDate);
     pill.appendChild(pillDate);
   }
 
@@ -7317,12 +7642,18 @@ function _reducePinnedPopup(popup) {
   popup._linkedPill = pill;
 
   pill.addEventListener("click", (e) => {
+    // v2026.5.23 : si on était en train de drag, ne pas déclencher le clic
+    if (pill._justDragged) {
+      pill._justDragged = false;
+      return;
+    }
     e.stopPropagation();
     _restorePinnedPopupFromDock(popup);
   });
 
   // v2026.5.20 : mini-menu au survol (Agrandir / Fermer)
   pill.addEventListener("mouseenter", () => {
+    if (pill._dragging) return;  // pas de menu pendant le drag
     _showPillHoverMenu(pill, popup);
   });
   pill.addEventListener("mouseleave", (e) => {
@@ -7330,6 +7661,9 @@ function _reducePinnedPopup(popup) {
     _schedulePillMenuClose();
   });
 
+  // v2026.5.23 : drag & drop — réordonne dans le dock, ou restaure hors du dock
+  _attachPillDragHandler(pill, popup);
+
   dock.appendChild(pill);
   dock.classList.add("visible");
 
@@ -7365,6 +7699,15 @@ function _showPillHoverMenu(pill, popup) {
   menu._linkedPill = pill;
   menu._linkedPopup = popup;
 
+  // v2026.5.25 : REF en haut du menu (info seulement, centrée)
+  const refText = popup.dataset.ref || "";
+  if (refText) {
+    const refLabel = document.createElement("div");
+    refLabel.className = "pill-hover-menu-ref";
+    refLabel.textContent = refText;
+    menu.appendChild(refLabel);
+  }
+
   const restoreBtn = document.createElement("button");
   restoreBtn.type = "button";
   restoreBtn.className = "pill-hover-menu-btn";