Qui a ouvert ce dossier, par quel chemin, et à quel titre ? Un logiciel de santé doit pouvoir répondre à cette question pour chaque accès, y compris quand la lecture vient d'un agent IA. Cet article décrit une façon de le faire, avec trois schémas et quelques extraits de code. Il traite d'un logiciel utilisé pendant la prise en charge : dossier patient, téléconsultation, coordination des soins. Les entrepôts de données et la recherche posent d'autres questions.
Ce que demandent les textes
En France, le référentiel d'imputabilité de la PGSSI-S (v1.0, décembre 2014) décrit la piste d'audit attendue. Elle doit pouvoir se restituer au minimum par utilisateur ou machine, par type d'action, par date et heure et par cible de l'action, par exemple le dossier de quel patient. Le même référentiel demande de documenter les éléments de traçabilité recueillis, leur conservation et leur restitution. Il précise que des traces contenant des données de santé ne sont accessibles qu'aux professionnels de santé et aux personnels techniques placés sous leur responsabilité.
Au niveau européen, l'annexe II du règlement EHDS (point 3.2) demande au journal d'un système de dossier médical électronique d'enregistrer, à chaque accès, qui a accédé, quelles catégories de données, la date et l'heure, et l'origine des données. Le point 3.3 ajoute des outils pour passer en revue et analyser le journal. Le règlement s'applique à partir du 26 mars 2027, et ces exigences aux systèmes de DME selon un calendrier qui va jusqu'au 26 mars 2031.
Les deux textes vont dans le même sens : une trace par accès, et quelqu'un qui la lit.
Six chemins mènent au dossier

Le praticien devant son écran est le chemin le plus visible. Un logiciel de santé en a cinq autres :
- l'agent IA, qui lit au nom d'un praticien, avec ses droits
- le serveur MCP, par lequel un assistant externe se branche sur le dossier
- l'outil tiers, un autre logiciel qui appelle l'API
- l'administrateur, pour le support et l'exploitation
- le prestataire externe, pour la maintenance ou l'hébergement
Une trace posée dans l'écran ne voit que le premier. La trace se place donc plus bas, côté serveur, dans la couche par laquelle passent toutes les lectures.
Ce que le journal enregistre

Une ligne par accès, lectures comprises. Ouvrir un dossier sans raison ne modifie rien : sans trace de lecture, l'accès n'existe nulle part.
Chaque ligne répond à quatre questions.
- Qui : la personne qui répond de l'accès, et le chemin emprunté.
- Quoi : le patient, la ressource lue, l'action.
- Quand : une date posée par la base elle-même.
- À quel titre : dans le cas courant, un lien de prise en charge, c'est-à-dire un rendez-vous, un séjour ou l'appartenance à l'équipe de soins. Hors de ce lien, l'utilisateur déclare un « bris de glace » et écrit un motif.
Deux règles se vérifient dans la base elle-même, pour qu'aucun chemin ne puisse les oublier :
-- Règle 1 : un accès au titre de la prise en charge désigne laquelle,
-- tout autre accès porte un motif écrit
CONSTRAINT titre_justifie CHECK (
(titre = 'prise_en_charge' AND prise_en_charge_id IS NOT NULL)
OR (titre <> 'prise_en_charge' AND motif IS NOT NULL AND length(trim(motif)) >= 10)
),
-- Règle 2 : un accès par agent ou par MCP nomme l'agent
CONSTRAINT agent_nomme CHECK (
chemin NOT IN ('agent', 'mcp') OR agent_id IS NOT NULL
)
Un détail m'a piégé en écrivant cet exemple. Ma première version de la règle 1 n'avait pas motif IS NOT NULL. Avec un motif absent, l'expression vaut NULL, et PostgreSQL accepte une contrainte CHECK qui vaut NULL. Le bris de glace sans motif passait. Seul un test l'a montré.
Le journal se protège comme une donnée sensible, puisqu'il dit quel patient a été vu par qui. Le compte de l'application y ajoute des lignes, sans pouvoir les lire, les modifier ou les supprimer. La lecture est réservée aux personnes chargées de la revue.
Comment une lecture se déroule

Chaque lecture passe par une fonction qui vérifie le droit, écrit la ligne, puis lit la donnée. Les trois étapes tiennent dans une seule transaction. Si le journal refuse la ligne, la donnée n'est pas rendue.
tx, err := d.db.BeginTx(ctx, nil)
if err != nil {
return "", err
}
defer tx.Rollback()
// La ligne de journal part avant la lecture, dans la même transaction.
_, err = tx.ExecContext(ctx, `
INSERT INTO acces_journal
(acteur_id, chemin, agent_id, requete_id, patient_id,
ressource, ressource_id, action, titre, prise_en_charge_id, motif)
VALUES ($1, $2, $3, $4, $5, 'compte_rendu', $6, 'lire', $7, $8, $9)`,
a.ActeurID, a.Chemin, vide(a.AgentID), a.RequeteID, patientID,
id, a.Titre, vide(a.PriseEnChargeID), vide(a.Motif))
if err != nil {
return "", fmt.Errorf("journal des accès : %w", err) // ligne refusée : rien n'est lu
}
var contenu string
err = tx.QueryRowContext(ctx,
`SELECT contenu FROM compte_rendu WHERE id = $1 AND patient_id = $2`,
id, patientID).Scan(&contenu)
Le même principe vaut dans tout langage : la fonction est le seul chemin vers la table, et une lecture sans contexte est refusée. Un traitement de nuit ou un script interne dit lui aussi au nom de qui il lit.
Cet extrait a une limite : une lecture qui échoue annule la transaction, donc aussi sa ligne de journal. Les tentatives refusées méritent leur propre trace, écrite hors de la transaction.
Quand le lecteur est un agent
Un agent qui prépare une consultation lit plusieurs ressources pour une seule question du praticien. Si le journal n'enregistre que le praticien, la revue voit un médecin qui ouvre de nombreux documents en une seconde. Si le journal n'enregistre que l'agent, plus personne ne répond de l'accès.
Le journal garde donc les deux identités, plus un identifiant commun à toutes les lectures d'une même demande. Ce que le serveur peut écrire dépend de la façon dont l'agent arrive.
| Cas | Ce que le serveur sait sans aide | Ce que le client doit transmettre |
|---|---|---|
| Agent intégré au produit, côté serveur | Le praticien, l'agent, sa version, la demande | Rien |
| Agent externe, par MCP ou API | Le praticien et l'application cliente, par le jeton | L'agent, sa version, l'identifiant de la demande |
| Agent qui pilote l'écran du praticien | Le praticien seul | Rien : l'agent est invisible pour le serveur |
Quatre points distinguent un agent d'un utilisateur dans le journal.
Ce qui est prouvé vient du jeton. Dans la spécification MCP, le client est un client OAuth 2.1 qui agit pour le compte de l'utilisateur. Le serveur vérifie le jeton et en tire deux identités : le praticien, et l'application cliente.
L'application cliente n'est pas l'agent. Le jeton désigne un logiciel. Le nom de l'agent, sa version et le modèle utilisé sont déclarés par le client, et le serveur ne peut pas les vérifier. Le journal les range dans des champs à part, marqués comme déclarés. D'après la documentation de WSO2 sur MCP, la spécification n'impose pas d'identifier l'agent lui-même. Un projet de l'IETF, décrit par WorkOS en avril 2026, étend OAuth pour porter l'identité de l'agent dans le jeton. Ce projet n'est pas encore une norme.
L'identifiant de la demande vient du client. Le serveur voit dix lectures. Il ne sait pas qu'elles répondent à une seule question. Sans cet identifiant, il ne reste que la session ou la proximité dans le temps pour les regrouper.
Le journal reste hors de portée de l'agent. Le guide de l'ANSSI Sécuriser un système IA agentique (V1.0, 30/10/2026, mesure 7.4) demande de garder les journaux à l'abri des modifications de l'agent, pour pouvoir reconstituer la séquence demande, autorisation, action, résultat.
Le contexte se construit là où la demande entre, par exemple dans le serveur MCP :
ctx = AvecAcces(ctx, Acces{
ActeurID: jeton.Utilisateur, // prouvé : le praticien qui a autorisé l'assistant
Chemin: "mcp",
AgentID: jeton.Client, // prouvé : l'application cliente
RequeteID: idDeLaDemande, // transmis par le client, commun à toutes ses lectures
Titre: "prise_en_charge",
PriseEnChargeID: priseEnCharge,
})
La revue peut alors répondre à une question nouvelle : qu'a lu cet agent, pour quelle demande, au nom de qui.
Le texte de la PGSSI-S date de 2014. Il parle d'utilisateur ou de machine, et ne prévoit pas un agent qui agit au nom d'un utilisateur. Garder les deux identités est ma lecture. Je ne l'ai lu dans aucun des textes cités ici.
L'accès qui ne laisse aucune ligne
Un administrateur ou un prestataire qui se connecte à la base avec un client SQL contourne la couche. Aucune ligne n'est écrite. C'est la flèche en pointillé du premier schéma.
Trois mesures réduisent ce trou, sans le fermer :
- Des comptes nominatifs pour l'administration, jamais le compte de l'application.
- Un journal du moteur de base pour ces comptes. Sous PostgreSQL, l'extension pgaudit journalise les lectures d'un rôle donné. Je ne l'ai pas testée pour cet article.
- Un accès de maintenance ouvert pour une durée et un motif, avec une ligne au journal applicatif à l'ouverture.
L'export pose la même question. Un fichier sorti de la base ne laisse plus de trace une fois copié. La ligne de journal se place donc au moment de l'export.
La revue : le journal ne sert que s'il est lu
Deux requêtes simples suffisent pour commencer : les accès hors prise en charge, et les accès où l'utilisateur porte le nom du patient. Voici la première.
SELECT j.horodatage::date AS jour, u.nom AS acteur, j.chemin,
p.nom AS patient, j.ressource, j.titre, j.motif
FROM acces_journal j
JOIN utilisateur u ON u.id = j.acteur_id
JOIN patient p ON p.id = j.patient_id
WHERE j.horodatage >= now() - interval '7 days'
AND j.titre <> 'prise_en_charge'
ORDER BY j.horodatage;
Le reste est de l'organisation. Les requêtes tournent chaque semaine, une personne désignée lit le résultat et le signe, et le résultat signé se conserve. C'est cette signature qui permet à un dirigeant de répondre en personne à un régulateur.
Ce que cette approche ne règle pas
- Le motif se remplit vite. Un champ libre n'arrête pas quelqu'un qui écrit « urgence patient ». La revue lit les motifs sans pouvoir les vérifier.
- Le nom de famille est un critère grossier. Il signale des homonymes et laisse passer un conjoint, un voisin ou un collègue.
- Les listes et les recherches. Une recherche par nom affiche des patients sans ouvrir de dossier. Les exemples ne tracent que la lecture d'un document.
- Le volume et la durée de conservation. Un agent multiplie les lignes. Le référentiel d'imputabilité de la PGSSI-S reprend une recommandation de la CNIL : des journaux d'activité conservés sur six mois glissants au plus, sauf obligation légale. Ce texte date de 2014. La durée est à vérifier contre la doctrine actuelle avant de la fixer.
- L'agent qui pilote l'écran. Un agent qui utilise la session du praticien dans son navigateur ne laisse que la trace du praticien. Seul le rythme des lectures peut le signaler, sans le prouver.
- Le lien de prise en charge suppose que le logiciel le connaisse. Sans rendez-vous, séjour ou équipe de soins en base, tout accès devient un bris de glace et le signal se perd.
- Le propriétaire de la base. Un superutilisateur peut réécrire le journal. La PGSSI-S évoque pour cela un scellement des traces, que ces exemples ne font pas.
Les exemples SQL ont été exécutés sur PostgreSQL 16 le 14/11/2026, avec un petit jeu d'essai. L'extrait Go vient d'un code qui compile, et que je n'ai pas exécuté contre la base. Tous sont un point de départ à adapter au modèle de données de chaque produit. Lire ensemble le code, le journal et les textes qui s'y appliquent, c'est l'objet de Sonar Express.
Dans votre produit, une simple lecture de dossier laisse-t-elle une ligne ?
Sources
- The Register, 13/11/2026 (lettre de l'ICO du 12/11/2026)
- PGSSI-S, référentiel d'imputabilité v1.0 (ASIP Santé, décembre 2014), pages 17, 18 et 21
- EHDS, règlement (UE) 2025/327, annexe II, points 3.2 et 3.3
- ANSSI, Sécuriser un système IA agentique, V1.0 (30/10/2026), mesure 7.4
- Spécification MCP, autorisation (version du 18/06/2025)
- WSO2 Identity Server, MCP
- WorkOS, 28/04/2026, projet IETF d'extension d'OAuth aux agents