feat: partage dirigÃ© entre utilisateurs #196

- create_share/shared_with + validation des destinataires - gate auth sur /s/{token} (+pdf, raw) : 404 opaque hors crÃ©ateur/admin/destinataires - GET /api/shares scopÃ© (non-admin = crÃ©Ã©s + reÃ§us), rÃ©vocation crÃ©ateur/admin - UI : dialogue dirigÃ©/public + destinataires, dashboard Â« partagÃ© par X Â» - i18n FR/EN, tests test_directed_shares.py (9), fiche feature
fix: admin — icône fermeture modale utilisateurs + sections du dashboard affichées une à la fois BUG-111
2026-10-10 20:14:29 -04:00 · 2026-10-10 17:17:14 -04:00 · 2026-10-10 16:42:00 -04:00 · 2026-10-10 16:09:59 -04:00 · 2026-10-10 00:40:35 -04:00 · 2026-10-09 15:48:04 -04:00
50 changed files with 1628 additions and 110 deletions
@@ -44,6 +44,7 @@ test_dir/video/
 test_vault/images/
 test_vault/markdown/
 test_vault/budget.xlsx
+test_home/

 # Tauri updater signing keys (private key — never commit)
 desktop/*.key
@@ -6,7 +6,7 @@ Format basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/),
 et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 > **En cours de développement** : les changements à venir sont listés dans la section
-> [Unreleased](#unreleased). La dernière version livrée est **2.62.0**.
+> [Unreleased](#unreleased). La dernière version livrée est **2.66.0**.

 ---

@@ -14,6 +14,142 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 ---

+## [2.66.0] — 2026-10-10
+
+### Ajouté
+
+- **#196 — Partage dirigé entre utilisateurs**
+  - Un utilisateur peut partager un document à un ou plusieurs comptes
+    précis (champ destinataires dans le dialogue de partage, noms séparés
+    par des virgules) : les pages `/s/{token}` (+ PDF, téléchargement brut)
+    exigent alors une session et n'acceptent que le créateur, les admins et
+    les destinataires — 404 opaque sinon (l'existence d'un token dirigé
+    n'est pas confirmable de l'extérieur).
+  - Dashboard : les partages reçus s'affichent avec « Partagé par X » et
+    s'ouvrent en lecture seule via la page de partage ; pas de bouton
+    révoquer pour un destinataire.
+  - Rétrocompatible : les partages publics existants (sans destinataires)
+    restent accessibles anonymement.
+
+### Sécurité
+
+- **#196 — `GET /api/shares` scopé** : un utilisateur non-admin ne voit plus
+  TOUS les partages de l'instance, mais uniquement ceux qu'il a créés ou
+  reçus (fuite préexistante, intenable avec le partage user-to-user). La
+  révocation d'un partage est réservée à son créateur ou à un admin.
+  - i18n FR/EN (7 nouvelles clés), tests `tests/test_directed_shares.py` (9),
+    fiche `docs/features/directed-shares-196.md`.
+
+---
+
+## [2.65.2] — 2026-10-10
+
+### Corrigé
+
+- **BUG-111 — Admin : icône de fermeture + navigation du tableau de bord**
+  - La modale « Administration — Utilisateurs » ouverte depuis la page `/admin` n'affichait pas l'icône du bouton fermer (lucide absent de `admin.html`) — même version du script UMD que `index.html` ajoutée.
+  - Le tableau de bord admin affiche désormais **une seule section** à la fois (état initial : hash de l'URL ou « Statistiques temps réel ») au lieu des 4 sections empilées.
+
+---
+
+## [2.65.1] — 2026-10-10
+
+---
+
+## [2.65.0] — 2026-10-10
+
+### Ajouté
+
+- **#194 (UI) — Dossier personnel visible dans l'arborescence**
+  - Les vaults `home-<user>` s'affichent **en premier** dans l'arborescence de
+    la barre latérale (tri stable appliqué à la source, `frontend/js/sidebar.js`,
+    donc aussi les sélecteurs de vault).
+  - Icône **maison** lucide (`data-lucide="home"`, même style/`stroke:
+    currentColor` que les autres icônes) via `getVaultIcon()` —
+    `frontend/js/viewer.js`.
+  - `docker-compose.test-win.yml` : montage `test_home:/vaults/Home` +
+    `OBSIGATE_HOME_ROOT=/vaults/Home` pour tester la feature en local
+    (dossier `test_home/` ignoré par git).
+  - Tests : `sidebar-filters.test.mjs` +2 (icône maison pour `home-*`,
+    gemme violette inchangée ailleurs).
+
+### Corrigé
+
+- **#194 — Un dossier perso n'est plus visible par les autres comptes**
+  - `check_vault_access` (`backend/auth/middleware.py`) refuse désormais tout
+    vault `home-*` qui n'est pas **explicitement** octroyé au compte : le
+    `vaults: ["*"]` de l'admin ne couvre plus les dossiers persos (avant,
+    l'admin voyait `home-<user>` de chaque utilisateur dans sa barre latérale).
+  - Les filtres `« * »` écrits en dur dans les routes ont été remplacés par
+    cet appel unique — dashboard, conflits, liens retour, favoris,
+    abonnements push : partout la même règle.
+  - `/api/search` filtre les résultats par vault accessible **avant**
+    pagination (`search_vaults(is_allowed=…)`), sinon les notes personnelles
+    d'un autre pouvait apparaître dans les résultats.
+  - `_grant` octroie désormais le home aussi aux comptes `« * »` : l'admin
+    voit **son** `home-admin`, réparé au démarrage pour les comptes existants.
+  - Tests : `test_user_home.py` +2 (`« * »` sans homes, filtrage de la
+    recherche), assertion API inversée dans `test_auth_api.py`.
+
+---
+
+## [2.64.0] — 2026-10-10
+
+### Ajouté
+
+- **#194 — Dossier personnel par utilisateur**
+  - Chaque utilisateur créé reçoit `<OBSIGATE_HOME_ROOT>/<username>` (ex.
+    `/NFS/OBSIDIAN_DOC/Home/<user>` côté hôte) monté comme un vault propre
+    `home-<user>` : l'isolation utilise l'**ACL par vault existante**
+    (`check_vault_access`), sans nouvelle ACL par chemin.
+  - `backend/user_home.py` : `ensure_user_home()` idempotent (mkdir + registre
+    vault + watcher + octroi dans `user.vaults`), appelé à la création d'un
+    compte (`POST /api/auth/admin/users`) **et** au démarrage
+    (`ensure_all_user_homes()` : migration des users existants + réparation
+    d'un dossier ou d'un registre perdu).
+  - **Registre persistant des vaults dynamiques** `data/vaults.json`
+    (`load_vault_config()` le fusionne avec les env `VAULT_N_*`) : auparavant,
+    tout vault ajouté à la volée (`/api/vaults/add`) disparaissait au premier
+    reindex complet et au redémarrage.
+  - Suppression d'un compte → vault refermé (index/watcher/registre) mais
+    **dossier conservé** (aucune perte de données).
+  - Correctif : `reload_single_vault` remet la config du vault après
+    `remove_vault_from_index` (sinon le vault disparaissait de
+    `vault_config` jusqu'au rechargement complet).
+  - Déploiement : montage unique `/NFS/OBSIDIAN_DOC/Home:/vaults/Home` +
+    variable `OBSIGATE_HOME_ROOT` (fonctionnalité inactive sans cette
+    variable — dev, tests, desktop inchangés).
+  - Tests : `tests/test_user_home.py` (10) + 2 tests API dans
+    `test_auth_api.py` (provisionnement, isolation, retrait).
+
+---
+
+## [2.63.0] — 2026-10-09
+
+### Ajouté
+
+- **#193 — Chat : un post s'affiche comme un document markdown**
+  - Le rendu vient du **serveur** : `backend/file_chat.py` ajoute un champ
+    `html` à chaque message en réutilisant le pipeline des documents
+    (`backend/render.py::_render_markdown` → mistune + wikilinks + masquage des
+    secrets + **sanitizer BUG-021**). Pas de second moteur markdown côté client,
+    donc pas de nouvelle surface XSS.
+  - Titres, listes, tableaux, citations, notes, listes de tâches et **blocs de
+    code colorés** : le front injecte le HTML dans un `.md-content` puis passe
+    `safeHighlight()` (highlight.js + alias de langages) sur chaque `pre code`,
+    exactement comme la visionneuse de documents.
+  - Le `html` est calculé **à la lecture** (et à l'ajout, pour l'écho SSE) :
+    rien n'est persisté dans `data/chats/*.json`, un message reste du texte.
+  - Repli conservé : sans `html`, le texte brut + liens cliquables s'affichent
+    comme avant ; un échec de rendu n'emporte jamais le message.
+  - CSS : `.file-chat-md` annule le `pre-wrap` de la bulle (sinon les retours à
+    la ligne du HTML source devenaient des lignes vides) et compacte
+    `.md-content` (tailles, `pre`/`table` défilants) pour une bulle de chat.
+  - Tests : pytest `TestMarkdownRendering` +7 (54 → **61** dans
+    `test_file_chat.py`), JSDOM `filechat.test.mjs` +2 (25 → **27**).
+
+---
+
 ## [2.62.0] — 2026-10-09

 ### Modifié
@@ -4,7 +4,7 @@

 **Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.

-[![Version](https://img.shields.io/badge/Version-2.62.0-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.66.0-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -222,6 +222,7 @@ Les vaults sont configurées par paires `VAULT_N_NAME` / `VAULT_N_PATH` (N = 1,
 | `VAULT_1_PATH` | Chemin dans le conteneur | `/vaults/Obsidian-RECETTES` |
 | `VAULT_1_ATTACHMENTS_PATH` | Dossier d'attachements (optionnel) | `06_Boite_a_Outils/6.2_Attachments` |
 | `VAULT_1_SCAN_ATTACHMENTS` | Scan d'images au démarrage (défaut : true) | `true` |
+| `OBSIGATE_HOME_ROOT` | Racine des dossiers personnels (un vault `home-<user>` par compte). Absente = fonctionnalité désactivée. | `/vaults/Home` |

 **Règles de nommage :** lettres, chiffres et tirets uniquement ; pas d'espaces ; le nom doit correspondre au chemin dans le conteneur.

@@ -976,8 +977,8 @@ Ce projet est sous licence **MIT** — voir le fichier [LICENSE](LICENSE) pour l

 ## 📝 Changelog

-Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.62.0).
+Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.66.0).

 ---

-*Projet : ObsiGate | Version : 2.62.0 | Dernière mise à jour : Septembre 2026*
+*Projet : ObsiGate | Version : 2.66.0 | Dernière mise à jour : Septembre 2026*
@@ -2,7 +2,7 @@

 **Ultra-light web gateway for your Obsidian vaults** — Access, browse, and search all your Obsidian notes from any device via a modern, responsive web interface.

-[![Version](https://img.shields.io/badge/Version-2.62.0-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.66.0-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -238,6 +238,7 @@ Vaults are configured using pairs of `VAULT_N_NAME` / `VAULT_N_PATH` variables (
 | `VAULT_1_SCAN_ATTACHMENTS` | Enable image scanning on startup (optional, default: true) | `true` |
 | `VAULT_2_NAME` | Display name of the vault | `IT` |
 | `VAULT_2_PATH` | Path inside the container | `/vaults/Obsidian_IT` |
+| `OBSIGATE_HOME_ROOT` | Root folder for per-user home directories (one `home-<user>` vault per account). Unset = feature disabled. | `/vaults/Home` |

 **Naming rules:**
 - Use only letters, numbers, and hyphens
@@ -1151,8 +1152,8 @@ This project is licensed under the **MIT License** - see the [LICENSE](LICENSE)

 ## 📝 Changelog

-See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.62.0).
+See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.66.0).

 ---

-*Project: ObsiGate | Version: 2.62.0 | Last updated: September 2026*
+*Project: ObsiGate | Version: 2.66.0 | Last updated: September 2026*
@@ -1 +1 @@
-2.62.0
+2.66.0
@@ -142,6 +142,11 @@ def require_admin(current_user=Depends(require_auth)):
    return current_user


+def is_home_vault(vault_name: str) -> bool:
+    """Un dossier personnel (#194) : vault « home-<user> »."""
+    return vault_name.startswith("home-")
+
+
 def check_vault_access(vault_name: str, user: dict) -> bool:
    """Check if a user has access to a specific vault.

@@ -149,8 +154,13 @@ def check_vault_access(vault_name: str, user: dict) -> bool:
    - vaults == ["*"] → full access (admin default)
    - vault_name in vaults → access granted
    - otherwise → denied
+
+    #194 : un dossier personnel n'est **jamais** couvert par ``*`` — sinon
+    un admin (``vaults: ["*"]``) verrait le dossier de chaque utilisateur.
    """
    vaults = user.get("_token_vaults") or user.get("vaults", [])
+    if is_home_vault(vault_name):
+        return vault_name in vaults
    if "*" in vaults:
        return True
    return vault_name in vaults
@@ -946,9 +946,20 @@ async def create_user_endpoint(
        user = create_user(
            req.username, req.password, req.role, req.vaults, req.display_name
        )
-        return user
    except ValueError as e:
        raise HTTPException(400, str(e))
+    # #194 : dossier perso — best effort, réparé au démarrage si le disque
+    # (NFS) est indisponible (ensure_user_home journalise l'erreur).
+    from backend.auth.user_store import get_user
+    from backend.user_home import ensure_user_home
+
+    await ensure_user_home(req.username)
+    # La réponse doit refléter l'octroi du vault perso (#194) : create_user a
+    # renvoyé un instantané construit avant l'octroi.
+    fresh = get_user(req.username)
+    if fresh:
+        user["vaults"] = fresh.get("vaults", [])
+    return user


@router.patch("/admin/users/{username}")
@@ -975,9 +986,13 @@ async def delete_user_endpoint(
        raise HTTPException(400, "Impossible de supprimer son propre compte")
    try:
        delete_user(username)
-        return {"message": f"Utilisateur '{username}' supprimé"}
    except ValueError as e:
        raise HTTPException(404, str(e))
+    # #194 : fermer le vault du dossier perso (le dossier est conservé).
+    from backend.user_home import release_user_home
+
+    await release_user_home(username)
+    return {"message": f"Utilisateur '{username}' supprimé"}


 # ── API / MCP tokens (feature #107) ──────────────────────────────────
@@ -29,6 +29,8 @@ from urllib.parse import urljoin, urlparse

 import httpx

+from backend.render import _render_markdown
+
 logger = logging.getLogger("obsigate.file_chat")

 CHAT_DIR = Path("data/chats")
@@ -96,8 +98,28 @@ def _write(file: Path, doc: dict[str, Any]) -> None:


 def get_messages(vault: str, path: str) -> list[dict[str, Any]]:
-    """Return the chat history for *(vault, path)* (chronological)."""
-    return list(_read(vault, path).get("messages", []))
+    """Return the chat history for *(vault, path)* (chronological).
+
+    Every message carries its rendered ``html`` (#193): same markdown pipeline
+    as a document (mistune + sanitizer), computed on read so a template change
+    applies to the whole history without rewriting the JSON store.
+    """
+    return [_decorate(m, vault) for m in _read(vault, path).get("messages", [])]
+
+
+def _decorate(msg: dict[str, Any], vault: str) -> dict[str, Any]:
+    """Return a copy of *msg* with its sanitized markdown ``html`` (#193).
+
+    The stored message is left untouched (``html`` is never persisted). A
+    rendering failure must never break the chat: the message goes out with an
+    empty ``html`` and the client falls back to plain text.
+    """
+    try:
+        html = _render_markdown(msg.get("text", ""), vault)
+    except Exception as e:  # pragma: no cover - defensive
+        logger.warning("chat markdown rendering failed: %s", e)
+        html = ""
+    return {**msg, "html": html}


 def add_message(
@@ -147,7 +169,7 @@ def _append(
            messages = messages[-MAX_MESSAGES:]
        doc["messages"] = messages
        _write(_chat_file(vault, path), doc)
-    return msg
+    return _decorate(msg, vault)  # #193 — le html part avec l'écho SSE


 # --- #192 : accusé de réception ---------------------------------------------
@@ -37,6 +37,12 @@ _last_full_index_ts: str = ""
 # Hook for incremental inverted index updates: called as (action, vault, path, file_info)
 _on_index_change: Callable[..., None] | None = None

+# Registre des vaults ajoutés à la volée (#194) : les env VAULT_N_*/DIR_N_*
+# ne couvrent que le déploiement, tout ce qui est créé à runtime
+# (/api/vaults/add, dossiers perso) vivrait uniquement en mémoire sinon et
+# disparaîtrait au prochain rebuild ou redémarrage.
+DYNAMIC_VAULTS_FILE = Path("data/vaults.json")
+

 def set_index_change_hook(hook):
    """Register a callback for incremental inverted index updates.
@@ -134,7 +140,64 @@ def load_vault_config() -> dict[str, dict[str, Any]]:
        }
        n += 1

-    return vaults
+    # Registre dynamique (#194) : les vaults créés à runtime (dossiers
+    # persos, /api/vaults/add) sont chargés en premier, les env gagnent en
+    # cas de collision de nom (vérité du déploiement).
+    merged = _load_dynamic_vaults()
+    merged.update(vaults)
+    return merged
+
+
+def _load_dynamic_vaults() -> dict[str, dict[str, Any]]:
+    """Read vaults registered at runtime from ``data/vaults.json`` (#194)."""
+    if not DYNAMIC_VAULTS_FILE.exists():
+        return {}
+    try:
+        data = json.loads(DYNAMIC_VAULTS_FILE.read_text(encoding="utf-8"))
+        vaults = data.get("vaults", {})
+        return vaults if isinstance(vaults, dict) else {}
+    except (json.JSONDecodeError, OSError) as e:
+        logger.error(f"Failed to read {DYNAMIC_VAULTS_FILE}: {e}")
+        return {}
+
+
+def _save_dynamic_vaults(vaults: dict[str, dict[str, Any]]) -> None:
+    """Atomic write of the dynamic vault registry (tmp + rename, as users.json)."""
+    try:
+        DYNAMIC_VAULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = DYNAMIC_VAULTS_FILE.with_suffix(".tmp")
+        tmp.write_text(
+            json.dumps({"version": 1, "vaults": vaults}, indent=2, default=str),
+            encoding="utf-8",
+        )
+        os.replace(tmp, DYNAMIC_VAULTS_FILE)
+    except OSError as e:
+        # Le registre est un filet : vault_config mémoire reste valable
+        # jusqu'au prochain rebuild, qui se reparera du dossier manquant.
+        logger.error(f"Failed to write {DYNAMIC_VAULTS_FILE}: {e}")
+
+
+def persist_vault(vault_name: str) -> None:
+    """Persist *vault_name* so it survives rebuild/restart (#194).
+
+    Idempotent. Env-declared vaults are re-added by :func:`load_vault_config`
+    anyway; persisting them too is harmless (single source after merge).
+    """
+    cfg = vault_config.get(vault_name)
+    if not cfg:
+        return
+    vaults = _load_dynamic_vaults()
+    vaults[vault_name] = cfg
+    _save_dynamic_vaults(vaults)
+
+
+def unpersist_vault(vault_name: str) -> None:
+    """Drop *vault_name* from the dynamic registry (#194). No-op if absent."""
+    vaults = _load_dynamic_vaults()
+    if vault_name not in vaults:
+        return
+    vaults.pop(vault_name, None)
+    _save_dynamic_vaults(vaults)



@@ -867,6 +930,10 @@ async def reload_single_vault(vault_name: str) -> dict[str, Any]:

    # Remove old vault data from index structures
    await remove_vault_from_index(vault_name)
+    # remove_vault_from_index a poppé la config : la remettre, sinon le vault
+    # disparaît de vault_config jusqu'au prochain reload complet (#194 — les
+    # vaults dynamiques n'y reviennent que par data/vaults.json).
+    vault_config[vault_name] = config

    # Re-add the vault with updated configuration
    import functools
@@ -364,6 +364,12 @@ async def lifespan(app: FastAPI):
        else:
            logger.info("File watcher disabled by configuration.")

+        # #194 : dossier personnel par utilisateur — réparation/migration
+        # (mkdir manquant, registre perdu, user créé hors API). Après le
+        # watcher pour que les vaults ajoutés soient surveillés.
+        from backend.user_home import ensure_all_user_homes
+        await ensure_all_user_homes()
+
        logger.info("Background startup complete.")

    asyncio.create_task(_background_startup())
@@ -13,7 +13,7 @@ from typing import Any
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field

-from backend.auth.middleware import require_auth
+from backend.auth.middleware import check_vault_access, require_auth

 logger = logging.getLogger("obsigate.push")

@@ -167,9 +167,9 @@ async def subscribe_push(
    """Subscribe to push notifications for a vault."""
    username = current_user.get("username", "unknown")
    
-    # Check if user has access to this vault
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
-    if "*" not in user_vaults and request.vault not in user_vaults:
+    # Check if user has access to this vault (#194 : "*" n'inclut pas les
+    # dossiers persos, check_vault_access est la source unique).
+    if not check_vault_access(request.vault, current_user):
        raise HTTPException(status_code=403, detail="No access to this vault")
    
    # Check if subscription already exists
@@ -24,7 +24,7 @@ from pathlib import Path
 from fastapi import APIRouter, Body, Depends, HTTPException, Query

 from backend.ai import PROVIDERS, _read_ai_keys, get_ai_key
-from backend.auth.middleware import require_admin, require_auth
+from backend.auth.middleware import check_vault_access, require_admin, require_auth
 from backend.indexer import index
 from backend.media_types import IMAGE_EXTENSIONS
 from backend.schemas import (
@@ -495,14 +495,13 @@ async def api_diagnostics(current_user=Depends(require_admin)):
@router.get("/api/dashboard", response_model=DashboardResponse)
 async def api_dashboard(current_user=Depends(require_auth)):
    """Aggregated dashboard statistics across all accessible vaults."""
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
    vault_stats = []
    total_files = 0
    total_tags = set()
    total_size = 0
    total_images = 0
    for vname, vdata in index.items():
-        if "*" not in user_vaults and vname not in user_vaults:
+        if not check_vault_access(vname, current_user):
            continue
        files = vdata.get("files", [])
        fc = len(files)
@@ -31,10 +31,9 @@ router = APIRouter(tags=["conflicts"])
@router.get("/api/conflicts", response_model=ConflictsResponse)
 async def api_conflicts(current_user=Depends(require_auth)):
    """List sync-conflict files across accessible vaults."""
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
    all_conflicts = get_conflicts()
-    if "*" not in user_vaults:
-        all_conflicts = [c for c in all_conflicts if c["vault"] in user_vaults]
+    # #194 : filtrage via check_vault_access ("*" n'inclut pas les homes).
+    all_conflicts = [c for c in all_conflicts if check_vault_access(c["vault"], current_user)]
    return {"conflicts": all_conflicts, "total": len(all_conflicts)}


@@ -166,12 +166,11 @@ async def api_file_backlinks(
    if not vault_data:
        raise HTTPException(status_code=404, detail=f"Vault '{vault_name}' not found")

-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
    backlinks = get_backlinks(vault_name, path)

-    # Filter by user-accessible vaults
-    if "*" not in user_vaults:
-        backlinks = [b for b in backlinks if b["vault"] in user_vaults]
+    # Filter by user-accessible vaults (#194 : check_vault_access, "*" sans
+    # les dossiers persos).
+    backlinks = [b for b in backlinks if check_vault_access(b["vault"], current_user)]

    return {
        "vault": vault_name,
@@ -59,7 +59,6 @@ async def api_recent(limit: int | None = Query(None), vault: str | None = Query(
@router.get("/api/bookmarks", response_model=BookmarksResponse)
 async def api_bookmarks(vault: str | None = Query(None), current_user=Depends(require_auth)):
    username = current_user.get("username")
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])

    if not username:
        return {"files": []}
@@ -68,7 +67,8 @@ async def api_bookmarks(vault: str | None = Query(None), current_user=Depends(re
    files_resp = []
    for item in history:
        v_name = item["vault"]
-        if "*" not in user_vaults and v_name not in user_vaults:
+        # #194 : check_vault_access — "*" n'inclut pas les dossiers persos.
+        if not check_vault_access(v_name, current_user):
            continue

        # Find in index to get metadata
@@ -82,7 +82,12 @@ async def api_search(
    # paginate in the shared service so routes and tools share the same logic.
    return await loop.run_in_executor(
        get_search_executor(),
-        partial(search_vaults, q, vault, tag, limit, offset),
+        # #194 : filtre par vault accessible AVANT pagination ("*" sans les
+        # dossiers persos) — sinon un user voyait les notes des autres.
+        partial(
+            search_vaults, q, vault, tag, limit, offset,
+            is_allowed=lambda v: check_vault_access(v, current_user),
+        ),
    )


@@ -24,7 +24,8 @@ import frontmatter
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, Request
 from fastapi.responses import FileResponse, HTMLResponse, Response

-from backend.auth.middleware import check_vault_access, require_auth
+from backend.auth.middleware import check_vault_access, get_current_user, require_auth
+from backend.auth.user_store import get_user
 from backend.indexer import get_vault_data, parse_markdown_file, update_single_file
 from backend.render import _render_markdown
 from backend.schemas import ShareModel, StatusResponse
@@ -53,6 +54,27 @@ except Exception:  # pragma: no cover - WeasyPrint/GTK missing
 router = APIRouter(tags=["sharing"])


+def _gate_share(share: dict | None, user: dict | None) -> dict:
+    """#196 — directed shares: auth + membership check for ``/s/*`` pages.
+
+    Public share (``shared_with`` empty) → pass-through, no auth required.
+    Directed share → requires an authenticated user who is the creator, an
+    admin, or listed in ``shared_with``. Anything else answers **404** (never
+    403) so an outsider cannot learn that a token exists.
+    """
+    if share is None:
+        raise HTTPException(404, "Share not found or expired")
+    recipients = share.get("shared_with") or []
+    if not recipients:
+        return share
+    if user is None:
+        raise HTTPException(404, "Share not found or expired")
+    if user["username"] == share.get("created_by") or user.get("role") == "admin" \
+            or user["username"] in recipients:
+        return share
+    raise HTTPException(404, "Share not found or expired")
+
+
@router.post("/api/share/{vault_name}", response_model=ShareModel)
 async def api_share_create(
    vault_name: str,
@@ -68,7 +90,14 @@ async def api_share_create(
        raise HTTPException(403, f"Accès refusé à la vault '{vault_name}'")
    path = body.get("path", "")
    expires = body.get("expires_in_hours")
-    share = create_share(vault_name, path, current_user["username"], expires)
+    # #196 — directed share: validate recipients before creating anything.
+    recipients = body.get("shared_with") or []
+    if not isinstance(recipients, list):
+        raise HTTPException(400, "shared_with doit être une liste d'utilisateurs")
+    for name in recipients:
+        if not isinstance(name, str) or not get_user(name):
+            raise HTTPException(400, f"Utilisateur inconnu : {name}")
+    share = create_share(vault_name, path, current_user["username"], expires, recipients)
    share["url"] = f"/s/{share['token']}"

    # Set publish: true in the file's frontmatter
@@ -94,8 +123,13 @@ async def api_share_create(

@router.get("/api/shares", response_model=list[ShareModel])
 async def api_shares_list(vault: str | None = Query(None), current_user=Depends(require_auth)):
-    """List all shares (optionally filtered by vault)."""
-    shares = list_shares(vault)
+    """List shares (optionally filtered by vault).
+
+    #196 : un non-admin ne voit que SES partages (créés ou reçus) ; un admin
+    voit tout (comportement historique).
+    """
+    username = None if current_user.get("role") == "admin" else current_user["username"]
+    shares = list_shares(vault, username)
    for s in shares:
        s["url"] = f"/s/{s['token']}"
    return shares
@@ -103,6 +137,12 @@ async def api_shares_list(vault: str | None = Query(None), current_user=Depends(

@router.delete("/api/share/{share_id}", response_model=StatusResponse)
 async def api_share_revoke(share_id: str, current_user=Depends(require_auth)):
+    # #196 — only the creator or an admin may revoke; a recipient cannot.
+    from backend.share import _read
+    share = _read()["shares"].get(share_id)
+    if share and current_user.get("role") != "admin" \
+            and share.get("created_by") != current_user["username"]:
+        raise HTTPException(403, "Seul le créateur du partage peut le révoquer")
    if not revoke_share(share_id):
        raise HTTPException(404, "Share not found")
    return {"status": "revoked"}
@@ -113,13 +153,12 @@ async def api_share_revoke(share_id: str, current_user=Depends(require_auth)):
    response_class=Response,
    responses={200: {"content": {"application/pdf": {}}, "description": "Shared document as PDF"}},
 )
-async def public_share_pdf_download(token: str):
+async def public_share_pdf_download(token: str, current_user=Depends(get_current_user)):
    """Download shared document as real PDF via WeasyPrint."""
    if generate_pdf is None:
        raise HTTPException(501, "PDF export unavailable (WeasyPrint/GTK not available)")
    share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
    vault_data = get_vault_data(share["vault"])
    if not vault_data:
        raise HTTPException(404, "Vault not found")
@@ -147,11 +186,10 @@ async def public_share_pdf_download(token: str):


@router.get("/s/{token}/raw", response_class=FileResponse)
-async def public_share_raw(token: str):
+async def public_share_raw(token: str, current_user=Depends(get_current_user)):
    """Download the raw (original) shared document."""
    share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
    vault_data = get_vault_data(share["vault"])
    if not vault_data:
        raise HTTPException(404, "Vault not found")
@@ -164,13 +202,12 @@ async def public_share_raw(token: str):


@router.get("/s/{token}", response_class=HTMLResponse)
-async def public_share_view(request: Request, token: str):
-    """Public share view — no authentication required."""
+async def public_share_view(request: Request, token: str, current_user=Depends(get_current_user)):
+    """Public share view — no authentication required (unless directed #196)."""
    from backend.csp import inject_csp_nonce

    share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
    vault_data = get_vault_data(share["vault"])
    if not vault_data:
        raise HTTPException(404, "Vault not found")
@@ -55,6 +55,11 @@ async def api_add_vault(body: dict = Body(...), current_user=Depends(require_adm

    stats = await add_vault_to_index(name, vault_path)

+    # #194 : persister, sinon ce vault disparaît au prochain rebuild/redémarrage.
+    from backend.indexer import persist_vault
+
+    persist_vault(name)
+
    # Start watching the new vault
    watcher = get_watcher()
    if watcher:
@@ -80,6 +85,10 @@ async def api_remove_vault(vault_name: str, current_user=Depends(require_admin))
        await watcher.remove_vault(vault_name)

    await remove_vault_from_index(vault_name)
+    # #194 : plus de trace au redémarrage (les vaults d'env, eux, reviennent).
+    from backend.indexer import unpersist_vault
+
+    unpersist_vault(vault_name)
    await sse_manager.broadcast("vault_removed", {"vault": vault_name})
    return {"status": "ok", "vault": vault_name}

@@ -166,6 +166,13 @@ class ChatMessageItem(BaseModel):
        default=None,
        description="Link preview card {url, title, description, image, site} (#191)",
    )
+    html: str = Field(
+        default="",
+        description=(
+            "Rendered (mistune + sanitized) HTML of ``text``, like a document "
+            "preview — tables, lists, fenced code blocks (#193)"
+        ),
+    )


 class ChatHistoryResponse(BaseModel):
@@ -1049,6 +1056,7 @@ class ShareModel(BaseModel):
    expires_at: str | None = None
    access_count: int = 0
    last_accessed: str | None = None
+    shared_with: list[str] = Field(default_factory=list, description="#196 destinataires (partage dirigé)")


 class ConflictEntry(BaseModel):
@@ -12,6 +12,7 @@ import time
 from datetime import datetime
 from typing import Any

+from backend.auth.middleware import is_home_vault
 from backend.history import get_recent_opened, is_bookmarked
 from backend.indexer import find_file_in_index, index

@@ -31,6 +32,10 @@ def humanize_mtime(mtime: float) -> str:


 def _can_access(vault: str, user_vaults: list[str]) -> bool:
+    # #194 : un dossier perso ne bénéficie jamais de "*" (même règle que
+    # backend.auth.middleware.check_vault_access).
+    if is_home_vault(vault):
+        return vault in user_vaults
    return "*" in user_vaults or vault in user_vaults


@@ -2,6 +2,7 @@

 from __future__ import annotations

+from collections.abc import Callable
 from typing import Any


@@ -11,15 +12,19 @@ def search_vaults(
    tag: str | None = None,
    limit: int = 50,
    offset: int = 0,
+    is_allowed: Callable[[str], bool] | None = None,
 ) -> dict[str, Any]:
    """Full-text search with pagination, returned as the API response payload.

-    No permission filtering is applied here: callers that need it (the tool
-    layer) filter the ``results`` list themselves.
+    ``is_allowed`` (#194) filters the raw hits **before** pagination, so a
+    restricted vault set neither distorts ``total`` nor the returned page.
+    The tool layer filters on its own and leaves it as ``None``.
    """
    from backend.search import search

    all_results = search(q, vault_filter=vault, tag_filter=tag)
+    if is_allowed is not None:
+        all_results = [r for r in all_results if is_allowed(r.get("vault", ""))]
    total = len(all_results)
    page = all_results[offset: offset + limit]
    return {
@@ -44,8 +44,14 @@ def create_share(
    path: str,
    created_by: str,
    expires_in_hours: int | None = None,
+    shared_with: list[str] | None = None,
 ) -> dict:
-    """Create a new share token for a document."""
+    """Create a new share token for a document.
+
+    ``shared_with`` non vide (#196) : partage **dirigé** — la page ``/s/…``
+    exige alors une session et n'accepte que les destinataires listés (plus
+    le créateur et les admins). Vide/absent : comportement public inchangé.
+    """
    with _lock:
        data = _read()
        token = secrets.token_hex(32)  # 64-char hex token
@@ -64,6 +70,7 @@ def create_share(
            "expires_at": expires_at,
            "access_count": 0,
            "last_accessed": None,
+            "shared_with": list(shared_with) if shared_with else [],
        }
        data["shares"][token] = share
        _write(data)
@@ -107,10 +114,17 @@ def revoke_share(share_id: str) -> bool:
    return False


-def list_shares(vault_filter: str | None = None) -> list:
-    """List all shares, optionally filtered by vault."""
+def list_shares(vault_filter: str | None = None, user: str | None = None) -> list:
+    """List shares, optionally filtered by vault and/or requesting user.
+
+    #196 : un non-admin ne voit que les partages qu'il a créés **ou** qui lui
+    sont dirigés. Un admin voit tout. ``user=None`` (anciens appels, tests
+    unitaires) conserve l'ancien comportement : tout lister.
+    """
    data = _read()
    shares = list(data["shares"].values())
+    if user is not None:
+        shares = [s for s in shares if user in (s.get("created_by"), *(s.get("shared_with") or []))]
    if vault_filter:
        shares = [s for s in shares if s["vault"] == vault_filter]
    # Most recent first
@@ -0,0 +1,169 @@
+"""Dossier personnel par utilisateur (#194).
+
+Chaque utilisateur reçoit ``<OBSIGATE_HOME_ROOT>/<username>`` monté comme un
+vault propre ``home-<username>`` : l'isolation profite de l'ACL par vault
+déjà en place (``check_vault_access``), aucune ACL par chemin à inventer.
+
+Tout est idempotent (``ensure_user_home``) pour être rappelé à la création
+d'un compte ET au démarrage : un dossier supprimé, un registre perdu ou un
+user créé hors API se réparent au boot.
+
+La fonctionnalité est inactive tant que ``OBSIGATE_HOME_ROOT`` n'est pas
+défini (dev, tests, desktop) — comportement inchangé.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from pathlib import Path
+
+logger = logging.getLogger("obsigate.user_home")
+
+# Même grammaire que CreateUserRequest.username_valid (backend/auth/router.py) :
+# segment de chemin sûr, déjà passé par la validation de l'API. Re-vérifié ici
+# car le nom sert à construire un chemin (défense en profondeur).
+_USERNAME_RE = re.compile(r"^[a-zA-Z0-9_-]{2,32}$")
+
+
+def home_root() -> Path | None:
+    """Racine des dossiers persos, ou ``None`` si la fonctionnalité est inactive."""
+    root = os.environ.get("OBSIGATE_HOME_ROOT", "").strip()
+    return Path(root) if root else None
+
+
+def home_vault_name(username: str) -> str:
+    """Nom de vault du dossier perso — pas de ``/`` ni ``::`` (segment d'URL, clé d'index)."""
+    return f"home-{username}"
+
+
+async def ensure_user_home(username: str) -> str | None:
+    """Crée (si besoin) le dossier perso de *username*, son vault et son octroi.
+
+    Retourne le nom de vault, ou ``None`` si désactivé / nom invalide /
+    erreur disque (journalisée, réparée au prochain démarrage).
+    """
+    root = home_root()
+    if root is None:
+        return None
+    if not _USERNAME_RE.match(username):
+        logger.warning(f"Home folder skipped: invalid username {username!r}")
+        return None
+
+    home = root / username
+    try:
+        home.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        logger.exception(f"Cannot create home folder {home} for user '{username}'")
+        return None
+
+    name = home_vault_name(username)
+    try:
+        from backend.indexer import add_vault_to_index, index, persist_vault, vault_config
+        from backend.sse import sse_manager
+
+        vault_path = str(home)
+        if name not in index:
+            await add_vault_to_index(name, vault_path)
+            persist_vault(name)
+            from backend.watcher_state import get_watcher
+
+            watcher = get_watcher()
+            if watcher:
+                await watcher.add_vault(name, vault_path)
+            await sse_manager.broadcast("vault_added", {"vault": name})
+            logger.info(f"Home vault '{name}' registered at {vault_path}")
+        elif name not in vault_config:
+            vault_config[name] = {"path": vault_path, "attachmentsPath": None,
+                                  "scanAttachmentsOnStartup": True}
+    except Exception:
+        logger.exception(f"Cannot register home vault '{name}' for user '{username}'")
+        return None
+
+    _grant(username, name)
+    return name
+
+
+async def release_user_home(username: str) -> None:
+    """Retire le vault du dossier perso à la suppression du compte (#194).
+
+    Le dossier sur disque est **conservé** (décision produit : pas de perte
+    de données) ; seul l'index, le watcher et le registre le referment.
+    """
+    name = home_vault_name(username)
+    try:
+        from backend.indexer import index, remove_vault_from_index, unpersist_vault
+
+        unpersist_vault(name)
+        if name not in index:
+            return
+        await remove_vault_from_index(name)
+        from backend.sse import sse_manager
+        from backend.watcher_state import get_watcher
+
+        watcher = get_watcher()
+        if watcher:
+            await watcher.remove_vault(name)
+        await sse_manager.broadcast("vault_removed", {"vault": name})
+        logger.info(f"Home vault '{name}' released (folder kept)")
+    except Exception:
+        logger.exception(f"Cannot release home vault '{name}'")
+
+
+def _grant(username: str, vault_name: str) -> None:
+    """Ajoute le vault à ``user.vaults`` s'il n'y est pas déjà (#194).
+
+    L'octroi est explicite même pour un admin (``vaults: ["*"]``) : ``*`` ne
+    couvre jamais un dossier perso (voir ``check_vault_access``).
+    """
+    from backend.auth.user_store import get_user, update_user
+
+    user = get_user(username)
+    if not user:
+        return  # créé hors API (bootstrap avant users.json) → réparé au boot suivant
+    vaults = user.get("vaults") or []
+    if vault_name in vaults:
+        return
+    update_user(username, {"vaults": [*vaults, vault_name]})
+
+
+async def ensure_all_user_homes() -> int:
+    """Passe de réparation/migration au démarrage : un home par user existant.
+
+    Balaye aussi les vaults orphelins (compte supprimé hors route, ex.
+    ``create_admin.py delete``) : ils sont refermés, dossier conservé.
+    """
+    from backend.auth.user_store import get_all_users
+    from backend.indexer import index, vault_config
+
+    root = home_root()
+    if root is None:
+        return 0
+    users = get_all_users()
+    usernames = {u.get("username") for u in users}
+    created = 0
+    for user in users:
+        username = user.get("username")
+        if not username:
+            continue
+        if await ensure_user_home(username):
+            created += 1
+    if created:
+        logger.info(f"User home folders ensured for {created} user(s)")
+
+    # Orphelins : vault home-<x> toujours indexé mais <x> n'existe plus.
+    # Path.parent == root → on ne touche qu'aux dossiers sous la racine Home,
+    # jamais à un vault admin nommé « home-… » par ailleurs.
+    for name in list(index):
+        if not name.startswith("home-"):
+            continue
+        owner = name[len("home-"):]
+        if owner in usernames:
+            continue
+        cfg_path = Path((vault_config.get(name) or {}).get("path", ""))
+        if cfg_path.parent != root:
+            continue
+        logger.warning(f"Orphan home vault '{name}' released (user deleted?)")
+        await release_user_home(owner)
+    return created
@@ -2626,7 +2626,7 @@ dependencies = [

 [[package]]
 name = "obsigate-desktop"
-version = "2.62.0"
+version = "2.66.0"
 dependencies = [
 "chrono",
 "env_logger",
@@ -1,6 +1,6 @@
 [package]
 name = "obsigate-desktop"
-version = "2.62.0"
+version = "2.66.0"
 description = "ObsiGate Desktop — Porte d'entrée native pour vos vaults Obsidian"
 authors = ["Bruno Charest"]
 edition = "2021"
@@ -1,7 +1,7 @@
 {
  "$schema": "https://raw.githubusercontent.com/nicedoc/obsigate/main/desktop/tauri.conf.schema.json",
  "productName": "ObsiGate",
-  "version": "2.62.0",
+  "version": "2.66.0",
  "identifier": "com.obsigate.desktop",
  "build": {
    "frontendDist": "../frontend",
@@ -21,12 +21,17 @@ services:
    volumes:
      - /c/dev/git/python/ObsiGate/test_vault:/vaults/TestVault
      - /c/dev/git/python/ObsiGate/test_dir:/vaults/TestDir
+      # #194 : racine des dossiers persos — UN seul montage pour tous les
+      # utilisateurs (dossier hôte : mkdir test_home à côté du dépôt).
+      - /c/dev/git/python/ObsiGate/test_home:/vaults/Home
      - obsigate_data:/app/data
    environment:
      - VAULT_1_NAME=TestVault
      - VAULT_1_PATH=/vaults/TestVault
      - DIR_1_NAME=TestDir
      - DIR_1_PATH=/vaults/TestDir
+      # #194 : dossier personnel par utilisateur = <racine>/home-<user>
+      - OBSIGATE_HOME_ROOT=/vaults/Home
      - OBSIGATE_AUTH_ENABLED=true
      - OBSIGATE_ADMIN_USER=admin
      - OBSIGATE_ADMIN_PASSWORD=test123
@@ -36,6 +36,9 @@ services:
      - /NFS/OBSIDIAN_DOC/Obsidian_WORKOUT:/vaults/Obsidian_WORKOUT
      - /NFS/OBSIDIAN_DOC/SessionsManager:/vaults/SessionsManager
      - /home/bruno:/vaults/bruno
+      # #194 : racine des dossiers perso — UN seul montage pour tous les
+      # utilisateurs (un montage par user demanderait un redémarrage).
+      - /NFS/OBSIDIAN_DOC/Home:/vaults/Home
      - /DOCKER_CONFIG/ObsiGate/data:/app/data
    environment:
      - VAULT_1_NAME=Recettes
@@ -50,6 +53,8 @@ services:
      - VAULT_5_PATH=/vaults/SessionsManager
      - DIR_1_NAME=Bruno
      - DIR_1_PATH=/vaults/bruno
+      # #194 : dossier personnel par utilisateur = <racine>/home-<user>
+      - OBSIGATE_HOME_ROOT=/vaults/Home
      - OBSIGATE_AUTH_ENABLED=true
      - OBSIGATE_ADMIN_USER=admin
      # OBSIGATE_ADMIN_PASSWORD → .env
@@ -217,6 +217,7 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | *BUG-107* | Drag & drop de fichiers depuis l'Explorateur inutilisable sur desktop : Tauri/wry pose son propre `IDropTarget` par-dessus de celui du WebView2 et aucun événement natif n'est écouté — #89 ne fonctionnait que sur le web | 🟢 corrigé | P1 | 🖥️ desktop | IA | `desktop/tauri.conf.json` (`create: false`), `desktop/src/main.rs` (`WebviewWindowBuilder::…disable_drag_drop_handler`) | App desktop : glisser un fichier de l'Explorateur sur la fenêtre → aucun survol, aucun dépôt — les gestionnaires HTML5 de `dragdrop.js` ne sont jamais déclenchés | Création manuelle de la fenêtre avec `disable_drag_drop_handler()` (doc Tauri : « required to use HTML5 drag and drop APIs on the frontend on Windows ») ; `create: false` évite la double création par la boucle Tauri | `cargo test` 26 passed (nouveau garde-fou `test_window_created_without_tauri_drag_drop_handler` : les deux marqueurs obligatoires) + lancement OK (fenêtre unique, boot normal) ; dépôt réel à valider par l'utilisateur |
 | *BUG-108* | Tableur : le « Coller » du menu contextuel ne fait rien (copier-coller par menu muet) | 🟢 corrigé | P1 | 📱 frontend | IA | `frontend/js/xlsx/context-menu.js` (`closeContextMenu`) | Ouvrir un `.xlsx`, clic droit « Copier » sur une plage, clic droit cible puis « Coller » → rien n'est collé (le menu se ferme sans action) | `closeContextMenu()` retirait le nœud du DOM **avant** de remettre `_menu` à `null` : retirer le menu qui tient le focus émet `focusout` en synchrone, qui rappelle `closeContextMenu()` → second `remove()` sur un nœud déjà démonté → `NotFoundError` qui avorte le handler de l'action « Coller » du viewer. Introduit par #179 (fermeture au focus). Correctif : `_menu = null` avant `menu.remove()` | Reproduit en local sur HEAD (e2e « coller une plage » : attendu `Date`, obtenu la valeur datée) puis vert après fix : E2E `-g "coller une plage"` 1/1, `xlsx-menus` 11/11, `ai-quick-actions` 13/13 |
 | *BUG-109* | Chat : dans la tuile d'une URL (link preview) l'image ne s'affiche jamais | 🟢 corrigé | P2 | ⚙️ backend | IA | `backend/file_chat.py` (`build_preview`, `_proxy_image`) | Poster une URL avec `og:image` dans le chat général → la carte s'affiche mais sans vignette (console : `Refused to load the image … Content Security Policy`) | La CSP de réponse (`img-src 'self' data: blob:`) interdit toute image externe, et les `og:image` **relatives** étaient résolues contre l'origine d'ObsiGate (404). La vignette est désormais **téléversée à l'envoi** dans `chat_uploads` et servie same-origin (`/api/chat/attachment/<uuid>`) : résolution `urljoin` contre la page, garde SSRF réutilisée, plafond 2 Mo, allow-list d'extensions ; échec du téléchargement → carte conservée sans vignette (jamais de message perdu) | Tests `test_preview_image_is_proxied_same_origin` + `test_preview_image_failure_keeps_the_card` (contre-preuve : proxy neutralisé → `image == ""`). Cartes antérieures inchangées : leur URL distante était déjà bloquée |
+| *BUG-111* | Admin : modale « Administration — Utilisateurs » sans icône de fermeture (lucide absent de admin.html) et tableau de bord admin affichant toutes les sections au lieu de la seule section sélectionnée | 2026-10-10 | Utilisateur | `frontend/admin.html` (ajout du script lucide UMD) + `frontend/js/admin.js` (`_wireSectionNav` : show/hide au lieu du scrollspy) ; suites frontend + backend vertes, vérifié sur instance locale 2020 | lucide n'était chargé que dans index.html ; le scrollspy laissait les 4 sections visibles |
 | *BUG-110* | Chat : refonte visuelle des posts — boutons discrets sous l'image, image ouverte dans un onglet de l'app, point de non-lus sur l'icône chat, notification OS hors focus, annulation **réelle** d'une suppression | 🟢 corrigé | P2 | 📱 frontend | IA | `frontend/js/filechat.js`, `frontend/js/ui.js`, `frontend/js/viewer.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/frontend/filechat.test.mjs` | Clic sur une image du chat → ouverture dans un onglet du navigateur au lieu du visualiseur de l'app ; boutons de pièce jointe bavards (icône + libellé) ; aucun repère visuel persistant sur l'icône chat ; aucune alerte OS quand l'app est en arrière-plan ; le bouton « Annuler » d'une suppression ne restaurait rien (copie DOM d'un message déjà supprimé côté serveur) | `TabManager.openChatImage()` (+ branche `chatImage` de `activate()`, `renderImageViewer()` accepte une `url` directe) ouvre la pièce jointe dans un **onglet** avec le visualiseur des images de vault (zoom/pan/plein écran) ; boutons **icônes seules** (24 px, `aria-label`) sous l'image, alignés à droite ; **point rouge pulsant** (`.chat-has-unread`) tant qu'il reste des non-lus, en plus du badge chiffré ; `_notifyNewMessage()` — notification OS si `document.hidden`/hors focus, permission demandée à l'ouverture du chat ; suppression **différée de 10 s** (ligne « Ce message a été supprimé » + « Annuler », DELETE envoyé à l'échéance seulement, échec réseau → le message revient) | Vérifié : `filechat.test.mjs` 25/25 (dont 6 tests #110), `validate-imports` 42 modules / 372 exports 0 erreur, `unit.test.mjs` 13/13 |
 |  | | | | | | | | | |
 ### TODOs techniques (améliorations / nouvelles tâches)
@@ -335,8 +336,17 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | 2026-10-08 | #190 | Fonctionnalité | `backend/file_chat.py`, `backend/routers/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js` (réécrit), `frontend/js/viewer.js`, `frontend/js/config.js`, `frontend/js/sidebar.js`, `frontend/js/app.js`, `frontend/index.html`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/ROADMAP.md`, `CHANGELOG.md` | **#190 — chat : suivi du document, chat général en onglet sidebar, onglets au-dessus du filtre** : (A) l'en-tête du panneau affiche le document ciblé (titre + chemin) et `followFileChat()` appelé par `renderFile()` re-cible le panneau ouvert à chaque changement de document ; (B) onglet **Chat** (dernier) → conversation générale stockée dans le même store #169 via les sentinelles `__global__/general` (`GET/POST /api/chat`), **pastille de messages non lus** (`localStorage` + badge sur l'onglet), **pièces jointes image/vidéo** (`POST /api/chat/upload` : allow-list d'extensions, 25 MB, nom UUID — jamais le nom client ; `GET /api/chat/attachment/{name}` résolu contre l'allow-list), **URL cliquables** dans le rendu (linkification `http(s)://`), date/heure d'envoi ; (C) barre de filtre **déplacée sous les onglets** et routée vers `filterChatMessages()` (texte + auteur) quand l'onglet Chat est actif. Transport : broadcast SSE `chat_message` réutilisé (vault `__global__` route vers le panneau sidebar, sinon panneau fichier) — pas de second WebSocket. Contre-preuves : `__global__` non routé → test « routes __global__ » échoue ; panneau sans classe `active` → le message part en toast au lieu du rendu (révélé par le stub JSDOM). Vérifié : pytest **1655 passed / 2 skipped** (27 tests chat dont 12 nouveaux), ruff 0, mypy 0 (113 fichiers), validate-imports 42 modules/368 exports, unit 13/13, filechat.test.mjs **11/11** (5 nouveaux), toolbar-order, sidebar-filters 8/8 | ✅ livré (en attente vérif utilisateur) |
 | 2026-10-08 | #169 | Fonctionnalité | `backend/file_chat.py` (nouveau), `backend/routers/file_chat.py` (nouveau), `backend/schemas.py`, `backend/main.py`, `frontend/js/filechat.js` (nouveau), `frontend/js/viewer.js`, `frontend/js/sync.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py` (nouveau), `tests/frontend/filechat.test.mjs` (nouveau), `tests/frontend/toolbar-order.test.mjs`, `.gitea/workflows/ci.yml`, `docs/ROADMAP.md`, `docs/features/file-chat-169.md` (nouveau), `docs/GUIDES/PRISE_EN_MAIN.md`, `CHANGELOG.md` | **#169 — chat intégré par fichier** : store JSON par (vault, path) sous `data/chats/` (nom SHA-256 → traversal impossible, plafond 500 msgs, texte 4000 car., écriture atomique, fichier corrompu → vide) ; `GET/POST /api/file/{vault}/chat` (auth + `check_vault_access` + `resolve_safe_path`, 400/404/403, `response_model`) + broadcast SSE `chat_message` sur le transport #62 (**pas de 2ᵉ WebSocket**) ; panneau latéral `filechat.js` (bouton 💬 toolbar, rendu chronologique `textContent`, envoi optimiste + dédup par id, toast si panneau fermé/autre fichier, plein écran ≤ 768 px) ; relais SSE en import dynamique dans `sync.js` ; i18n FR/EN 10 clés `chat.*`. En route : tag OpenAPI maison `file-chat` non déclaré → `test_used_tags_are_declared` rouge (retiré, dérivé « Files »), regex navBtns de `toolbar-order.test.mjs` (échappements → `includes`), ruff UP012/TRY004/I001. Vérifié : `test_file_chat.py` 15 passed, `filechat.test.mjs` 6/6, suite 1643 passed, ruff/mypy 0, validate-imports 42 modules, CI run #1938 5/5 success (v2.57.0) | ✅ livré (en attente vérif utilisateur) |
 | 2026-10-08 | #192 + BUG-109 | Fonctionnalité + correction | `backend/file_chat.py`, `backend/routers/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js`, `frontend/js/sync.js`, `frontend/index.html`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/ROADMAP.md`, `docs/features/file-chat-169.md`, `CHANGELOG.md` | **#192 — chat : saisie auto-agrandissante + accusé de réception.** La boîte d'envoi (panneau document **et** sidebar) devient un `textarea` dont la hauteur suit le contenu (plafond 160 px puis défilement, repasse à 1 ligne après l'envoi), `Entrée` envoie / `Maj+Entrée` saute une ligne ; placeholder sidebar désormais traduit à l'init. **Accusé de réception** : chaque document de conversation porte `read = {utilisateur: ts}` (verrou global sur le read-modify-write — une lecture ne peut plus faire disparaître un message), `GET` d'historique renvoie la carte, nouveau `POST /api/chat/read` (400 sans vault/path, 403 DM hors pair, ACL vault pour un chat de fichier) marque la lecture et diffuse `chat_read` en SSE ; côté client `✓` envoyé / `✓✓` lu sur **mes** messages (exclut ma propre carte de lecture), bascule en direct via `onChatRead()` + toast « {user} a lu votre message », accusé émis à l'ouverture d'une conversation et à la réception d'un message déjà affiché. **BUG-109** : la vignette des tuiles de lien ne s'affichait jamais (CSP `img-src 'self'` + `og:image` relative résolue contre ObsiGate) → `_proxy_image()` téléverse l'image dans `chat_uploads` (same-origin, `urljoin` contre la page, garde SSRF, 2 Mo max, allow-list) et la carte reste affichée si le téléchargement échoue. Tests : pytest `test_file_chat.py` 45→**54** (`TestReadReceipts` 7, proxy image 2, 2 assertions de réponse adaptées), JSDOM `filechat.test.mjs` 16→**19** ; ruff 0, mypy 0 (113 fichiers), validate-imports 42/371, unit 13/13 | ✅ livré (en attente vérif utilisateur) |
+| 2026-10-10 | BUG-111 | Correction UI admin | `frontend/admin.html`, `frontend/js/admin.js`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-111** : (1) la modale « Administration — Utilisateurs » ouverte depuis `/admin` n'affichait pas l'icône du bouton fermer — `safeCreateIcons()` retourne immédiatement car le global `lucide` n'existe pas sur `admin.html` (script UMD absent — seul index.html le chargeait) ; ajout du même `<script defer>` lucide@0.344.0. (2) Le tableau de bord admin affichait les 4 sections d'un coup (scrollspy) — `_wireSectionNav` masque désormais toutes les sections sauf celle cliquée (état initial : hash de l'URL ou section Stats). Vérifié : 1705 passed, suites frontend vertes, instance docker locale 2020. | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-10-09 | BUG-110 | Correction + refonte UI chat | `frontend/js/filechat.js`, `frontend/js/ui.js`, `frontend/js/viewer.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/frontend/filechat.test.mjs`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-110 — refonte visuelle du chat** : (1) les boutons de pièce jointe deviennent des **icônes seules** (24 px, `aria-label`) rangées **sous l'image, alignées à droite** — plus de gros boutons à libellé ; (2) le clic sur une image ouvre le **même visualiseur que pour une image de vault** (zoom/pan/plein écran) mais dans un **onglet de l'app** (`TabManager.openChatImage()`, branche `chatImage` de `activate()`, `renderImageViewer()` accepte désormais une `url` directe : une pièce jointe n'est pas dans un vault) au lieu d'un onglet du navigateur ; (3) **point rouge pulsant sur l'icône chat** de la sidebar tant qu'il reste des non-lus (classe `chat-has-unread`, en plus du badge chiffré) ; (4) **notification OS** (`Notification`) quand l'app n'est pas au premier plan (`document.hidden`/hors focus), permission demandée au premier clic d'ouverture du chat ; (5) la suppression n'est plus mensongère : le `DELETE` est **différé de 10 s**, la ligne passe à « Ce message a été supprimé » avec « Annuler » — annuler réarme le message (l'ancien code restaurait une copie DOM d'un message déjà détruit côté serveur en affichant « Message restauré ») ; échec réseau → le message revient. Vérifié : `filechat.test.mjs` 25/25 (dont 6 tests #110 : icônes seules, clic image → `openChatImage`, aucun `DELETE` pendant la fenêtre d'annulation, notification OS), `validate-imports` 42 modules / 372 exports 0 erreur, `unit.test.mjs` 13/13 | 🟢 corrigé (en attente vérif utilisateur) |

+| 2026-10-09 | #193 | Fonctionnalité | `backend/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js`, `frontend/style.css`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/features/file-chat-169.md`, `CHANGELOG.md` | **#193 — un post du chat s'affiche comme un document markdown** : le serveur rend le texte de chaque message avec le **pipeline des documents** (`backend/render.py::_render_markdown` : mistune — tableaux, listes de tâches, notes —, wikilinks, masquage des secrets #188, **sanitizer BUG-021**) et le renvoie dans un champ `html` (ajouté à `ChatMessageItem`, sinon `response_model` le filtrait). Le rendu est calculé **à la lecture** (`get_messages`) et à l'ajout (`_append`) — il n'est donc **jamais persisté** dans `data/chats/*.json` — et l'écho SSE part avec : les autres clients voient le rendu sans refresh. Côté front, `_fillBody()` injecte le HTML dans un `<div class="md-content">` puis appelle `safeHighlight()` sur chaque `pre code` (highlight.js + alias de langages, exactement comme le viewer ; mermaid non déclenché). Repli intact si `html` manque (écho optimiste → texte brut + URL cliquable) et un échec de rendu n'emporte jamais le message. CSS : `.file-chat-md` annule le `pre-wrap` hérité de la bulle (les retours à la ligne du HTML source produisaient des lignes vides) et compacte `.md-content` (`pre`/`table` en `overflow-x: auto`). Vérifié : `test_file_chat.py` 54→**61** (`TestMarkdownRendering` ×7 : html à l'ajout et à la lecture, **absent du JSON**, classe `language-xxx`, listes, `<script>` neutralisé, routes POST/GET, broadcast SSE), `filechat.test.mjs` 25→**27**, suite 1689 passed, ruff 0, mypy 0 (113 fichiers), validate-imports 42 modules / 372 exports | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-09 | #194 | Fonctionnalité | `backend/user_home.py` (nouveau), `backend/indexer.py`, `backend/auth/router.py`, `backend/routers/vaults.py`, `backend/main.py`, `docker-compose.yml`, `tests/test_user_home.py` (nouveau), `tests/test_auth_api.py`, `docs/features/user-home-194.md` (nouveau), `docs/ROADMAP.md`, `CHANGELOG.md`, `README.md`, `README.fr.md` | **#194 — dossier personnel par utilisateur** : chaque compte reçoit `<OBSIGATE_HOME_ROOT>/<user>` monté comme vault propre `home-<user>` (option A validée) — l'isolation s'appuie sur l'ACL par vault **existante** (`check_vault_access`), aucune ACL par chemin inventée. `backend/user_home.py` : `ensure_user_home()` idempotent (mkdir → `add_vault_to_index` → `persist_vault` → watcher → SSE → octroi dans `user.vaults`) appelé à `POST /api/auth/admin/users` **et** au démarrage (`ensure_all_user_homes()` : migration des users existants, réparation des dossiers/registres manquants, sweep des vaults `home-*` orphelins dont l'utilisateur a disparu hors route — garde `Path.parent == racine` pour ne jamais toucher à un vault admin homonyme) ; `release_user_home()` à la suppression (index/watcher/registre refermés, **dossier conservé**). **Blocage levé** : registre persistant `data/vaults.json` fusionné par `load_vault_config()` — avant, tout vault ajouté à la volée (`/api/vaults/add`) disparaissait au premier reindex complet et au redémarrage. Correctif au passage : `reload_single_vault()` remet `vault_config[name]` après `remove_vault_from_index()`. Réponse du POST = vaults réactualisés (l'instantané de `create_user` était antérieur à l'octroi). Déploiement : montage unique `/NFS/OBSIDIAN_DOC/Home:/vaults/Home` + `OBSIGATE_HOME_ROOT` (absente = feature inactive, dev/tests/desktop inchangés). Vérifié : `test_user_home.py` 12/12 (création, idempotence, username invalide, persistance après `load_vault_config`, retrait, isolation `check_vault_access`, orphelins), `test_auth_api.py::TestUserHome` 2/2, suite **1703 passed / 2 skipped**, ruff backend 0, mypy 114 fichiers 0, `validate-imports` 42 modules / 372 exports, `unit.test.mjs` 13/13 | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-09 | #194 | Fonctionnalité (UI) | `frontend/js/sidebar.js`, `frontend/js/viewer.js`, `docker-compose.test-win.yml`, `.gitignore`, `tests/frontend/sidebar-filters.test.mjs`, `docs/ROADMAP.md`, `docs/features/user-home-194.md`, `CHANGELOG.md` | **#194 (incrément UI)** : les vaults `home-<user>` s'affichent **en premier** dans l'arborescence de la sidebar — tri stable appliqué à la source (`_homeFirst` dans `loadVaults()` et dans le soft-refresh, donc `state.allVaults`, l'arborescence et les sélecteurs restent cohérents) — et portent l'icône **maison** lucide (`data-lucide="home"` via `getVaultIcon`, même `safeCreateIcons`/`stroke: currentColor` que les autres icônes, thème-aware). Compose de test : `test_home:/vaults/Home` + `OBSIGATE_HOME_ROOT=/vaults/Home` (dossier `test_home/` ignoré par git). Vérifié : `sidebar-filters.test.mjs` 8→**10/10**, `validate-imports` 42 modules / 372 exports, `unit.test.mjs` 13/13, suites voisines (ai-sidebar, toolbar-order, search-facets, pane-manager, editor-inline) vertes, **live Playwright sur l'instance 2020** : ordre `home-admin, home-bruno, TestDir, TestVault` + `svg.lucide-home` rendu (placeholder `<i>` remplacé) | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-09 | #194 | Correction (isolation) | `backend/auth/middleware.py`, `backend/services/recent.py`, `backend/services/search.py`, `backend/routers/search.py`, `backend/routers/config.py`, `backend/routers/conflicts.py`, `backend/routers/files_read.py`, `backend/routers/history.py`, `backend/push.py`, `backend/user_home.py`, `tests/test_user_home.py`, `tests/test_auth_api.py`, `docs/features/user-home-194.md`, `CHANGELOG.md` | **#194 — l'admin voyait le home de chaque utilisateur** (retour utilisateur) : `vaults: ["*"]` ouvrait **tous** les vaults, donc `home-<user>` compris. Correctif à la racine : `check_vault_access` exige un octroi **explicite** pour tout vault `home-*` (nouveau `is_home_vault()`), et les filtres `« * »` écrits en dur dans les routes ont été remplacés par cet appel unique — dashboard (`routers/config.py`), conflits, liens retour, favoris, abonnements push (`/api/search/replace` utilisait déjà `is_vault_allowed`). `/api/search` filtre désormais les bruts **avant** pagination via `search_vaults(is_allowed=…)` (sinon notes personnelles d'un autre compte dans les résultats). `_grant` n'écarte plus les comptes `« * »` → l'admin reçoit son propre `home-admin` (auto-réparé au démarrage). Vérifié : `test_user_home.py` 12→**14/14** (dont « * » sans homes + filtrage recherche), `test_auth_api.py` 2/2 (admin ne voit **plus** `home-alice`, alice voit le sien), suite **1705 passed / 2 skipped**, ruff backend 0, mypy 114 fichiers 0, **live Playwright instance 2020** : arborescence admin = `home-admin, TestDir, TestVault` (plus de `home-bruno`), `svg.lucide-home` rendu. Reste ouvert (fuite pré-existante, hors périmètre) : `/api/search/advanced`, `/api/tags`, `/api/tags/suggest`, `/api/tree-search`, `/api/suggest` ne filtrent pas par vault accessible | ✅ livré (en attente vérif utilisateur) |
+
 ---

 ## 📜 Historique des bugs résolus
@@ -1,6 +1,6 @@
 # ObsiGate — Roadmap

-> **Version :** 2.62.0 | **Dernière mise à jour :** 2026-10-09
+> **Version :** 2.66.0 | **Dernière mise à jour :** 2026-10-10
 > **Ce fichier ne contient que le travail à venir** (🔵 En cours + ⚪ Backlog) et un index compact
 > vers les fonctionnalités livrées.
 > - **Méthode de livraison à appliquer pour toute tâche : [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md)**
@@ -30,6 +30,52 @@

 ## 🔵 En cours

+### 196. Partage dirigé entre utilisateurs (document → utilisateur)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-10 | **Statut :** ✅ livré le 2026-10-10
+- **Fiche :** [features/directed-shares-196.md](./features/directed-shares-196.md)
+- **Description :** un utilisateur peut partager un document à un ou plusieurs
+  autres comptes (pas un lien public) : les pages `/s/{token}` exigent alors
+  une session et n'acceptent que créateur + admin + destinataires (404 sinon,
+  pas de fuite d'existence). Vue « partagé avec moi » dans le dashboard,
+  destinataires listés dans le dialogue de partage, révocabilité réservée au
+  créateur/admin, `GET /api/shares` scopé (un non-admin ne voit que ses
+  partages créés/reçus — corrige une fuite préexistante). Rétrocompatible :
+  les partages publics existants restent anonymes.
+- **Sous-tâches :**
+  - [x] Store `shared_with` + validation des destinataires à la création
+  - [x] Gate auth+appartenance sur `/s/{token}` (+`/pdf`, `/raw`) — 404 opaque
+  - [x] Scope de `GET /api/shares` ; révocation créateur/admin uniquement
+  - [x] UI : dialogue dirigé/public + destinataires, dashboard « partagé par X »
+  - [x] i18n FR/EN, tests `test_directed_shares.py` (9), fiche feature
+
+### 194. Dossier personnel par utilisateur (`<racine>/Home/<user>`)
+
+- **Effort :** 1-2 jours | **Impact :** 🟡 | **Ouvert :** 2026-10-09 | **Statut :** 🔵 en cours
+- **Cadrage :** chaque utilisateur créé reçoit un dossier personnel monté en vault propre
+  (`home-<user>`), isolé par l'ACL par vault existante — pas d'ACL par chemin à inventer.
+- **Décisions validées :** option A (un vault par utilisateur), nom `home-<user>`,
+  dossier **conservé** à la suppression du compte, racine `/NFS/OBSIDIAN_DOC/Home`
+  (montée `/vaults/Home`, exposée par `OBSIGATE_HOME_ROOT`).
+- **Sous-tâches :**
+  - [x] ID stable créé (avant codage, AGENTS.md)
+  - [x] Registre persistant des vaults dynamiques `data/vaults.json` (les vaults ajoutés à la
+        volée sont aujourd'hui perdus au redémarrage / reindex — `load_vault_config` ne lit
+        que les env `VAULT_N_*`)
+  - [x] Service `ensure_user_home()` idempotent : mkdir + vault + octroi, appelé à la création
+        d'un user et au démarrage (réparation/migration)
+  - [x] Retrait au suppression de compte (index/watcher/registre) sans supprimer le dossier
+  - [x] Montage Docker + `OBSIGATE_HOME_ROOT` (prod **et** compose de test
+        `docker-compose.test-win.yml` → `test_home:/vaults/Home`)
+  - [x] UI : vaults `home-*` en **premier** dans l'arborescence + icône maison
+        lucide (`getVaultIcon`), vérifié live sur l'instance 2020
+  - [x] Isolation : « * » (admin) ne couvre **plus** les dossiers persos —
+        `check_vault_access` + filtres des routes + `/api/search` (avant
+        pagination) ; octroi du home aussi aux comptes « * »
+  - [x] Tests (création, persistance après rebuild, isolation 403 entre users) + docs
+
+---
+
 ### 77. Application Desktop native — Tauri (Windows / Linux / macOS)

 - **Effort :** 8-12 jours | **Impact :** 🟡 | **Framework :** Tauri v2 (Rust + Webview)
@@ -0,0 +1,79 @@
+# #196 — Partage dirigé entre utilisateurs
+
+> **Statut :** livré | **Ouvert :** 2026-10-10 | **Type :** feature (sharing + auth)
+
+## Problème
+
+Le seul partage existant (#85) était un lien **public** : quiconque possède
+l'URL lit le document, sans compte ni session. Il n'existait aucun moyen de
+partager un document *à un utilisateur précis* de la plateforme — un
+utilisateur ne pouvait ni adresser un document à un autre, ni consulter les
+documents qu'on lui adresse, ni (côté créateur) retirer ce partage.
+
+## Décision d'architecture
+
+Deux formes étaient possibles :
+
+1. **Réutiliser le partage par token existant, dirigé** (retenu) — le record
+   `data/shares.json` gagne `shared_with: [usernames]`. Si la liste est non
+   vide, les pages `/s/{token}` (et `/pdf`, `/raw`) exigent une session et
+   n'acceptent que créateur + admin + destinataires. Vide/absent : le
+   comportement public historique est inchangé (rétrocompatibilité totale,
+   zéro migration — les shares existants n'ont pas le champ).
+2. Octroyer le vault entier au destinataire (`update_user {"vaults": …}`)
+   (écartée) — accès lecture-**écriture** au vault complet au lieu d'un
+   document en lecture seule ; c'est le modèle « collaborateur de vault »,
+   pas « partager un document ». Reste la bonne réponse pour ce besoin-là.
+
+Points de sécurité délibérés :
+
+- **404, jamais 403/401, sur la gate** — un visiteur sans session (ou un
+  utilisateur non destinataire) apprend le même « Share not found or
+  expired » qu'un token inventé : l'existence d'un token dirigé n'est pas
+  confirmable de l'extérieur.
+- **`GET /api/shares` scopé** (correctif au passage) — un non-admin ne voit
+  que les partages qu'il a créés **ou reçus`** (avant : tout le monde voyait
+  tous les partages, fuite préexistante devenue intenable avec du user-to-user).
+  Un admin voit tout.
+- **Révocation réservée au créateur/admin** — un destinataire ne peut pas
+  casser l'accès des autres.
+- Les **destinataires sont validés** à la création (`get_user`) : pas de lien
+  mort vers un compte inexistant.
+
+## Mise en place
+
+| Élément | Où |
+|---|---|
+| Store : champ `shared_with`, param de `create_share` | `backend/share.py` |
+| Gate `_gate_share()` + branchement `/s/{token}`, `/s/{token}/pdf`, `/s/{token}/raw` | `backend/routers/sharing.py` |
+| Scope de `GET /api/shares` (non-admin = créés + reçus) | `backend/routers/sharing.py`, `backend/share.py::list_shares(user=…)` |
+| Révocabilité créateur/admin uniquement | `backend/routers/sharing.py::api_share_revoke` |
+| Validation des destinataires à la création | `backend/routers/sharing.py::api_share_create` |
+| `ShareModel.shared_with` | `backend/schemas.py` |
+| Dialogue : radio public/dirigé + champ destinataires (virgules) | `frontend/js/config.js::openShareDialog` |
+| Destinataires affichés dans la vue « déjà partagé » | `frontend/js/config.js` |
+| Dashboard : cartes reçues (« Partagé par X », ouverture `/s/`, pas de bouton révoquer) | `frontend/js/dashboard.js::DashboardSharedWidget` |
+| i18n FR/EN (6 clés config.* + dashboard.shared_by) | `frontend/locales/{fr,en}.json` |
+
+Ce qui est gratuit par construction : lecture seule (le destinataire ne
+passe jamais par l'éditeur), expiration, compteur d'accès, suivi des
+renommages (`update_shares_after_rename`), masquage des secrets
+(`redact_file_content` déjà dans les 3 routes `/s/*`), isolation des
+dossiers perso #194 (le destinataire ne voit jamais l'arbre du vault de
+l'auteur, seulement le document rendu).
+
+## Tests
+
+`tests/test_directed_shares.py` (9) : création dirigée, destinataire inconnu
+→ 400, anonyme → 404 / destinataire + créateur → 200, non-destinataire →
+404, lien public toujours anonyme, scope de `/api/shares`, destinataire ne
+peut pas révoquer (403), créateur révoque, la révocation coupe l'accès.
+
+## Limites connues
+
+- `shared_with` est une liste plate d'usernames — pas de groupes. Ajouter
+  des groupes quand le besoin sera réel.
+- Pas de notification push : le destinataire découvre les partages reçus au
+  rechargement du dashboard (badge/rafraîchissement suffisent ; SSE existe
+  si un vrai push est demandé).
+- La date d'« expiration » reste globale au partage (pas par destinataire).
@@ -211,6 +211,54 @@ carte reste (jamais de message perdu).
  direct + notification + pas d'écho, textarea (tagName/rows, hauteur
  pilotée, `Entrée` intercepté / `Maj+Entrée` non).

+## #193 — Rendu markdown des posts (2026-10-09)
+
+Un post du chat s'affiche désormais **comme un document** : titres, listes,
+tableaux, citations, blocs de code colorés — au lieu du texte brut avec liens
+cliquables.
+
+### A. Le rendu vient du serveur (pas de second moteur markdown)
+
+- `backend/file_chat.py::_decorate()` ajoute un champ `html` à chaque message
+  en réutilisant `backend/render.py::_render_markdown()` — **le pipeline exact
+  des documents** : mistune (tableaux, strikethrough, notes, listes de tâches),
+  résolution des wikilinks, normalisation des sauts de ligne, masquage des
+  secrets (#188) et **sanitizer BUG-021** en sortie. Aucun markdown côté client,
+  donc aucun XSS nouveau à traiter : la sanitisation est déjà éprouvée.
+- `ChatMessageItem.html` (schéma de réponse) : sans ce champ, `response_model`
+  filtrait la clé.
+- Le `html` est calculé **à la lecture** (`get_messages()`) et à l'ajout
+  (`_append()`), donc il n'est **jamais persisté** dans `data/chats/*.json` :
+  un message reste du texte, le rendu suit les évolutions du pipeline.
+- L'écho SSE part avec le `html` : les autres clients voient le rendu sans
+  attendre un refresh.
+- Un échec de rendu n'emporte pas le message : repli silencieux (`html = ""`),
+  le client affiche le texte brut.
+
+### B. Frontend : `.md-content` + highlight.js
+
+- `_fillBody()` injecte le `html` dans un `<div class="md-content">` (la
+  typographie des documents) puis appelle `safeHighlight()` sur chaque
+  `pre code` — le même helper (et les mêmes alias de langages) que le viewer.
+  Mermaid n'est pas déclenché dans le chat.
+- Repli intact : un message sans `html` (écho optimiste d'un autre client)
+  repasse par l'ancien chemin texte + URL cliquable.
+- CSS : `.file-chat-body.file-chat-md` annule le `white-space: pre-wrap` hérité
+  de la bulle (sinon les retours à la ligne du HTML source créaient des lignes
+  vides) et compacte `.md-content` (tailles, marges, `pre`/`table` en
+  `overflow-x: auto`) pour tenir dans une bulle de 92 % de large.
+
+### Tests #193
+
+- pytest `TestMarkdownRendering` (7) : `html` présent à l'ajout **et** à la
+  lecture, `html` **absent** du JSON stocké, classe `language-xxx` conservée
+  (ce sur quoi hljs se branche), tableaux/listes, `<script>` neutralisé,
+  routes `POST/GET` (chat de fichier + chat général) et écho SSE porteur du
+  `html`. Suite : 1689 passed.
+- JSDOM `filechat.test.mjs` +2 (27) : post avec `html` → `.md-content`,
+  `<strong>`, `pre code.language-python` ; post sans `html` → texte brut et URL
+  cliquable conservés.
+
 ## Décisions

 - **SSE plutôt qu'un second WebSocket** : le transport de #62 (EventSource
@@ -0,0 +1,107 @@
+# #194 — Dossier personnel par utilisateur
+
+> **Statut :** livré | **Ouvert :** 2026-10-09 | **Type :** feature (auth + vaults)
+
+## Problème
+
+Un utilisateur créé dans ObsiGate n'avait aucun espace propre : il ne voyait
+que les vaults qu'un admin lui attribuait à la main, et rien n'était préparé
+sur le disque à sa création.
+
+## Décision d'architecture
+
+Deux formes étaient possibles :
+
+1. **Un vault par utilisateur** (retenu) — `<racine>/<user>` devient le vault
+   `home-<user>`, octroyé dans `user.vaults`. L'ACL par vault existante
+   (`backend/auth/middleware.py::check_vault_access`, appliquée partout :
+   API, MCP, search, push, tools) fait l'isolation **sans rien inventer**.
+2. Un vault `Home` unique + ACL par sous-dossier (écartée) — il n'existe
+   aucune ACL par chemin dans le code ; il aurait fallu la brancher dans
+   `files_read`, `files_media`, `history`, `backups`, `mcp/tools`, `push`…
+   Surface de sécurité trop grande pour un gain marginal.
+
+Décisions produit validées : nom `home-<user>`, dossier **conservé** à la
+suppression du compte, racine `/NFS/OBSIDIAN_DOC/Home` montée `/vaults/Home`.
+
+## Mise en place
+
+| Élément | Où |
+|---|---|
+| Service idempotent `ensure_user_home()` / `release_user_home()` / `ensure_all_user_homes()` | `backend/user_home.py` |
+| Registre persistant des vaults dynamiques `data/vaults.json`, fusionné par `load_vault_config()` | `backend/indexer.py` (`persist_vault` / `unpersist_vault`) |
+| Appel à la création et à la suppression d'un compte | `backend/auth/router.py` (`POST/DELETE /api/auth/admin/users`) |
+| Passe de réparation/migration au démarrage | `backend/main.py` (`lifespan` → après le watcher) |
+| Persistance des vaults ajoutés par `/api/vaults/add` + retrait | `backend/routers/vaults.py` |
+| Montage + variable d'environnement | `docker-compose.yml` (`/NFS/OBSIDIAN_DOC/Home:/vaults/Home`, `OBSIGATE_HOME_ROOT=/vaults/Home`) |
+
+## Garde-fous
+
+- **Fonctionnalité inactive sans `OBSIGATE_HOME_ROOT`** : dev, tests et
+  desktop n'ont aucun comportement modifié.
+- **Validation du nom** : `^[a-zA-Z0-9_-]{2,32}$` (même grammaire que
+  `CreateUserRequest.username_valid`), re-vérifiée avant de construire un
+  chemin — défense en profondeur contre le path traversal.
+- **Nom de vault sans `/` ni `::`** : le nom sert de segment d'URL
+  (`/api/file/{vault}/…`) et de clé d'index `vault::path`.
+- **Auto-réparation** : `ensure_all_user_homes()` au démarrage crée les
+  dossiers manquants, ré-enregistre les vaults perdus et octroie l'accès aux
+  users créés hors API. Toute erreur disque (NFS indisponible) est
+  journalisée et rattrapée au boot.
+- **Suppression de compte** : index/watcher/registre refermés, dossier sur
+  disque conservé.
+
+## Bug corrigé au passage
+
+- `load_vault_config()` ne lisait que les env `VAULT_N_*`/`DIR_N_*` : tout
+  vault ajouté à la volée (y compris via `/api/vaults/add`) disparaissait au
+  premier reindex complet et au redémarrage. → `data/vaults.json`.
+- `reload_single_vault()` perdait l'entrée `vault_config[vault]` après
+  `remove_vault_from_index()`.
+
+## Tests
+
+- `tests/test_user_home.py` (10) : création (dossier + vault + octroi +
+  registre), idempotence, username invalide, désactivation sans variable,
+  relecture du registre par `load_vault_config`, `release` (dossier
+  conservé), isolation `check_vault_access` entre users, passe de réparation.
+- `tests/test_auth_api.py::TestUserHome` (2) : provisionnement via l'API
+  (création → dossier, vault visible, alice ne voit que son home, suppression
+  → vault refermé / dossier conservé) + absence de dossier sans
+  `OBSIGATE_HOME_ROOT`.
+
+## UI — arborescence (incrément)
+
+- **Ordre** : tri stable `home-*` en premier, appliqué à la source
+  (`frontend/js/sidebar.js::_homeFirst`, sur les deux sites qui alimentent
+  `state.allVaults`) → arborescence, sélecteurs et refreshs homogènes.
+- **Icône** : `getVaultIcon()` (`frontend/js/viewer.js`) renvoie
+  `icon("home", size)` pour `home-*` → même pipeline lucide que le reste de
+  l'app (`safeCreateIcons`, `stroke: currentColor`, suit le thème).
+- **Test local** : `docker-compose.test-win.yml` monte
+  `test_home:/vaults/Home` + `OBSIGATE_HOME_ROOT=/vaults/Home`
+  (`test_home/` est dans `.gitignore`).
+- **Vérifié live** (instance 2020, Playwright) : ordre `home-admin, TestDir,
+  TestVault` (l'admin ne voit plus le home des autres), `svg.lucide-home`
+  rendu, placeholder `<i>` remplacé.
+
+## Isolation — « * » ne couvre pas les dossiers persos
+
+- **Racine** : `check_vault_access` (`backend/auth/middleware.py`) renvoie
+  ``vault_name in vaults`` pour tout vault ``home-*``, quel que soit le ``*``.
+  Toutes les routes (89 usages) passent par cette fonction.
+- **Filtres « * » en dur remplacés** par cet appel : dashboard
+  (`routers/config.py`), conflits, liens retour, favoris, abonnements push.
+- **Recherche** : `services/search.search_vaults(is_allowed=…)` filtre les
+  bruts **avant** pagination — ``total`` et page restent justes.
+- **Octroi** : `_grant` n'écarte plus les comptes ``*`` → l'admin reçoit son
+  propre ``home-admin`` (réparé au démarrage pour les comptes existants).
+- **Reste ouvert** (fuite pré-existante, hors #194) : `/api/search/advanced`,
+  `/api/tags`, `/api/tags/suggest`, `/api/tree-search` et `/api/suggest` ne
+  filtrent pas par vault accessible — à traiter dans une tâche dédiée.
+
+## Impact utilisateur
+
+Aucune nouvelle chaîne i18n : les noms de vault sont des données, la liste
+provient déjà de `GET /api/vaults`. Le dossier apparaît tout seul dans le
+sélecteur de vaults de l'utilisateur concerné.
@@ -8,6 +8,9 @@

    <link rel="icon" type="image/svg+xml" href="/static/icons/icon-72x72.svg" />

+    <!-- Lucide : requis par safeCreateIcons() (icônes des modales, ex. bouton fermer) -->
+    <script defer src="https://unpkg.com/[email protected]/dist/umd/lucide.min.js"></script>
+
    <!-- Anti-FOUC : applique vite le mode du thème sauvegardé avant le CSS -->
    <script>
        (function () {
@@ -394,54 +394,35 @@ function _wireAuditFilters() {
  }
 }

-// ── Section nav (scrollspy) ───────────────────────────────────────────
+// ── Section nav (une seule section visible à la fois) ──────────────────

 /**
- * Wire the sticky section nav: smooth-scroll on click + highlight the section
- * currently in view (IntersectionObserver). Falls back to default anchor jump
- * if the observer is unavailable.
+ * Wire the sticky section nav: clicking a link shows ONLY that section
+ * (the others are hidden). The first section (Stats) is shown on load.
 */
 function _wireSectionNav() {
  const links = Array.from(document.querySelectorAll("#admin-subnav a"));
  if (!links.length) return;
-  const targets = links
-    .map((a) => document.getElementById((a.getAttribute("href") || "#").slice(1)))
-    .filter(Boolean);
+  const sections = Array.from(document.querySelectorAll("#admin-main .admin-section"));

-  // Smooth scroll on click
-  links.forEach((a) => {
-    a.addEventListener("click", (e) => {
-      const href = a.getAttribute("href");
-      if (!href || !href.startsWith("#")) return;
-      const t = document.getElementById(href.slice(1));
-      if (!t) return;
-      e.preventDefault();
-      t.scrollIntoView({ behavior: "smooth", block: "start" });
-    });
-  });
-
-  // Scrollspy: mark the section currently at the top of the viewport
-  let active = null;
-  const setActive = (id) => {
-    if (active === id) return;
-    active = id;
+  const show = (id) => {
+    sections.forEach((s) => { s.style.display = s.id === id ? "" : "none"; });
    links.forEach((l) => l.classList.toggle("active", l.getAttribute("href") === "#" + id));
  };

-  if ("IntersectionObserver" in window) {
-    const io = new IntersectionObserver(
-      (entries) => {
-        entries.forEach((en) => {
-          if (en.isIntersecting) setActive(en.target.id);
-        });
-      },
-      { rootMargin: "-64px 0px -70% 0px", threshold: 0 }
-    );
-    targets.forEach((t) => io.observe(t));
-  } else {
-    // Fallback: highlight the first section only (no scroll observation)
-    links[0] && links[0].classList.add("active");
-  }
+  links.forEach((a) => {
+    a.addEventListener("click", (e) => {
+      e.preventDefault();
+      const href = a.getAttribute("href") || "";
+      if (!href.startsWith("#")) return;
+      show(href.slice(1));
+      window.scrollTo({ top: 0, behavior: "smooth" });
+    });
+  });
+
+  // État initial : seule la section demandée par le hash (ou la première) est visible.
+  const initial = (location.hash && sections.find((s) => "#" + s.id === location.hash)) || sections[0];
+  if (initial) show(initial.id);
 }

 // ── Auth gate ────────────────────────────────────────────────────────────
@@ -1656,10 +1656,14 @@ export async function openShareDialog(vault, path) {
      const expiresInfo = existingShare.expires_at
        ? `<p style="font-size:0.75rem;color:var(--text-muted)">Expire le ${new Date(existingShare.expires_at).toLocaleDateString("fr-FR")}</p>`
        : '<p style="font-size:0.75rem;color:var(--text-muted)">Sans expiration</p>';
+      const recipientsInfo = (existingShare.shared_with && existingShare.shared_with.length)
+        ? `<p style="font-size:0.75rem;color:var(--text-muted);margin-bottom:4px">${t('config.share_shared_with')} : ${escapeHtml(existingShare.shared_with.join(", "))}</p>`
+        : '';
      div.innerHTML = `
        <div class="share-dialog">
          <h3>📤 Document partagé</h3>
          <p style="font-size:0.85rem;color:var(--text-muted);margin-bottom:4px">${escapeHtml(vault)}/${escapeHtml(path)}</p>
+          ${recipientsInfo}
          ${expiresInfo}
          <p style="font-size:0.75rem;color:var(--text-muted);margin-bottom:8px">${existingShare.access_count} vue(s)</p>
          <input type="text" class="share-url-input" value="${url}" readonly>
@@ -1697,7 +1701,16 @@ export async function openShareDialog(vault, path) {
        <div class="share-dialog">
          <h3>📤 Partager ce document</h3>
          <p style="font-size:0.85rem;color:var(--text-muted);margin-bottom:12px">${escapeHtml(vault)}/${escapeHtml(path)}</p>
-          <p style="font-size:0.8rem;margin-bottom:8px">Ce lien sera accessible <strong>publiquement, sans authentification</strong>.</p>
+          <label style="font-size:0.8rem;display:flex;align-items:center;gap:8px;margin-bottom:8px">
+            <input type="radio" name="share-visibility" value="directed" checked>
+            ${t('config.share_directed')}
+          </label>
+          <input type="text" id="share-recipients" placeholder="${t('config.share_recipients_ph')}"
+                 style="width:100%;padding:6px 8px;margin-bottom:8px;border:1px solid var(--border);border-radius:4px;background:var(--bg-secondary);color:var(--text-primary);font-size:0.8rem">
+          <label style="font-size:0.8rem;display:flex;align-items:center;gap:8px;margin-bottom:8px">
+            <input type="radio" name="share-visibility" value="public">
+            ${t('config.share_public')}
+          </label>
          <label style="font-size:0.8rem;display:flex;align-items:center;gap:8px;margin-bottom:12px">
            Expiration :
            <select id="share-expiry" style="padding:4px 8px;border:1px solid var(--border);border-radius:4px;background:var(--bg-secondary);color:var(--text-primary);font-size:0.8rem">
@@ -1716,10 +1729,19 @@ export async function openShareDialog(vault, path) {
      div.querySelector(".share-create-btn").addEventListener("click", async () => {
        try {
          const expiry = document.getElementById("share-expiry")?.value;
+          const visibility = div.querySelector('input[name="share-visibility"]:checked')?.value || "directed";
+          const recipientsRaw = document.getElementById("share-recipients")?.value || "";
+          const recipients = visibility === "directed"
+            ? recipientsRaw.split(",").map(s => s.trim()).filter(Boolean)
+            : [];
+          if (visibility === "directed" && !recipients.length) {
+            showToast(t('config.share_need_recipient'), "error");
+            return;
+          }
          const share = await api(`/api/share/${encodeURIComponent(vault)}`, {
            method: "POST",
            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ path, expires_in_hours: expiry ? parseInt(expiry) : null }),
+            body: JSON.stringify({ path, expires_in_hours: expiry ? parseInt(expiry) : null, shared_with: recipients }),
          });
          existingShare = share;
          renderContent();
@@ -1,5 +1,5 @@
 // dashboard.js — extracted from app.js (3414-3806) + DashboardBookmarkWidget (3810-3870)
-import { api } from './auth.js';
+import { api, AuthManager } from './auth.js';
 import { state } from './state.js';
 import { escapeHtml, safeCreateIcons, getFileIcon } from './utils.js';
 import { icon, openFile } from './viewer.js';
@@ -60,24 +60,29 @@ const DashboardSharedWidget = {
      const shares = await api("/api/shares");
      if (!shares.length) { if (empty) empty.style.display = ""; grid.innerHTML = ""; return; }
      if (empty) empty.style.display = "none";
-      grid.innerHTML = shares.map(s => `
-        <div class="shared-card" data-vault="${escapeHtml(s.vault)}" data-path="${escapeHtml(s.path)}">
+      const me = (AuthManager.getUser() || {}).username;
+      grid.innerHTML = shares.map(s => {
+        const received = me && s.created_by && s.created_by !== me;
+        const actions = received
+          ? `<button class="shared-open-btn">${t('dashboard.open_btn')}</button>`
+          : `<button class="shared-copy-btn" data-url="${window.location.origin}/s/${s.token}">${t('dashboard.copy_btn')}</button>
+             <button class="shared-open-btn">${t('dashboard.open_btn')}</button>
+             <button class="shared-revoke-btn" data-id="${s.id}">🗑</button>`;
+        return `
+        <div class="shared-card" data-vault="${escapeHtml(s.vault)}" data-path="${escapeHtml(s.path)}" data-token="${s.token}" data-received="${received ? "1" : ""}">
          <div class="shared-card-header">
            <i data-lucide="file-text" style="width:14px;height:14px"></i>
-            <span class="shared-card-title">${escapeHtml(s.path.split("/").pop().replace(/\.md$/i, ""))}</span>
+            <span class="shared-card-title">${escapeHtml(s.path.split("/").pop().replace(/\\.md$/i, ""))}</span>
            <span class="shared-card-vault">${escapeHtml(s.vault)}</span>
          </div>
          <div class="shared-card-meta">
+            ${received ? `<span>${t('dashboard.shared_by', { user: s.created_by })}</span>` : ""}
            <span>${s.access_count || 0} ${t('dashboard.views', {count: s.access_count || 0})}</span>
            ${s.expires_at ? `<span>${t('dashboard.expires', {date: new Date(s.expires_at).toLocaleDateString(getLocale() === 'fr' ? 'fr-FR' : 'en-US')})}</span>` : ""}
          </div>
-          <div class="shared-card-actions">
-            <button class="shared-copy-btn" data-url="${window.location.origin}/s/${s.token}">${t('dashboard.copy_btn')}</button>
-            <button class="shared-open-btn">${t('dashboard.open_btn')}</button>
-            <button class="shared-revoke-btn" data-id="${s.id}">🗑</button>
-          </div>
-        </div>
-      `).join("");
+          <div class="shared-card-actions">${actions}</div>
+        </div>`;
+      }).join("");
      lucide.createIcons();
      grid.querySelectorAll(".shared-copy-btn").forEach(b => b.addEventListener("click", async (e) => {
        e.stopPropagation();
@@ -88,6 +93,10 @@ const DashboardSharedWidget = {
      grid.querySelectorAll(".shared-open-btn").forEach(b => b.addEventListener("click", (e) => {
        e.stopPropagation();
        const card = b.closest(".shared-card");
+        if (card && card.dataset.received === "1" && card.dataset.token) {
+          window.open(`/s/${card.dataset.token}`, "_blank");
+          return;
+        }
        if (card) TabManager.openPreview(card.dataset.vault, card.dataset.path);
      }));
      grid.querySelectorAll(".shared-revoke-btn").forEach(b => b.addEventListener("click", async (e) => {
@@ -97,6 +106,10 @@ const DashboardSharedWidget = {
        this.load();
      }));
      grid.querySelectorAll(".shared-card").forEach(card => card.addEventListener("click", () => {
+        if (card.dataset.received === "1" && card.dataset.token) {
+          window.open(`/s/${card.dataset.token}`, "_blank");
+          return;
+        }
        TabManager.openPreview(card.dataset.vault, card.dataset.path);
      }));
    } catch (err) { if (empty) empty.style.display = ""; }
@@ -12,7 +12,7 @@
 import { api, AuthManager } from "./auth.js";
 import { t } from "./i18n.js";
 import { showToast, TabManager } from "./ui.js";
-import { escapeHtml, safeCreateIcons } from "./utils.js";
+import { escapeHtml, safeCreateIcons, safeHighlight } from "./utils.js";
 import { icon } from "./viewer.js";

 const PANEL_ID = "file-chat-panel";
@@ -147,7 +147,32 @@ async function _markRead(vault, path) {
 }

 // URL dans le texte → lien cliquable (partage d'URL #190), texte sinon.
-function _fillBody(body, text) {
+/**
+ * Remplit le corps d'un message (#193).
+ *
+ * Quand le serveur a fourni le rendu markdown (`html`, même pipeline que les
+ * documents : mistune + sanitizer BUG-021), on l'injecte dans un `.md-content`
+ * — titres, listes, tableaux, blocs de code — et on colore les blocs avec
+ * highlight.js (`safeHighlight`), exactement comme dans le viewer.
+ *
+ * Sans `html` (message optimiste d'un autre client, cache ancien), on retombe
+ * sur le texte brut avec liens cliquables, comme avant.
+ */
+function _fillBody(body, m) {
+  const text = typeof m === "string" ? m : (m && m.text) || "";
+  const html = m && typeof m === "object" ? m.html || "" : "";
+  if (html) {
+    body.classList.add("file-chat-md");
+    const div = document.createElement("div");
+    div.className = "md-content";
+    div.innerHTML = html; // rendu + assaini côté serveur
+    body.appendChild(div);
+    div.querySelectorAll("pre code").forEach((block) => {
+      if (block.querySelector(".secret-mask")) return;
+      safeHighlight(block);
+    });
+    return;
+  }
  const parts = String(text || "").split(/(https?:\/\/[^\s<>"']+)/g);
  parts.forEach((part) => {
    if (!part) return;
@@ -341,7 +366,7 @@ export function _messageEl(m, currentUser, delUrl, readMap) {
  }
  const body = document.createElement("div");
  body.className = "file-chat-body";
-  _fillBody(body, m.text);
+  _fillBody(body, m);
  wrap.appendChild(meta);
  if (m.text) wrap.appendChild(body);
  const att = _attachEl(m.attachment);
@@ -220,8 +220,15 @@ async function loadVaultSettings() {
 // ---------------------------------------------------------------------------
 // Sidebar — Vault tree
 // ---------------------------------------------------------------------------
+// #194 : le dossier personnel (vault « home-<user> ») s'affiche en premier
+// dans l'arborescence. Tri stable fait sur place, à la source de toutes les
+// listes (arborescence, sélecteurs, state.allVaults).
+const _homeFirst = (a, b) =>
+  (String(b?.name).startsWith("home-") ? 1 : 0) - (String(a?.name).startsWith("home-") ? 1 : 0);
+
 async function loadVaults() {
  const vaults = await api("/api/vaults");
+  vaults.sort(_homeFirst);
  state.allVaults = vaults;
  const container = document.getElementById("vault-tree");
  container.innerHTML = "";
@@ -426,6 +433,7 @@ export async function refreshSidebarTreePreservingState() {
  // 2. Soft update: vault names/counts without wiping the tree
  try {
    const vaults = await api("/api/vaults");
+    vaults.sort(_homeFirst);
    state.allVaults = vaults;
    vaults.forEach((v) => {
      const vItem = document.querySelector(`.vault-item[data-vault="${CSS.escape(v.name)}"]`);
@@ -7579,6 +7579,10 @@ export function attachTreeItemLongPress(itemEl, getMenuData) {
 }

 export function getVaultIcon(vaultName, size = 16) {
+  // Dossier personnel (#194) : icône maison, même style lucide que le reste.
+  if (typeof vaultName === "string" && vaultName.startsWith("home-")) {
+    return icon("home", size);
+  }
  const v = state.allVaults.find((val) => val.name === vaultName);
  const type = v ? v.type : "VAULT";

@@ -604,6 +604,11 @@
  "config.server_config": "Server config",
  "config.settings_saved": "✓ Settings saved",
  "config.share_revoked": "Share revoked",
+  "config.share_directed": "Share with users (authentication required)",
+  "config.share_public": "Public link (no authentication)",
+  "config.share_recipients_ph": "Recipients (usernames, comma-separated)",
+  "config.share_need_recipient": "Provide at least one recipient",
+  "config.share_shared_with": "Shared with",
  "config.shares": "Public shares",
  "config.shares_desc": "Manage public share links for your documents.",
  "config.shares_empty": "No active shares",
@@ -701,6 +706,7 @@
  "dashboard.recent": "Recent",
  "dashboard.recent_hint": "Open a file to see it appear here",
  "dashboard.shared_hint": "Share a document to see it appear here",
+  "dashboard.shared_by": "Shared by {user}",
  "dashboard.shares": "Shares",
  "dashboard.show": "Show",
  "dashboard.size_bytes": " B",
@@ -604,6 +604,11 @@
  "config.server_config": "Configuration serveur",
  "config.settings_saved": "✓ Paramètres sauvegardés",
  "config.share_revoked": "Partage révoqué",
+  "config.share_directed": "Partager avec des utilisateurs (authentification requise)",
+  "config.share_public": "Lien public (sans authentification)",
+  "config.share_recipients_ph": "Destinataires (noms d'utilisateur, séparés par des virgules)",
+  "config.share_need_recipient": "Indiquez au moins un destinataire",
+  "config.share_shared_with": "Partagé avec",
  "config.shares": "Partages publics",
  "config.shares_desc": "Gérez les liens de partage public de vos documents.",
  "config.shares_empty": "Aucun partage actif",
@@ -701,6 +706,7 @@
  "dashboard.recent": "Récents",
  "dashboard.recent_hint": "Ouvrez un fichier pour le voir apparaître ici",
  "dashboard.shared_hint": "Partagez un document pour le voir apparaître ici",
+  "dashboard.shared_by": "Partagé par {user}",
  "dashboard.shares": "Partages",
  "dashboard.show": "Afficher",
  "dashboard.size_bytes": " o",
@@ -13852,6 +13852,70 @@ body.reading-mode .file-actions {
  white-space: pre-wrap;
  word-break: break-word;
 }
+/* #193 — un post peut être rendu comme un document markdown (mistune côté
+   serveur + hljs côté client) : on annule le `pre-wrap` hérité (sinon les
+   retours à la ligne du HTML source deviennent des lignes vides) et on
+   compacte la typographie `.md-content` pour une bulle de chat. */
+.file-chat-body.file-chat-md {
+  white-space: normal;
+  word-break: normal;
+}
+.file-chat-body .md-content > :first-child {
+  margin-top: 0;
+}
+.file-chat-body .md-content > :last-child {
+  margin-bottom: 0;
+}
+.file-chat-body .md-content h1,
+.file-chat-body .md-content h2,
+.file-chat-body .md-content h3,
+.file-chat-body .md-content h4,
+.file-chat-body .md-content h5,
+.file-chat-body .md-content h6 {
+  font-size: 1rem;
+  margin: 0.7em 0 0.35em;
+  border-bottom: none;
+  padding-bottom: 0;
+}
+.file-chat-body .md-content p {
+  margin: 0.4em 0;
+}
+.file-chat-body .md-content ul,
+.file-chat-body .md-content ol {
+  padding-left: 1.3em;
+  margin: 0.4em 0;
+}
+.file-chat-body .md-content pre {
+  max-width: 100%;
+  overflow-x: auto;
+  margin: 0.5em 0;
+}
+.file-chat-body .md-content pre code {
+  font-size: 0.78rem;
+  line-height: 1.45;
+}
+.file-chat-body .md-content :not(pre) > code {
+  font-size: 0.82rem;
+  padding: 1px 4px;
+  border-radius: 4px;
+  background: var(--bg-hover, rgba(128, 128, 128, 0.15));
+}
+.file-chat-body .md-content table {
+  display: block;
+  max-width: 100%;
+  overflow-x: auto;
+  border-collapse: collapse;
+  font-size: 0.82rem;
+}
+.file-chat-body .md-content img {
+  max-width: 100%;
+  border-radius: 6px;
+}
+.file-chat-body .md-content .wikilink,
+.file-chat-body .md-content .wikilink-anchor {
+  color: var(--accent, #58a6ff);
+  cursor: pointer;
+}
 .file-chat-form {
  display: flex;
  gap: 8px;
@@ -1,6 +1,6 @@
 {
  "name": "obsigate",
-  "version": "2.62.0",
+  "version": "2.66.0",
  "description": "**Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.",
  "main": "patch.js",
  "directories": {
@@ -433,6 +433,30 @@ test("#110 — notification OS quand l'app est en arrière-plan", () => {
  }
 });

+// --- #193 : un post est rendu comme un document (markdown + code coloré) -----
+
+test("#193 — post avec html rendu : markdown + bloc de code", () => {
+  const list = document.createElement("div");
+  renderChatMessages(list, [{
+    id: "md1", user: "alice", text: "**gras**\n\n```python\nprint(1)\n```", ts: 400,
+    html: '<p><strong>gras</strong></p><pre><code class="language-python">print(1)</code></pre>',
+  }], "bruno");
+  const body = list.querySelector("[data-id='md1'] .file-chat-body");
+  assert.ok(body.classList.contains("file-chat-md"), "classe md posée sur le corps");
+  assert.ok(body.querySelector(".md-content"), "conteneur md-content");
+  assert.ok(body.querySelector(".md-content strong"), "markdown rendu (strong)");
+  assert.ok(body.querySelector("pre code.language-python"), "bloc de code conservé");
+});
+
+test("#193 — sans html, repli texte brut + URL cliquable", () => {
+  const list = document.createElement("div");
+  renderChatMessages(list, [{ id: "md2", user: "alice", text: "voir https://ex.com/a", ts: 401 }], "bruno");
+  const body = list.querySelector("[data-id='md2'] .file-chat-body");
+  assert.ok(!body.classList.contains("file-chat-md"), "pas de rendu markdown");
+  assert.ok(body.querySelector("a.file-chat-link"), "URL toujours cliquable");
+  assert.strictEqual(body.textContent, "voir https://ex.com/a", "texte intact");
+});
+
 // Sequential execution: each case depends on panel state left by the previous.
 for (const [name, fn] of cases) {
  try {
@@ -176,6 +176,19 @@ await test("filterSavedSearches combines with the type pills", async () => {
  assert.equal(visibleSaved(), 3, "clearing both filters restores everything");
 });

+// ── #194 : icône du dossier personnel ──
+await test("getVaultIcon returns the lucide house icon for home-* vaults", async () => {
+  const homeIcon = viewerMod.getVaultIcon("home-bruno", 16);
+  assert.equal(homeIcon.tagName.toLowerCase(), "i", "placeholder lucide (comme les autres icônes)");
+  assert.equal(homeIcon.getAttribute("data-lucide"), "home", "icône maison lucide");
+  assert.equal(homeIcon.style.width, "16px", "taille demandée respectée");
+});
+
+await test("getVaultIcon is unchanged for regular vaults", async () => {
+  const vaultIcon = viewerMod.getVaultIcon("Recettes", 16);
+  assert.equal(vaultIcon.tagName.toLowerCase(), "svg", "gemme violette SVG d'origine");
+});
+
 // ── Summary ──
 console.log(`\n${passCount}/${testCount} tests passed`);
 if (passCount !== testCount) {
@@ -481,4 +481,66 @@ class TestSecureCookies:
            assert "secure" in resp.headers.get("set-cookie", "").lower()
        finally:
            if hasattr(https_client, "close"):
-                https_client.close()
+                https_client.close()
+
+# ═══════════════════════════════════════════════════════════════════
+# Dossier personnel par utilisateur (#194)
+# ═══════════════════════════════════════════════════════════════════
+
+class TestUserHome:
+    def _login(self, client, username, password):
+        resp = client.post("/api/auth/login", json={
+            "username": username, "password": password,
+        })
+        return resp.json()["access_token"]
+
+    def test_create_user_provisions_home(self, auth_client, monkeypatch):
+        """POST /admin/users → dossier + vault home-<user> + isolation + retrait."""
+        from pathlib import Path
+
+        from backend import watcher_state
+
+        monkeypatch.setattr(watcher_state, "get_watcher", lambda: None)
+        home = Path.cwd() / "Home"
+        home.mkdir()
+        monkeypatch.setenv("OBSIGATE_HOME_ROOT", str(home))
+
+        admin = {"Authorization": f"Bearer {self._login(auth_client, 'admin', 'chab30')}"}
+
+        resp = auth_client.post("/api/auth/admin/users", headers=admin, json={
+            "username": "alice", "password": "testpass", "role": "user",
+        })
+        assert resp.status_code == 200
+        assert (home / "alice").is_dir()
+
+        names = [v["name"] for v in auth_client.get("/api/vaults", headers=admin).json()]
+        # #194 : « * » n'inclut pas les dossiers persos — l'admin ne voit pas
+        # le home d'alice (il ne verrait sinon celui de chaque utilisateur).
+        assert "home-alice" not in names
+        assert "TestVault" in names
+        # L'octroi atterrit bien dans le user
+        assert "home-alice" in resp.json()["vaults"]
+
+        # Isolation : alice ne voit QUE son propre dossier
+        alice = {"Authorization": f"Bearer {self._login(auth_client, 'alice', 'testpass')}"}
+        alice_names = [v["name"] for v in auth_client.get("/api/vaults", headers=alice).json()]
+        assert alice_names == ["home-alice"]
+
+        # Suppression du compte → vault refermé, dossier conservé
+        resp = auth_client.delete("/api/auth/admin/users/alice", headers=admin)
+        assert resp.status_code == 200
+        assert (home / "alice").is_dir()
+        names = [v["name"] for v in auth_client.get("/api/vaults", headers=admin).json()]
+        assert "home-alice" not in names
+
+    def test_create_user_without_home_root_is_unchanged(self, auth_client):
+        """Sans OBSIGATE_HOME_ROOT : aucun dossier, comportement historique."""
+        from pathlib import Path
+
+        assert Path.cwd().exists()
+        admin = {"Authorization": f"Bearer {self._login(auth_client, 'admin', 'chab30')}"}
+        resp = auth_client.post("/api/auth/admin/users", headers=admin, json={
+            "username": "nohome", "password": "testpass", "role": "user",
+        })
+        assert resp.status_code == 200
+        assert not (Path.cwd() / "Home").exists()
@@ -0,0 +1,142 @@
+# #196 — Partage dirigé entre utilisateurs : gate des pages /s/*, scope de
+# /api/shares, révocabilité, validation des destinataires.
+# Fixture admin_client (conftest.py) : users admin (role admin, vaults ["*"])
+# et normaluser (role user, vaults ["TestVault"]), auth activée.
+
+import os
+from pathlib import Path
+
+import pytest
+
+
+def _logged_client(username, password):
+    """Fresh TestClient with a session (cookie) — /s/* reads the access_token cookie."""
+    from fastapi.testclient import TestClient
+    from backend.main import app
+
+    c = TestClient(app)
+    resp = c.post("/api/auth/login", json={"username": username, "password": password})
+    assert resp.status_code == 200, resp.text
+    return c
+
+
+def _ensure_shared_file():
+    # admin_client chdir(tmp_path) mais le vault indexé est VAULT_1_PATH
+    # (absolu, résolu avant le chdir) → écrire là, pas dans cwd.
+    vault = Path(os.environ["VAULT_1_PATH"])
+    vault.mkdir(parents=True, exist_ok=True)
+    target = vault / "share_directed.md"
+    target.write_text("# Partagé\n\ncontenu dirigé\n", encoding="utf-8")
+    return "share_directed.md"
+
+
+@pytest.fixture
+def sessions(admin_client):
+    """admin (creator) and normaluser (recipient) clients, logged in via cookie."""
+    return _logged_client("admin", "chab30"), _logged_client("normaluser", "normal123")
+
+
+class TestDirectedShareGate:
+    def test_create_directed_share(self, sessions):
+        admin_client, _ = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        assert resp.status_code == 200, resp.text
+        body = resp.json()
+        assert body["shared_with"] == ["normaluser"]
+
+    def test_create_directed_unknown_recipient_rejected(self, sessions):
+        admin_client, _ = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["ghost"],
+        })
+        assert resp.status_code == 400
+
+    def test_recipient_can_view_but_anon_cannot(self, sessions):
+        admin_client, user_client = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        token = resp.json()["token"]
+
+        # Anonymous → 404 (pas 401/403 : on ne fuite pas l'existence du token)
+        from fastapi.testclient import TestClient
+        from backend.main import app
+        anon = TestClient(app)
+        assert anon.get(f"/s/{token}").status_code == 404
+
+        # Recipient (cookie de session via Bearer) → 200
+        assert user_client.get(f"/s/{token}").status_code == 200
+        # Creator → 200
+        assert admin_client.get(f"/s/{token}").status_code == 200
+
+    def test_other_user_cannot_view(self, sessions):
+        admin_client, _ = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["admin"],  # dirigé, mais pas normaluser
+        })
+        token = resp.json()["token"]
+        other = _logged_client("normaluser", "normal123")
+        assert other.get(f"/s/{token}").status_code == 404
+
+    def test_public_share_still_anonymous(self, sessions):
+        admin_client, _ = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={"path": path})
+        token = resp.json()["token"]
+        from fastapi.testclient import TestClient
+        from backend.main import app
+        anon = TestClient(app)
+        assert anon.get(f"/s/{token}").status_code == 200
+
+    def test_shares_list_scoped_for_user(self, sessions):
+        admin_client, user_client = sessions
+        path = _ensure_shared_file()
+        admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        # normaluser (non-admin) voit le partage reçu
+        resp = user_client.get("/api/shares")
+        assert resp.status_code == 200
+        tokens = [s["token"] for s in resp.json()]
+        assert tokens, "destinataire doit voir le partage reçu"
+
+        # Un admin voit tout
+        resp = admin_client.get("/api/shares")
+        assert resp.status_code == 200
+        assert len(resp.json()) >= 1
+
+    def test_recipient_cannot_revoke(self, sessions):
+        admin_client, user_client = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        sid = resp.json()["id"]
+        resp = user_client.delete(f"/api/share/{sid}")
+        assert resp.status_code == 403
+
+    def test_creator_can_revoke(self, sessions):
+        admin_client, _ = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        sid = resp.json()["id"]
+        assert admin_client.delete(f"/api/share/{sid}").status_code == 200
+
+    def test_revoke_cuts_recipient_access(self, sessions):
+        admin_client, user_client = sessions
+        path = _ensure_shared_file()
+        resp = admin_client.post("/api/share/TestVault", json={
+            "path": path, "shared_with": ["normaluser"],
+        })
+        body = resp.json()
+        assert user_client.get(f"/s/{body['token']}").status_code == 200
+        admin_client.delete(f"/api/share/{body['id']}")
+        assert user_client.get(f"/s/{body['token']}").status_code == 404
@@ -1,6 +1,7 @@
 # tests/test_file_chat.py — Chat par fichier (#169)
 """Store + REST routes for the per-file chat history."""

+import json
 import time

 import pytest
@@ -479,3 +480,73 @@ class TestReadReceipts:
        assert [e for e, _ in events] == ["chat_read"]
        assert events[0][1]["user"] == "anonymous"
        assert events[0][1]["vault"] == "__global__"
+
+
+# ═══════════════════════════════════════════════════════════════════
+# #193 — un post est rendu comme un document markdown
+# ═══════════════════════════════════════════════════════════════════
+
+class TestMarkdownRendering:
+    """Le post porte son HTML (mistune + sanitizer), comme une prévisualisation
+    de document : le client n'a plus à réimplémenter le markdown."""
+
+    def test_message_carries_rendered_html(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_store, "CHAT_DIR", tmp_path / "chats")
+        msg = _store.add_message("V", "a.md", "u", "**gras** et `code`")
+        assert "<strong>gras</strong>" in msg["html"]
+        assert "<code>code</code>" in msg["html"]
+        got = _store.get_messages("V", "a.md")
+        assert "<strong>gras</strong>" in got[0]["html"]
+
+    def test_html_is_not_persisted(self, tmp_path, monkeypatch):
+        """`html` est recalculé à chaque lecture, jamais écrit dans le store."""
+        chat_dir = tmp_path / "chats"
+        monkeypatch.setattr(_store, "CHAT_DIR", chat_dir)
+        _store.add_message("V", "a.md", "u", "**gras**")
+        raw = json.loads(next(chat_dir.glob("*.json")).read_text(encoding="utf-8"))
+        assert "html" not in raw["messages"][0]
+
+    def test_fenced_code_block_keeps_its_language(self, tmp_path, monkeypatch):
+        """La classe `language-xxx` est ce sur quoi hljs se branche (comme dans
+        le viewer)."""
+        monkeypatch.setattr(_store, "CHAT_DIR", tmp_path / "chats")
+        msg = _store.add_message("V", "a.md", "u", "```python\nprint(1)\n```")
+        assert 'class="language-python"' in msg["html"]
+
+    def test_tables_and_lists_are_rendered(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_store, "CHAT_DIR", tmp_path / "chats")
+        msg = _store.add_message("V", "a.md", "u", "- un\n- deux")
+        assert "<ul>" in msg["html"] and "<li>un</li>" in msg["html"]
+
+    def test_raw_html_is_sanitized(self, tmp_path, monkeypatch):
+        """Pas de XSS par le chat : le sanitizer des documents s'applique."""
+        monkeypatch.setattr(_store, "CHAT_DIR", tmp_path / "chats")
+        msg = _store.add_message("V", "a.md", "u", "<script>alert(1)</script>ok")
+        assert "<script" not in msg["html"]
+
+    def test_routes_return_html(self, client, test_vault_dir):
+        r = client.post(
+            "/api/file/TestVault/chat",
+            json={"path": "note1.md", "text": "## Titre\n\n- item"},
+        )
+        assert r.status_code == 200
+        html = r.json()["message"]["html"]
+        assert "<h2" in html and "<li>item</li>" in html
+        r2 = client.get("/api/file/TestVault/chat", params={"path": "note1.md"})
+        assert "<h2" in r2.json()["messages"][0]["html"]
+
+    def test_sse_broadcast_carries_html(self, client, test_vault_dir, monkeypatch):
+        """L'écho SSE part avec le html : les autres clients n'attendent pas un
+        refresh pour voir le rendu."""
+        from backend.routers import file_chat as _router
+
+        events = []
+
+        class _Spy:
+            async def broadcast(self, event, data):
+                events.append((event, data))
+
+        monkeypatch.setattr(_router, "sse_manager", _Spy())
+        client.post("/api/chat", json={"text": "**fort**"})
+        assert events and events[0][0] == "chat_message"
+        assert "<strong>fort</strong>" in events[0][1]["message"]["html"]
@@ -0,0 +1,266 @@
+# tests/test_user_home.py — #194 dossier personnel par utilisateur
+import asyncio
+import json
+import os
+
+import pytest
+
+
+def _run(coro):
+    loop = asyncio.new_event_loop()
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+
+@pytest.fixture
+def home_env(tmp_path, monkeypatch):
+    """Racine Home + registre vaults + users.json isolés, globals sauvegardés."""
+    root = tmp_path / "Home"
+    root.mkdir()
+    monkeypatch.setenv("OBSIGATE_HOME_ROOT", str(root))
+
+    from backend import indexer
+
+    monkeypatch.setattr(indexer, "DYNAMIC_VAULTS_FILE", tmp_path / "vaults.json")
+
+    from backend.auth import user_store
+
+    monkeypatch.setattr(user_store, "USERS_FILE", tmp_path / "users.json")
+
+    from backend import watcher_state
+
+    monkeypatch.setattr(watcher_state, "get_watcher", lambda: None)
+
+    saved_index = dict(indexer.index)
+    saved_config = dict(indexer.vault_config)
+    yield root
+    indexer.index.clear()
+    indexer.index.update(saved_index)
+    indexer.vault_config.clear()
+    indexer.vault_config.update(saved_config)
+
+
+def _create_user(name: str) -> dict:
+    from backend.auth.user_store import create_user
+
+    return create_user(name, "Motdepasse1!", role="user")
+
+
+def _registry() -> dict:
+    """Contenu du registre dynamique (chemin monkeypatché par home_env)."""
+    from backend import indexer
+
+    return json.loads(indexer.DYNAMIC_VAULTS_FILE.read_text(encoding="utf-8"))
+
+
+class TestEnsureUserHome:
+    def test_creates_folder_vault_and_grant(self, home_env):
+        from backend.auth.user_store import get_user
+        from backend.indexer import index
+        from backend.user_home import ensure_user_home
+
+        _create_user("alice")
+        name = _run(ensure_user_home("alice"))
+
+        assert name == "home-alice"
+        assert (home_env / "alice").is_dir()
+        assert "home-alice" in index
+        assert "home-alice" in get_user("alice")["vaults"]
+        # Registre persistant rempli → survit au prochain rebuild/redémarrage
+        assert "home-alice" in _registry()["vaults"]
+
+    def test_is_idempotent(self, home_env):
+        from backend.auth.user_store import get_user
+        from backend.indexer import index
+        from backend.user_home import ensure_user_home
+
+        _create_user("bob")
+        _run(ensure_user_home("bob"))
+        index_snapshot = dict(index)
+        _run(ensure_user_home("bob"))
+
+        assert get_user("bob")["vaults"].count("home-bob") == 1
+        assert index == index_snapshot
+
+    def test_invalid_username_never_touches_disk(self, home_env):
+        from backend.indexer import index
+        from backend.user_home import ensure_user_home
+
+        assert _run(ensure_user_home("../evil")) is None
+        assert _run(ensure_user_home("a/b")) is None
+        assert not (home_env.parent / "evil").exists()
+        assert not any(name.startswith("home-") for name in index)
+
+    def test_disabled_without_env(self, home_env, monkeypatch):
+        from backend.user_home import ensure_user_home
+
+        monkeypatch.delenv("OBSIGATE_HOME_ROOT")
+        assert _run(ensure_user_home("alice")) is None
+        assert not (home_env / "alice").exists()
+
+
+class TestPersistence:
+    def test_registry_reloaded_by_load_vault_config(self, home_env):
+        """data/vaults.json doit être relu par load_vault_config (rebuild/restart)."""
+        from backend import indexer
+
+        _create_user("carol")
+        from backend.user_home import ensure_user_home
+
+        _run(ensure_user_home("carol"))
+
+        # Simule un redémarrage : vault_config vidé, rechargé depuis la source
+        indexer.vault_config.clear()
+        config = indexer.load_vault_config()
+        assert config["home-carol"]["path"] == str(home_env / "carol")
+
+    def test_unpersist_drops_registry_entry(self, home_env):
+        from backend import indexer
+        from backend.user_home import ensure_user_home
+
+        _create_user("dan")
+        _run(ensure_user_home("dan"))
+        indexer.unpersist_vault("home-dan")
+        assert "home-dan" not in _registry()["vaults"]
+
+
+class TestRelease:
+    def test_release_closes_vault_but_keeps_folder(self, home_env):
+        from backend.indexer import index
+        from backend.user_home import ensure_user_home, release_user_home
+
+        _create_user("erin")
+        _run(ensure_user_home("erin"))
+        assert "home-erin" in index
+
+        _run(release_user_home("erin"))
+        assert "home-erin" not in index
+        assert (home_env / "erin").is_dir()  # décision : dossier conservé
+        assert "home-erin" not in _registry()["vaults"]
+
+
+class TestOrphanSweep:
+    def test_orphan_home_released_when_user_deleted_outside_route(self, home_env):
+        """create_admin.py delete ne passe pas par la route → réparé au boot."""
+        from backend.auth.user_store import delete_user
+        from backend.indexer import index
+        from backend.user_home import ensure_all_user_homes, ensure_user_home
+
+        _create_user("hank")
+        _run(ensure_user_home("hank"))
+        delete_user("hank")
+        assert "home-hank" in index
+
+        _run(ensure_all_user_homes())
+        assert "home-hank" not in index
+        assert (home_env / "hank").is_dir()
+
+    def test_vault_named_home_outside_root_is_left_alone(self, home_env):
+        """Un vault admin nommé « home-… » ailleurs dans le FS n'est pas touché."""
+        from backend.indexer import index
+        from backend.user_home import ensure_all_user_homes
+
+        other = home_env.parent / "Elsewhere"
+        other.mkdir()
+        _run(add_vault("home-keep", str(other)))
+
+        _run(ensure_all_user_homes())
+        assert "home-keep" in index
+
+
+def add_vault(name: str, path: str):
+    from backend.indexer import add_vault_to_index
+
+    return add_vault_to_index(name, path)
+
+
+class TestIsolation:
+    def test_user_cannot_access_another_home_vault(self, home_env):
+        from backend.auth.middleware import check_vault_access
+        from backend.auth.user_store import get_user
+        from backend.user_home import ensure_user_home
+
+        _create_user("alice")
+        _create_user("bob")
+        _run(ensure_user_home("alice"))
+        _run(ensure_user_home("bob"))
+
+        assert check_vault_access("home-alice", get_user("alice")) is True
+        assert check_vault_access("home-alice", get_user("bob")) is False
+        assert check_vault_access("home-bob", get_user("alice")) is False
+
+    def test_wildcard_admin_does_not_cover_homes(self, home_env):
+        """#194 : « * » n'inclut JAMAIS un dossier perso, même pour l'admin."""
+        from backend.auth.middleware import check_vault_access
+        from backend.auth.user_store import create_user, get_user
+        from backend.user_home import ensure_user_home
+
+        create_user("root", "Motdepasse1!", role="admin", vaults=["*"])
+        _create_user("alice")
+        _run(ensure_user_home("alice"))
+
+        admin = get_user("root")
+        assert check_vault_access("home-alice", admin) is False  # pas le sien
+        assert check_vault_access("TestVault", admin) is True  # « * » intact
+
+        # L'octroi explicite suffit (y compris pour l'admin, cf. _grant)
+        _run(ensure_user_home("root"))
+        assert check_vault_access("home-root", get_user("root")) is True
+
+
+class TestSearchFiltering:
+    def test_search_service_filters_before_pagination(self, monkeypatch):
+        """#194 : /api/search ne doit pas renvoyer les notes d'un autre user."""
+        import backend.search as search_mod
+        from backend.services import search as search_service
+
+        hits = [
+            {"vault": "home-bruno", "path": "secret.md"},
+            {"vault": "TestVault", "path": "note.md"},
+            {"vault": "home-bruno", "path": "autre.md"},
+        ]
+        monkeypatch.setattr(
+            search_mod, "search",
+            lambda q, vault_filter="all", tag_filter=None: list(hits),
+        )
+
+        page = search_service.search_vaults("x", limit=50, is_allowed=lambda v: v == "TestVault")
+        assert page["total"] == 1, "total = résultats filtrés"
+        assert [r["vault"] for r in page["results"]] == ["TestVault"]
+
+        # Sans filtre (tool layer, qui filtre lui-même) : inchangé.
+        assert search_service.search_vaults("x", limit=50)["total"] == 3
+
+
+class TestEnsureAll:
+    def test_repairs_every_existing_user(self, home_env):
+        from backend.auth.user_store import get_user
+        from backend.user_home import ensure_all_user_homes
+
+        _create_user("fab")
+        _create_user("gab")
+        # Dossier supprimé à la main + user créé hors API (pas de vault)
+        (home_env / "fab").mkdir()
+        (home_env / "fab").rmdir()
+
+        created = _run(ensure_all_user_homes())
+
+        assert created == 2
+        assert (home_env / "fab").is_dir()
+        assert (home_env / "gab").is_dir()
+        assert "home-fab" in get_user("fab")["vaults"]
+        assert "home-gab" in get_user("gab")["vaults"]
+
+
+def test_home_root_env_contract():
+    """OBSIGATE_HOME_ROOT absent → fonctionnalité inactive (dev/tests/desktop)."""
+    from backend.user_home import home_root
+
+    saved = os.environ.pop("OBSIGATE_HOME_ROOT", None)
+    try:
+        assert home_root() is None
+    finally:
+        if saved is not None:
+            os.environ["OBSIGATE_HOME_ROOT"] = saved
Author	SHA1	Message	Date
bruno	49c715199d	feat: partage dirigÃ© entre utilisateurs #196 CI / test (push) Canceled after 0s Details CI / security (push) Canceled after 0s Details CI / build (push) Canceled after 0s Details CI / e2e (push) Canceled after 0s Details CI / lint (push) Canceled after 1m29s Details - create_share/shared_with + validation des destinataires - gate auth sur /s/{token} (+pdf, raw) : 404 opaque hors crÃ©ateur/admin/destinataires - GET /api/shares scopÃ© (non-admin = crÃ©Ã©s + reÃ§us), rÃ©vocation crÃ©ateur/admin - UI : dialogue dirigÃ©/public + destinataires, dashboard Â« partagÃ© par X Â» - i18n FR/EN, tests test_directed_shares.py (9), fiche feature	2026-10-10 20:14:29 -04:00
bruno	fd192df036	fix: admin — icône fermeture modale utilisateurs + sections du dashboard affichées une à la fois BUG-111 CI / lint (push) Successful in 2m54s Details CI / security (push) Successful in 1m41s Details CI / test (push) Successful in 4m36s Details CI / build (push) Successful in 1m34s Details CI / e2e (push) Successful in 17m56s Details	2026-10-10 17:17:14 -04:00
bruno	8662d23ec8	fix: un dossier perso n'est plus visible par les autres comptes #194 CI / lint (push) Successful in 2m57s Details CI / security (push) Successful in 1m40s Details CI / test (push) Successful in 4m39s Details CI / build (push) Successful in 1m34s Details CI / e2e (push) Successful in 17m44s Details L'admin (vaults: [""]) voyait le home de chaque utilisateur dans sa barre latérale : "" ouvrait tous les vaults, home-* compris. - backend/auth/middleware.py : check_vault_access exige un octroi explicite pour tout vault home-* (nouveau is_home_vault()). - Filtres « * » en dur remplacés par check_vault_access : dashboard, conflits, liens retour, favoris, abonnements push. - /api/search : search_vaults(is_allowed=…) filtre les bruts avant pagination (total et page restent justes). - backend/user_home.py : _grant n'écarte plus les comptes « * » — l'admin reçoit son propre home-admin (auto-réparé au démarrage). - Tests : test_user_home.py +2, assertion API inversée dans test_auth_api.py (admin ne voit plus home-alice).	2026-10-10 16:42:00 -04:00
bruno	10453d8dfe	feat: dossier perso (#194 ) — vaults home-* en tête de l'arborescence, icône maison, compose de test CI / lint (push) Successful in 3m1s Details CI / security (push) Successful in 1m41s Details CI / test (push) Successful in 4m37s Details CI / build (push) Successful in 1m34s Details CI / e2e (push) Successful in 17m40s Details - frontend/js/sidebar.js : tri stable _homeFirst appliqué à la source des deux listes de vaults (loadVaults + soft refresh) → les vaults home-<user> passent en premier, arborescence et sélecteurs cohérents. - frontend/js/viewer.js : getVaultIcon renvoie l'icône lucide "home" pour home-* (même safeCreateIcons / stroke currentColor que les autres). - docker-compose.test-win.yml : montage test_home:/vaults/Home + OBSIGATE_HOME_ROOT=/vaults/Home pour tester la feature en local ; test_home/ ajouté au .gitignore. - Tests : sidebar-filters.test.mjs +2 (icône maison, gemme violette inchangée), vérifié live sur l'instance 2020 (ordre + svg.lucide-home).	2026-10-10 16:09:59 -04:00
bruno	8235d632b8	feat: dossier personnel par utilisateur — vault home-<user> + registre de vaults persistant #194 CI / lint (push) Canceled after 0s Details CI / test (push) Canceled after 0s Details CI / security (push) Canceled after 0s Details CI / build (push) Canceled after 0s Details CI / e2e (push) Canceled after 0s Details - backend/user_home.py : ensure_user_home()/release_user_home() idempotents (mkdir, vault, watcher, octroi dans user.vaults), rappelés à la création d'un compte et au démarrage (migration + réparation + sweep des vaults home-* orphelins), dossier conservé à la suppression. - backend/indexer.py : data/vaults.json, registre persistant des vaults ajoutés à la volée, fusionné par load_vault_config() — ils disparaissaient au premier reindex complet et au redémarrage. reload_single_vault remet vault_config[name] après remove_vault_from_index. - backend/auth/router.py + routers/vaults.py : appels ensure/release + persistance à l'ajout/retrait d'un vault. - docker-compose.yml : montage unique /NFS/OBSIDIAN_DOC/Home:/vaults/Home + OBSIGATE_HOME_ROOT (absente = fonctionnalité inactive). - Tests : tests/test_user_home.py (12) + tests/test_auth_api.py::TestUserHome (2).	2026-10-10 00:40:35 -04:00
bruno	f4c8504c8d	feat: chat — les posts affichent le markdown rendu comme un document, code coloré #193 CI / lint (push) Successful in 2m50s Details CI / security (push) Successful in 1m37s Details CI / test (push) Successful in 4m34s Details CI / build (push) Successful in 1m31s Details CI / e2e (push) Successful in 17m36s Details	2026-10-09 15:48:04 -04:00
@@ -1 +1 @@
 .62.0
 .66.0