discovery-media-player 0.1.145 → 0.1.147

package/context/standalone.js

@@ -712,8 +712,58 @@ function createStandaloneContext(env = process.env) {
       // avec une SÉPARATION DE DOMAINE (préfixe distinct) — il est déjà requis par la fonctionnalité
       // qui produit ce hachage, ce qui évite une variable obligatoire de plus.
       ipHashSecret: String(env.PLAYER_IP_HASH_SECRET || env.PLAYER_PRESENCE_SECRET || ""),
+      retention: retentionDepuisEnv(env),
     },
   };
 }
 
-module.exports = { createStandaloneContext, creerLimites };
+/**
+ * La rétention, telle qu'un hôte AUTONOME peut la décider — et il ne le pouvait pas.
+ *
+ * ⚠️ CE FICHIER N'EXPOSAIT AUCUNE CLÉ DE RÉTENTION, ce qui rendait le balayage inatteignable pour
+ * quiconque consomme ce contexte tel quel. `server/retention.js` exige `config.retention.balayage
+ * === true`, et cet opt-in strict est juste : les fenêtres sont des décisions MÉTIER — ce qu'un
+ * conseiller peut encore prouver à un client — et une suppression ne doit agir que là où un
+ * exploitant l'a ÉCRITE. Mais un hôte autonome n'avait nulle part où l'écrire. Seuls ceux qui
+ * rédigent leur contexte à la main pouvaient armer la purge ; les autres accumulaient sans
+ * recours, et sans même savoir que le recours existait. Un opt-in dont la moitié du parc ne peut
+ * pas se saisir n'est pas un opt-in, c'est une indisponibilité.
+ *
+ * ⚠️ ET LES FENÊTRES VIENNENT AVEC, PAS SEULEMENT L'INTERRUPTEUR. N'exposer que `balayage`
+ * armerait la purge SUR NOS DÉFAUTS — exactement ce que le commentaire de `retention.js` décrit
+ * comme le mode de panne du second hôte, cette fois par une variable au lieu d'un oubli. Qui arme
+ * doit pouvoir décider ce qu'il arme.
+ *
+ * ⚠️ UNE CLÉ ABSENTE EST ABSENTE, JAMAIS `undefined`. `fenetresValidees` fusionne cet objet
+ * PAR-DESSUS les défauts : y poser `journauxMois: undefined` ferait échouer la validation et
+ * refuserait toute suppression chez un hôte qui a simplement armé sans régler les mois. La valeur
+ * n'entre donc que si la variable porte quelque chose.
+ *
+ * ⚠️ ET UNE VALEUR ILLISIBLE N'EST PAS CORRIGÉE ICI. `Number("abc")` vaut `NaN`, `"12.5"` n'est pas
+ * entier : le cœur les REFUSE en nommant la clé, avant le premier DELETE. La rattraper ici la
+ * rendrait silencieuse, et une purge est le dernier endroit où deviner.
+ */
+// ⚠️ ET LES QUATRE LECTURES SONT ÉCRITES EN CLAIR, PAS BOUCLÉES SUR UNE TABLE DE NOMS. La première
+// version faisait `env[TABLE[cle]]` — plus court, et refusé par `tools/env-lues.mjs` : un nom
+// d'environnement construit à l'exécution n'est trouvable par personne. Ni un `grep`, ni la garde
+// qui vérifie que chaque variable lue est documentée. La concision se paierait sur une variable
+// oubliée dans `docs/CONFIGURATION.md`, que rien ne rattraperait.
+function poserMois(out, cle, brut) {
+  const t = String(brut || "").trim();
+  // ⚠️ Absente = ABSENTE. `fenetresValidees` fusionne cet objet PAR-DESSUS les défauts : y poser
+  // `undefined` ferait échouer la validation et refuserait toute purge chez un hôte qui a
+  // simplement armé sans régler les mois.
+  if (t) out[cle] = Number(t);
+}
+
+function retentionDepuisEnv(env) {
+  const out = {};
+  if (String(env.PLAYER_RETENTION_SWEEP || "") === "1") out.balayage = true;
+  poserMois(out, "journauxMois", env.PLAYER_RETENTION_LOGS_MONTHS);
+  poserMois(out, "presentationsMois", env.PLAYER_RETENTION_PRESENTATIONS_MONTHS);
+  poserMois(out, "liensRevoquesMois", env.PLAYER_RETENTION_REVOKED_LINKS_MONTHS);
+  poserMois(out, "voixMois", env.PLAYER_RETENTION_VOICE_MONTHS);
+  return out;
+}
+
+module.exports = { createStandaloneContext, creerLimites, retentionDepuisEnv };

package/docs/HOST-CONTRACT.md

@@ -451,11 +451,11 @@ POST  →  { "email": "…", "role": "…", "action": "<one of the names below>"
 |---|---|
 | `create` | create a tracked link |
 | `list` | list one's own links |
-| `list.all` | list everyone's links |
+| `list.all` | list everyone's links **and everyone's reading sessions** |
 | `revoke` | revoke a link |
 | `setauth` | change a link's access wall |
 | `overview` | read a document's aggregate figures |
-| `sessions` | read individual reading sessions |
+| `sessions` | read individual reading sessions — of one document, or of one recipient across all of them |
 | `test` | create a rehearsal link |
 | `presentations.list.all` | list presentations **one does not own** (slugs, presenter names, counts) |
 | `presentations.stats` | read the **attendees** of a presentation one does not own — names, addresses, dwell time, pages |
@@ -467,6 +467,37 @@ than the player. That failure reads exactly like a permission problem, which is
 expensive. **Compare this table against your own at each upgrade**, and prefer a refusal that names
 the unknown action over one that looks like a role issue.
 
+⚠️ **`list.all` widens `sessions` as well from `0.1.147`, and until it nothing did.** `docshare.list`
+has always asked you two questions — *may they list?* then *may they list everything?* — and
+narrowed to the caller's own links when the second answer was no. `docshare.sessions` asked only the
+first, and returned every session of the document: the reading sessions table carries the
+recipient's **address and IP**, so any member allowed to call it read the prospects of their
+colleagues. A strict door with a wide door beside it protects nothing.
+
+`sessions` now asks the same second question, and answers with a `scope` field (`"mine"` or
+`"all"`) exactly as `list` does — and so does `docshare.sessionsByRecipient`, which reads one
+person's sessions across every document and is therefore the call where the scope matters most. **What changes for you:** a member to whom you answer *no* on
+`list.all` now sees only the sessions of links whose chain starts with a link they created —
+forwarded re-shares of their own links included, because they caused those readings. Nothing
+changes for a role you already answer *yes* to. If your table predates `list.all`, see the warning
+above: an unheard-of action answered *no* narrows this view rather than breaking it.
+
+⚠️ **The reader IP is erased, and a direct query of your own will start seeing nothing.** The
+sessions table carried `ip` in the clear. `0.1.147` stops serving it — no player path reads it back,
+so nothing in this contract changes — stops writing it, and ships migration **0026**, which erases
+what thirteen months of journal still hold. ⚠️ **This lands in `0.1.147` and not before**: on `0.1.145`
+and earlier the column is still written and still served. `npm view discovery-media-player version`
+tells you which one you are about to install. **What changes for you:** nothing, unless you
+read that column yourself in a report or dashboard outside the player, in which case its values are
+empty from the day you apply 0026. The column itself stays for now: dropping it would fail every
+session write of a host that applies migrations before deploying, so its removal is a later release.
+[`docs/RETENTION.md`](RETENTION.md) sets out what the migration erases, why emptying — not
+dropping — is what actually removes the bytes, and what it cannot reach: your backups. The raw `ua`
+is erased too, on this table and on `commercial_doc_views`, by migration **0027** and for the same
+reason: `device`, `os` and `browser` are derived from it at write time and are what a reading record
+carries, so the raw string had no reader left. On the views table it had none at all — that table has
+no derived columns.
+
 ⚠️ **`presentations.list.all` and `presentations.stats` are deliberately separate.** Seeing *that* a
 presentation happened and seeing *who attended it* are different sensitivities: the first returns
 metadata, the second returns people — often prospects. Merging them would take from you the choice of

package/docs/RETENTION.md

@@ -35,11 +35,11 @@ Purpose: reading statistics for a document that was sent out. **Purge: 13 months
 |---|---|---|
 | `commercial_doc_views.recipient_email` | who the read is attributed to | purged with the row, 13 months after `at` |
 | `commercial_doc_views.session_id` | correlates the views of one session | same |
-| `commercial_doc_views.ua` | browser (raw User-Agent) | same |
+| `commercial_doc_views.ua` | **emptied from `0.1.147`** | ⚠️ Emptied by migration **0027**, which ships with that release and not before. The clearest case of the three: unlike the sessions table, this one has no `device`, `os` or `browser` — it derived *nothing* from the string, wrote it, and no query in this player has ever read it back. A browser fingerprint kept for thirteen months with no reader at all, unnoticed because the question had never been asked table by table |
 | `commercial_doc_sessions.recipient_email` | session attribution | purged with the row, 13 months after `last_at` |
 | `commercial_doc_sessions.session_id` | session identifier | same |
-| `commercial_doc_sessions.ip` | **IP address in the clear** | same — the most sensitive datum in the schema |
-| `commercial_doc_sessions.ua` | raw User-Agent | same |
+| `commercial_doc_sessions.ip` | **emptied from `0.1.147`** | ⚠️ It held the reader's IP address in the clear and was the most sensitive datum in this schema. **`0.1.147`** stops **serving** it, stops **writing** it, and ships migration **0026**, which erases what thirteen months of journal still carry. ⚠️ **On `0.1.145` and earlier it is still written and still served** — upgrading is what stops it. The column itself survives for now — dropping it would break a host that applies migrations before deploying (see *Purging the reader IP* below); its removal is a later release. The asymmetry this table used to note ends here, upward: a presentation attendee's address is a salted HMAC, a reader's is now nothing at all |
+| `commercial_doc_sessions.ua` | **emptied from `0.1.147`** | ⚠️ **`0.1.147`** stops serving it, stops writing it, and ships migration **0027**, which erases what is there. ⚠️ **On `0.1.145` and earlier it is still written.** `device`, `os` and `browser` are derived from it *at write time* and are what a reading record carries — so the raw string had no reader left, and "we might re-parse it one day" does not justify thirteen months of a fingerprint kept for nobody. Same treatment and same reason as `ip`: emptied now, column removed in a later release |
 | `commercial_doc_sessions.num_pages` / `commercial_doc_sessions.pages_time` | page-by-page reading behaviour | same |
 
 ## Reading logs (internal team)
@@ -135,6 +135,107 @@ it queryable, which is strictly worse than not having it.
 an MP3 and a JSON in a public bucket. The grouping and ceilings added in 0.1.140 bound the cost per
 hour; only this window bounds the **duration**.
 
+## Purging the reader IP and User-Agent (migrations 0026 and 0027)
+
+> ⚠️ **UPGRADE FIRST, THEN APPLY — the order is not a preference.** Both migrations ship in
+> `0.1.147`, together with the code that stops writing these columns. On `0.1.145` and earlier the
+> player **still writes and still serves** the IP and the raw User-Agent, and carries migrations only
+> up to `0024`. Applying 0026 or 0027 to a database whose player is older leaves that player writing
+> new values into columns you have just emptied: the purge would be undone at the next heartbeat.
+> `npm view discovery-media-player version` tells you what the registry serves; your own deployment
+> tells you what you are running, and it is the second number that decides.
+>
+> This paragraph is written this precisely because its opposite stood here: a claim, in the past
+> tense, that the change was already live, naming versions that had never been published. An
+> integrating host caught it by unpacking what the registry actually serves, after being asked to
+> apply migrations that were in no package. A guard now refuses any document naming a version the
+> repository has not cut.
+
+⚠️ **Read this before upgrading if you have ever queried `commercial_doc_sessions.ip` directly.**
+`0.1.147` stops serving it — no player path reads it back — stops writing it, and ships the migration
+that empties it, so nothing in the player changes; a report or dashboard of your own
+that reads values from it starts seeing empty ones. This notice exists so that it is announced
+*before*, not explained afterwards.
+
+**The column is emptied, not dropped — and emptying is what actually erases.** This is the reverse
+of the intuition, so it is worth the measurement. `ALTER TABLE … DROP` of a column marks the
+attribute dropped; it does **not** rewrite the rows. Measured on PostgreSQL 16.13 with
+`pageinspect`, on rows carrying an address:
+
+| after | addresses still present in the heap |
+|---|---|
+| dropping the column | **all of them** |
+| … then routine `VACUUM` | **all of them** — the rows are *live*, so there is nothing to reclaim |
+| … then `VACUUM FULL` | none — but that rewrites the table under an exclusive lock |
+| `UPDATE … SET ip = NULL`, then routine `VACUUM` | **none** |
+
+Dropping the column on its own would have left every address on disk indefinitely — invisible to
+any query, and therefore never checked by anyone again, while the schema swore it was not there. The
+`UPDATE` writes new row versions without the address and makes the old ones dead; **ordinary
+autovacuum reclaims them by itself**, with no exclusive lock and no operator action. Verified end to
+end on a populated database: 200 rows kept, 200 addresses gone after a routine vacuum, the migration
+replayable with no further effect. **The erasure is therefore complete today.** What is deferred is
+the shape of the schema, not the data.
+
+**When the columns are removed, and how to know the moment has come.** Not until **every deployed
+host runs a version that no longer writes them** — the release carrying 0026 and 0027, or later.
+Until then a `DROP` of any of the three would fail every session and view write of a host that
+applies migrations before deploying. The check is not a date: it is whether the oldest player version
+still in service is at or past that release.
+
+**Why the column itself survives, for now.** A migration here must be safe to apply *while the
+previous version of the player is running* — that rule is what makes the deployment order harmless,
+and it is enforced by a test. **Every version before `0.1.147` writes `ip`**, and PostgREST rejects a write carrying an
+unknown column: dropping it today would fail **every** session write of a host that applies
+migrations before deploying, with an error naming a column rather than a version. The column is
+removed in a later release, once no supported version writes it. Until then it exists, is always
+`NULL`, and carries a comment in the database saying so — `col_description()` on it is how you
+attest that 0026 ran.
+
+**What the migration cannot reach, and you can.** Write-ahead logs already written, backups, exports
+and migration dumps still carry the addresses; they follow *your* retention policy, not this file.
+This is the general rule stated at the end of *Limits stated rather than left unsaid* — a dropped
+column is itself a retention act, and earlier copies follow the host's backup policy — in its first
+concrete instance. A host that must attest a **complete** purge expires or rewrites its earlier
+backups; no migration can do that on its behalf.
+
+**The raw User-Agent goes the same way (0027), on both tables.** `0.1.147` stops serving it, stops
+writing it, and 0027 erases what is there — same shape, same measurement, same
+deferred column removal. `device`, `os` and `browser` are derived from the string *at write time* and
+are what a reading record carries, so the raw value had no reader; "we might re-parse it one day" is
+not a reason to keep a fingerprint for thirteen months. On `commercial_doc_views` the case is
+starker still: that table has no derived columns at all, so it derived nothing from the string and no
+query has ever read it back.
+
+**What is not covered.** `player_rate_limits.key` may still hold an address in the clear and expires
+on its own. `doc_presentation_attendees.creator_ip_hash` is a salted HMAC, not an address.
+
+## From what date is a purge complete end to end
+
+A question worth answering precisely, because the honest answer has three parts and only one of them
+is a number.
+
+**1. The rows.** Reading logs are deleted **13 months** after `at` / `last_at` by default. A host
+changes that through `config.retention` — whole months in `[1, 120]`.
+
+⚠️ **But the automatic sweep is strictly opt-in.** It runs only where a host has written
+`config.retention.balayage: true`; the `retention.run` action stays available without opt-in, because
+calling it *is* the decision. **On a host that has enabled neither, no row has ever been deleted, and
+the 13 months describe an intent rather than an event.** Anyone attesting a retention period should
+check which of the two is true of the installation in front of them, rather than quoting the default.
+
+**2. The values inside surviving rows.** Erased by 0026 and 0027 as soon as they are applied, and
+physically gone from the table once routine autovacuum has passed — no operator action, typically
+minutes to hours on an active table. This part does not wait for the 13 months.
+
+**3. Backups, write-ahead logs, exports and migration dumps.** **Outside this player's reach, and we
+neither set nor observe them.** They follow the hosting platform's own settings — on a managed
+provider, typically a point-in-time-recovery window plus a snapshot schedule, each with its own
+retention. A purge is complete end to end at *the later of*: the day 0026/0027 were applied plus the
+host's longest backup retention, and — for the rows themselves — whichever purge the host actually
+runs. **Ask the platform for two numbers: the PITR window and the oldest retained snapshot.** Until
+both have rolled past the migration date, earlier copies still hold the erased values.
+
 ## Limits stated rather than left unsaid
 
 - ⚠️ **`fichiersErreur` can be high without any removal having failed.** Each fingerprint has two

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.145",
+  "version": "0.1.147",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/gabarit-agent.js

@@ -28,6 +28,19 @@ const init = (ctx) => { PLAYER = ctx; };
  *
  * ⚠️ `=== true` PLUTÔT QUE VÉRIDIQUE. Une fonction, une chaîne ou un objet posé là par accident
  * ouvrirait la porte : on exige une DÉCLARATION, pas une présence.
+ *
+ * ⚠️ ET IL EST EXPORTÉ, PARCE QUE LA PAGE POSAIT LA MÊME QUESTION AVEC UNE MOITIÉ EN MOINS.
+ * `page-visionneuse.js` calculait `cfg.botVoice` — le champ remis au greffon de l'hôte — sur la
+ * CLÉ SEULE. Mesuré le 31/08, clé posée, greffon sans `wiresVoice` :
+ *
+ *     cfg.botVoice  = true     ← ce que la page DIT au greffon
+ *     balisage voix = absent   ← ce que le lecteur a RENDU
+ *
+ * Les deux moitiés d'une même page se contredisaient, et celle qui se trompait était la moitié
+ * DÉRIVÉE DE LA CONFIGURATION : la clé prouve que le serveur sait synthétiser, jamais qu'un clic
+ * mène quelque part. `docs/HOST-CONTRACT.md` écrit cette correction en gras depuis le 26/08 —
+ * « ELEVENLABS_API_KEY alone no longer shows them » — et le champ, lui, portait encore l'ancienne
+ * règle. Une seule écriture désormais : celle-ci.
  */
 function voixProposable() {
   if (!process.env.ELEVENLABS_API_KEY) return false;
@@ -575,4 +588,4 @@ function botMarkup(share, pitch) {
   return `<div class="botc min" id=botc style="--bacc:${acc}"><div class=botc-grab id=botcGrab><i></i></div><div class=botc-h><span class=botc-av>${avatar}</span><div><b>${name}</b><span class=botc-sub>${sub}</span></div>${voiceBtn}<button class=botc-gearbtn id=botcGearBtn title="Réglages d'affichage">${ICONS.gear}</button><button class=botc-min id=botcMin title=Réduire>${ICONS.min}</button></div><button class=botc-back id=botcBack>${ICONS.prev}<span>Revenir à la présentation</span></button><div class=botc-msgs id=botcMsgs><div class=botc-choices id=botcChoices></div></div><button class=botc-resume id=botcResume>Reprendre la présentation</button><div class=botc-in><input id=botcText placeholder="Écrivez votre message…" autocomplete=off maxlength=1000><button id=botcSend title=Envoyer>${ICONS.send}</button></div></div><button class=botc-fab id=botcFab style="--bacc:${acc}" title="Assistant & réglages">${share.bot_avatar ? `<img src="${esc(share.bot_avatar)}" alt="">` : ICONS.chat}<span class=botc-badge id=botcBadge></span><span class=botc-gear>${ICONS.gear}</span><span class=fab-gear>${ICONS.gear}</span></button><button class=botc-fab2 id=botcFab2 title="Parler à ${esc(String(share.bot_name || "l'assistant"))}">${ICONS.chat}<span class=botc-badge id=botcBadge2></span></button>${voixProposable() ? `<button class="botc-fab2 botc-fab3" id=botcVoice2 title="Couper la voix"></button>` : ""}<button class="botc-fab2 botc-fab4" id=botcPlay2 title="Relancer une visite">${ICONS.play}</button><button class=botc-peek id=botcPeek></button><div class=fabmenu id=fabMenu style="--bacc:${acc}"><div class=fm-l0 id=fmL0><button class=fm-row data-p=pDisp><span class=fm-rl>Affichage</span><em id=fmVDisp></em>${ICONS.next}</button><button class=fm-row data-p=pLang><span class=fm-rl>Langue</span><em id=fmVLang></em>${ICONS.next}</button><button class=fm-row data-p=pLook><span class=fm-rl>Apparence</span><em id=fmVLook></em>${ICONS.next}</button></div><div class=fm-p id=pDisp><button class=fm-back>${ICONS.prev}<span class=fm-rl>Affichage</span></button><div class=fm-seg id=fmDisp><button data-v=panel>Panneau</button><button data-v=bubble>Bulle</button><button data-v=cap>Barre</button><button data-v=audio>Audio seul</button></div></div><div class=fm-p id=pLang><button class=fm-back>${ICONS.prev}<span class=fm-rl>Langue</span></button><div class=fm-seg id=fmLang><button data-v=fr>FR</button><button data-v=en>EN</button><button data-v=es>ES</button></div></div><div class=fm-p id=pLook><button class=fm-back>${ICONS.prev}<span class=fm-rl>Apparence</span></button><div class=fm-sec>Thème</div><div class=fm-seg id=fmTheme><button data-v=dark>Sombre</button><button data-v=light>Clair</button></div><div class=fm-sec>Style du texte</div><div class=fm-seg id=fmStyle><button data-v=classic>Classique</button><button data-v=focus>Focus</button><button data-v=fill>Encre</button><button data-v=underline>Souligné</button></div></div></div><div class=botw id=botw style="--bacc:${acc}"><button class=botw-x id=botwX aria-label=Fermer>${ICONS.close}</button><div class=botw-card><div class=botw-head><span class=botw-av>${avatar}</span><div><b>${name}</b><span>${sub}</span></div></div><div class=botw-lang id=botwLang><button data-v=fr>FR</button><button data-v=en>EN</button><button data-v=es>ES</button></div>${pitch ? `<p class=botw-pitch>${esc(pitch)}</p>` : ""}<p class=botw-q>Comment souhaitez-vous découvrir ce document ?</p><button class=botw-door id=doorPresent><i>${ICONS.play}</i><span>Je me laisse guider<small>${name} vous présente le document, à votre rythme</small></span><em class=botw-tag>Recommandé</em></button><button class=botw-door id=doorRead><i>${ICONS.book}</i><span>Je le parcours seul<small>Lecture libre — l'assistant reste disponible</small></span></button><button class=botw-door id=doorChat><i>${ICONS.chat}</i><span>J'ai des questions<small>Échangez directement avec ${name}</small></span></button></div>${s2}</div><div class=botp id=botp style="--bacc:${acc}"><div class=botp-prog id=botpProg><i id=botpFill></i></div><div class=botp-cap id=botpCap></div><div class=botp-chips id=botpChips></div><div class=botp-ctl><button class=pp id=botpPP aria-label="Lecture / pause">${ICONS.pause}${ICONS.play}</button>${pVoiceBtn}<button id=botpFs title="Plein écran">${ICONS.fs}</button><button id=botpChat title="Parler à ${esc(String(share.bot_name || "l'assistant"))}">${share.bot_avatar ? `<img src="${esc(share.bot_avatar)}" alt="">` : ICONS.chat}</button><button id=botpMore title=Options>${ICONS.more}</button></div><button class=botp-big id=botpBig aria-label=Reprendre>${ICONS.play}</button><div class=rot-hint id=rotHint><i class=rh-ph><svg viewBox="0 0 24 24" width="26" height="26" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="7" y="3" width="10" height="18" rx="2.5"/><path d="M11 18.2h2"/></svg></i><div class=rh-t><b>Plein écran</b><span>Tournez votre téléphone</span></div></div><div class=botp-menu id=botpMenu><button id=bmChat>${ICONS.chat}<span>Poser une question</span></button><button id=bmCall>${ICONS.cal}<span>Être rappelé / prendre RDV</span></button><button id=bmDl>${ICONS.dl}<span>Télécharger le document</span></button><button id=bmRestart>${ICONS.restart}<span>Recommencer la présentation</span></button><button id=bmRead>${ICONS.book}<span>Consulter tranquillement</span></button><button id=bmSet class=bm-set>${ICONS.gear}<span>Réglages</span></button></div><div class="botp-menu botp-set" id=botpSet><button class=bs-back id=bsBack>${ICONS.prev}<span>Réglages</span></button><div class=fm-sec>Vitesse de lecture</div><div class=fm-seg id=msSpd><button data-v=1>1×</button><button data-v=1.5>1,5×</button><button data-v=2>2×</button></div><div class=fm-sec>Thème</div><div class=fm-seg id=msTheme><button data-v=dark>Sombre</button><button data-v=light>Clair</button></div><div class=fm-sec>Style du texte</div><div class=fm-seg id=msStyle><button data-v=classic>Classique</button><button data-v=focus>Focus</button><button data-v=fill>Encre</button><button data-v=underline>Souligné</button></div></div></div>`;
 }
 
-module.exports = { init, BOT_CSS, ICO, ICONS, botMarkup };
+module.exports = { init, BOT_CSS, ICO, ICONS, botMarkup, voixProposable };

package/server/page-visionneuse.js

@@ -6,7 +6,7 @@ const { esc, jsonPourScript } = require("./texte");
 const { PDFJS, PDFJS_WORKER, TIERS, balise } = require("./tiers");
 const { LIVE_CSS, LIVE_BAR, LIVE_PANEL, LIVE_JS } = require("./gabarit-live");
 const { MAP_CSS, MAP_MARKUP, MAP_JS } = require("./gabarit-carte");
-const { BOT_CSS, ICONS, botMarkup } = require("./gabarit-agent");
+const { BOT_CSS, ICONS, botMarkup, voixProposable } = require("./gabarit-agent");
 const { legalFooter, LEGAL_CSS } = require("./gabarit-legal");
 const { cleSessionHote, CLE_SESSION_PLAYER, CLE_INVITE } = require("./session-cles");
 
@@ -86,7 +86,7 @@ function viewerHtml(share, nonce, logoUrl, pitch) {
   // En aperçu interne, on embarque de quoi démarrer une présentation live (URL Storage brute + métadonnées).
   // `fileName` : c'est LUI qui dit la nature du document côté page. L'URL publique est
   // `/api/doc?slug=…&file=1`, sans extension — sans ce champ, une image partait dans pdf.js.
-  const cfg = jsonPourScript({ brand: PLAYER.branding.name, slug: preview ? "" : share.slug, fileUrl, fileName: share.file_name || "", pdfjs: PDFJS, pdfjsWorker: PDFJS_WORKER, title, preview, embed, embedded, bot: botOn, botGuided: !preview && !!share.bot_enabled && share.bot_guided !== false, botAv: (!preview && share.bot_enabled && share.bot_avatar) || "", botName: (!preview && share.bot_enabled && share.bot_name) || "", botGreet: (!preview && share.bot_enabled && share.bot_greeting) || "", botGreetDoc: (!preview && share.bot_enabled && share.bot_greeting_doc) || "", dl: share.allow_download !== false, autoPresent: !!share.auto_present, botAnim: share.bot_page_anim !== false, botVoice: !preview && !!share.bot_enabled && !!process.env.ELEVENLABS_API_KEY, vIcOn: ICONS.sound, vIcOff: ICONS.mute, kStyle: (!preview && share.bot_enabled && share.bot_karaoke) || "classic", vLayout: (!preview && share.bot_enabled && share.video_layout) || "", vClips: !preview && !!share.bot_vclips, botVAv: (!preview && share.bot_enabled && share.bot_vphoto) || "", resumeSlug: preview ? (share.resume_slug || "") : "", supaUrl: preview ? (share.supa_url || "") : "", supaKey: preview ? (share.supa_key || "") : "", internal: preview && share.internal_email ? { email: share.internal_email, name: share.presenter_name || "", docId: share.doc_id || "", it: share.internal_token || "" } : null, present: preview ? { url: share.raw_url || "", name: share.file_name || "", title: share.doc_title || "", docId: share.doc_id || "", by: share.presenter_name || "", email: share.internal_email || "", av: share.presenter_avatar || "" } : null });
+  const cfg = jsonPourScript({ brand: PLAYER.branding.name, slug: preview ? "" : share.slug, fileUrl, fileName: share.file_name || "", pdfjs: PDFJS, pdfjsWorker: PDFJS_WORKER, title, preview, embed, embedded, bot: botOn, botGuided: !preview && !!share.bot_enabled && share.bot_guided !== false, botAv: (!preview && share.bot_enabled && share.bot_avatar) || "", botName: (!preview && share.bot_enabled && share.bot_name) || "", botGreet: (!preview && share.bot_enabled && share.bot_greeting) || "", botGreetDoc: (!preview && share.bot_enabled && share.bot_greeting_doc) || "", dl: share.allow_download !== false, autoPresent: !!share.auto_present, botAnim: share.bot_page_anim !== false, botVoice: !preview && !!share.bot_enabled && voixProposable(), vIcOn: ICONS.sound, vIcOff: ICONS.mute, kStyle: (!preview && share.bot_enabled && share.bot_karaoke) || "classic", vLayout: (!preview && share.bot_enabled && share.video_layout) || "", vClips: !preview && !!share.bot_vclips, botVAv: (!preview && share.bot_enabled && share.bot_vphoto) || "", resumeSlug: preview ? (share.resume_slug || "") : "", supaUrl: preview ? (share.supa_url || "") : "", supaKey: preview ? (share.supa_key || "") : "", internal: preview && share.internal_email ? { email: share.internal_email, name: share.presenter_name || "", docId: share.doc_id || "", it: share.internal_token || "" } : null, present: preview ? { url: share.raw_url || "", name: share.file_name || "", title: share.doc_title || "", docId: share.doc_id || "", by: share.presenter_name || "", email: share.internal_email || "", av: share.presenter_avatar || "" } : null });
   return `<!doctype html><html lang=fr><head><meta charset=utf-8>
 <meta name=viewport content="width=device-width,initial-scale=1,maximum-scale=3,viewport-fit=cover,interactive-widget=resizes-content">
 <meta name=robots content="noindex,nofollow">

package/server/routes-liens.js

@@ -6,7 +6,7 @@
 const { adresseAppelant } = require("./appelant");
 const { jsonPour, repondreJson, etiquetteRoute } = require("./reponses.js");
 const { estConflit } = require("./erreurs-base.js");
-const { createShare, createReshare, sendReshareEmail, revokeShare, setShareAuth, listSharesForDoc, listSessionsForDoc, internalStatsForDoc, cleIdempotence, getShareBySlug, logView, upsertSession, upsertInternalSession, overview: docOverview } = require("./shares");
+const { createShare, createReshare, sendReshareEmail, revokeShare, setShareAuth, listSharesForDoc, listSessionsForDoc, listSessionsForRecipient, internalStatsForDoc, cleIdempotence, getShareBySlug, logView, upsertSession, upsertInternalSession, overview: docOverview } = require("./shares");
 const { SESSION_QUOTA_PER_HOUR, VIEW_QUOTA_PER_HOUR } = require("./shared.generated.js");
 
 let PLAYER = null;
@@ -194,7 +194,37 @@ async function traiter(req, res, body, slug) {
           return jd(200, { ok: true, byDoc: await docOverview() });
         }
         if (body.action === "docshare.sessions") {
-          return jd(200, { ok: true, sessions: await listSessionsForDoc(String(body.docId || "")) });
+          // ⚠️ LA MÊME PORTÉE QUE `docshare.list`, ET SON ABSENCE ICI ÉTAIT UNE FUITE. Les sessions
+          // portent `recipient_email` et `ip` : sans ce filtre, tout membre autorisé à appeler cette
+          // action obtenait, pour n'importe quel document, l'adresse et l'IP des prospects de ses
+          // collègues — ce que la distinction `list` / `list.all` empêche vingt lignes plus bas,
+          // depuis qu'un hôte l'a demandée. Une porte stricte à côté d'une porte large ne protège
+          // rien : il suffisait de passer par la seconde.
+          const toutVoir = await PLAYER.identity.canManageShares(u, "list.all");
+          const sessions = await listSessionsForDoc(String(body.docId || ""), toutVoir ? null : u.email);
+          return jd(200, { ok: true, sessions, scope: toutVoir ? "all" : "mine" });
+        }
+        if (body.action === "docshare.sessionsByRecipient") {
+          // ⚠️ MÊME PORTÉE QUE `list` ET `sessions`, ET C'EST ICI QU'ELLE COMPTE LE PLUS : cette
+          // action traverse TOUS les documents. Sans la borne, un membre lirait l'historique complet
+          // d'une personne à qui un collègue a envoyé quelque chose — la fuite qu'on vient de fermer,
+          // en plus large.
+          const email = String(body.email || "").trim();
+          if (!email) return jd(400, { ok: false, error: "email requis" });
+          const toutVoir = await PLAYER.identity.canManageShares(u, "list.all");
+          const { sessions, curseur } = await listSessionsForRecipient(email, {
+            owner: toutVoir ? null : u.email,
+            // `depuis` est facultatif : sans lui, la fenêtre analytique. La fiche qui promet tout
+            // l'historique le demande explicitement, et le dit donc à l'hôte.
+            depuis: body.since ? String(body.since) : null,
+            apres: body.cursor ? String(body.cursor) : null,
+            limite: body.limit,
+          });
+          // ⚠️ `cursor: null` EST LA FIN, PAS LA LONGUEUR DE LA PAGE. Sous portée restreinte, une
+          // page peut être plus courte que `limit` sans être la dernière : le filtre s'applique
+          // APRÈS la lecture, et le curseur porte la dernière ligne examinée. Un appelant qui
+          // s'arrêterait sur une page courte perdrait la suite.
+          return jd(200, { ok: true, sessions, cursor: curseur, scope: toutVoir ? "all" : "mine" });
         }
         if (body.action === "docshare.list") {
           const docId = String(body.docId || "");

package/server/shares.js

@@ -162,11 +162,20 @@ const mesureBornee = ({ page, maxPage, seconds }) => ({
 });
 
 // Journalise un événement de consultation (ouverture / page vue / battement). Best-effort.
-async function logView(share, { event, page, maxPage, seconds, sessionId, ua }) {
+//
+// ⚠️ `ua` N'EST PLUS ÉCRIT, ET LA SIGNATURE LE DIT — même geste que pour `ip` sur les sessions, sur
+// demande explicite de l'ADV le 01/09/2026. Le cas est ici PLUS NET qu'ailleurs : cette table n'a
+// ni `device`, ni `os`, ni `browser`, donc elle ne dérivait RIEN de cette chaîne. Elle l'écrivait,
+// et personne — aucune requête de ce dépôt — ne l'a jamais relue. Une empreinte de navigateur
+// conservée treize mois sans le moindre lecteur.
+//
+// L'appelant continue de la passer : il ne sait pas ce que chaque table conserve, et ce n'est pas à
+// lui de le savoir. La garder en paramètre nommé laisserait croire qu'elle sert.
+async function logView(share, { event, page, maxPage, seconds, sessionId, ua: _ua }) {
   const row = {
     slug: share.slug, doc_id: share.doc_id, recipient_email: share.recipient_email,
     event: String(event || "open").slice(0, 16), ...mesureBornee({ page, maxPage, seconds }),
-    session_id: String(sessionId || "").slice(0, 64) || null, ua: String(ua || "").slice(0, 300) || null,
+    session_id: String(sessionId || "").slice(0, 64) || null,
   };
   await PLAYER.db.request("commercial_doc_views", { method: "POST", headers: { Prefer: "return=minimal" }, body: [row] });
 }
@@ -478,31 +487,295 @@ function parseUa(ua) {
 
 // Upsert d'une session de consultation (résumé envoyé périodiquement par la visionneuse). Stocke le temps
 // PAR page (cumulatif côté client → on remplace), totaux, appareil. Conserve started_at (insert) via merge.
-async function upsertSession(share, p, { ip, ua }) {
+// ⚠️ `ip` N'EST PLUS ÉCRITE, ET LA SIGNATURE LE DIT — comme pour la session INTERNE plus bas, et
+// pour la même raison. La 0.1.146 avait cessé de la SERVIR ; la colonne a été purgée puis
+// supprimée par la 0026 (arbitrage ADV du 01/09/2026). L'appelant continue de la passer : il ne
+// sait pas ce que chaque table conserve, et ce n'est pas à lui de le savoir. La garder en
+// paramètre nommé laisserait croire qu'elle sert — c'est comme ça qu'une donnée revient dans une
+// ligne où elle n'a plus de colonne, et l'écriture partirait alors en erreur PostgREST à chaque
+// battement de chaque lecteur.
+async function upsertSession(share, p, { ip: _ip, ua }) {
   const sessionId = String(p.sessionId || "").slice(0, 64);
   if (!sessionId) return;
+  // ⚠️ `ua` SERT ENCORE ICI, ET N'EST PLUS STOCKÉ — la distinction est tout le raisonnement. La
+  // chaîne arrive dans l'en-tête de la requête, `parseUa` en tire trois champs lisibles, et ce sont
+  // EUX qu'on garde. La chaîne elle-même n'avait plus de lecteur depuis la 0.1.146 ; « pouvoir la
+  // ré-analyser un jour » ne justifie pas treize mois d'empreinte conservée pour personne (ADV,
+  // 01/09/2026). C'est donc le paramètre qui reste, pas la colonne.
   const { device, os, browser } = parseUa(ua);
   const row = {
     session_id: sessionId, slug: share.slug, doc_id: share.doc_id, recipient_email: share.recipient_email,
     // Bornées comme la session INTERNE : plafond d'entrées, clés/valeurs numériques, totaux capés.
     num_pages: bornerNombre(p.numPages, BORNES.pages), max_page: mesureBornee({ maxPage: p.maxPage }).max_page,
     total_seconds: bornerNombre(p.totalSeconds, BORNES.secondes) || 0, pages_time: bornerPagesTime(p.pagesTime),
-    ua: String(ua || "").slice(0, 300), ip: String(ip || "").slice(0, 60), device, os, browser, last_at: new Date().toISOString(),
+    device, os, browser, last_at: new Date().toISOString(),
   };
   // started_at non touché par l'upsert (default à l'insert ; merge ne l'écrase pas car absent du body).
   await PLAYER.db.request("commercial_doc_sessions?on_conflict=session_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: [row] });
 }
 
-// Sessions de consultation d'un document (détail riche par session) + nom du destinataire (jointure share).
-async function listSessionsForDoc(docId) {
+/**
+ * Le lien RACINE d'une chaîne de re-partages, en remontant `parent_slug`.
+ *
+ * ⚠️ `created_by` CHANGE À CHAQUE SAUT, et c'est ce qui rend la remontée nécessaire. `createReshare`
+ * pose `created_by: parent.recipient_email` — le lien que Paul reçoit de Dana est donc « créé par »
+ * Dana, pas par le commercial qui a envoyé le document à Dana. Un filtre naïf sur
+ * `created_by = moi` cacherait au commercial les lectures de sa PROPRE descendance : celles qu'il a
+ * causées. La portée suit la chaîne d'origine, pas le dernier maillon.
+ *
+ * ⚠️ ET ELLE ÉCHOUE FERMÉE. Un maillon dont le lien n'existe pas (dérive de données), une chaîne
+ * qui boucle : on rend `null` plutôt que d'attribuer au hasard. Un appelant restreint ne verra pas
+ * cette session ; `list.all`, qui ne filtre pas, la verra comme avant.
+ */
+function racineDuLien(slug, parParent, profondeurMax = 64) {
+  if (!slug || !parParent.has(slug)) return null;   // lien inconnu — inattribuable
+  const vus = new Set();
+  let courant = slug;
+  for (let saut = 0; saut < profondeurMax; saut += 1) {
+    if (vus.has(courant)) return null;              // chaîne qui boucle — inattribuable
+    vus.add(courant);
+    const parent = parParent.get(courant);
+    if (!parent) return courant;                    // pas de parent : c'est la racine
+    if (!parParent.has(parent)) return null;        // maillon manquant — inattribuable
+    courant = parent;
+  }
+  return null;                                      // chaîne plus longue que tout re-partage réel
+}
+
+/**
+ * Sessions de consultation d'un document (détail riche par session) + nom du destinataire.
+ *
+ * ⚠️ `owner` BORNE CE QUE L'APPELANT VOIT, ET SON ABSENCE ÉTAIT UNE FUITE. Cette lecture rendait
+ * `select=*` sur `commercial_doc_sessions` sans aucun filtre — or cette table porte
+ * `recipient_email` ET `ip`. Tout membre autorisé à appeler `docshare.sessions` obtenait donc, pour
+ * n'importe quel document, l'adresse et l'adresse IP de chaque destinataire, y compris les
+ * prospects de ses collègues. C'est exactement ce que `docshare.list` empêche depuis qu'un hôte
+ * l'a demandé, avec le commentaire qui l'explique quarante lignes plus haut ; la porte stricte
+ * avait une porte large à côté d'elle, et deux appels suffisaient à passer par la seconde.
+ *
+ * `null` = toutes les sessions (le rôle qui a `list.all`), une adresse = celles dont la chaîne
+ * d'origine part d'un lien que cette personne a créé.
+ */
+async function listSessionsForDoc(docId, owner = null) {
   const id = enc(String(docId || ""));
   const [sessions, shares] = await Promise.all([
-    PLAYER.db.request(`commercial_doc_sessions?doc_id=eq.${id}&select=*&order=last_at.desc&limit=500`),
-    PLAYER.db.request(`commercial_doc_shares?doc_id=eq.${id}&is_test=not.is.true&select=slug,recipient_email,recipient_name`),
+    PLAYER.db.request(`commercial_doc_sessions?doc_id=eq.${id}&select=${SELECT_SESSION}&order=last_at.desc&limit=500`),
+    // ⚠️ TOUS LES LIENS, RÉPÉTITIONS COMPRISES. La chaîne se remonte par `parent_slug` : un maillon
+    // absent de cette lecture casse la remontée et fait échouer fermé une session légitime. Le
+    // filtre `is_test` d'avant ne servait qu'à nommer le destinataire ; il ne peut pas servir à
+    // reconstruire une filiation.
+    PLAYER.db.request(`commercial_doc_shares?doc_id=eq.${id}&select=slug,parent_slug,created_by,recipient_email,recipient_name`),
   ]);
-  const nameBySlug = new Map();
-  for (const sh of (Array.isArray(shares) ? shares : [])) nameBySlug.set(sh.slug, sh.recipient_name || null);
-  return (Array.isArray(sessions) ? sessions : []).map((s) => ({ ...s, recipient_name: nameBySlug.get(s.slug) || null }));
+  const liste = Array.isArray(shares) ? shares : [];
+  const parSlug = new Map(liste.map((sh) => [sh.slug, sh]));
+  const parParent = new Map(liste.map((sh) => [sh.slug, sh.parent_slug || null]));
+  const proprietaire = low(owner || "");
+
+  const sortie = [];
+  for (const s of (Array.isArray(sessions) ? sessions : [])) {
+    const lien = parSlug.get(s.slug) || null;
+    const racine = racineDuLien(s.slug, parParent);
+    const createurRacine = racine ? low(parSlug.get(racine)?.created_by || "") : "";
+    if (proprietaire && createurRacine !== proprietaire) continue;
+    const parent = lien && lien.parent_slug ? parSlug.get(lien.parent_slug) || null : null;
+    sortie.push({
+      ...sessionServie(s),
+      recipient_name: (lien && lien.recipient_name) || null,
+      // La filiation voyage avec la session : « une session, un lecteur, visible par sa chaîne
+      // d'origine » ne se lit pas si la chaîne n'est pas dans la charge utile.
+      parent_slug: (lien && lien.parent_slug) || null,
+      parent_recipient_email: parent ? parent.recipient_email || null : null,
+      parent_recipient_name: parent ? parent.recipient_name || null : null,
+    });
+  }
+  return sortie;
+}
+
+/**
+ * Ce qu'une session laisse sortir, et ce qu'elle ne laisse pas sortir.
+ *
+ * ⚠️ UNE LISTE DE CE QUI EST PERMIS, PAS DE CE QU'ON RETIRE. Les deux lectures de sessions
+ * demandaient `select=*` et rendaient la ligne entière : ce que la table contient partait par
+ * défaut, et une colonne ajoutée demain serait partie sans que personne y pense. Dans ce sens-là
+ * l'oubli est une FUITE. Dans l'autre — une colonne neuve qui n'est pas servie — l'oubli est une
+ * absence, que le premier lecteur signale. C'est la même inversion que le périmètre de
+ * `image-documentee`, appliquée à ce qui SORT.
+ *
+ * ⚠️ ET L'IP N'EN EST PLUS. `docs/RETENTION.md` l'appelle en toutes lettres « the most sensitive
+ * datum in the schema », et rien dans ce dépôt ne la LIT : elle était écrite par `upsertSession` et
+ * ne servait qu'à être rendue. Une fiche commerciale n'a pas à porter l'adresse d'un lecteur pour
+ * dire qu'il a lu quatre pages en six minutes.
+ *
+ * ⚠️ ET LE MÊME PRODUIT A DÉJÀ TRANCHÉ AILLEURS. Les participants d'une présentation n'ont pas leur
+ * IP mais un `creator_ip_hash` — un HMAC salé, lié au slug pour qu'on ne puisse pas corréler une
+ * adresse d'une présentation à l'autre (0.1.114). Deux décisions opposées sur la même donnée dans
+ * le même produit ; celle-ci était la permissive, et personne ne les avait confrontées.
+ */
+const CHAMPS_SERVIS = [
+  "session_id", "slug", "doc_id", "recipient_email",
+  "num_pages", "max_page", "total_seconds", "pages_time",
+  "device", "os", "browser",
+  "started_at", "last_at",
+];
+
+/**
+ * Les colonnes qu'on NE sert PAS, avec la raison — pour qu'une absence soit une décision.
+ *
+ * ⚠️ ET C'EST BIEN UNE LISTE DE RAISONS, PAS DE CASES COCHÉES. Une colonne retirée sans motif écrit
+ * revient au bout de six mois, parce que personne ne sait pourquoi elle n'était pas là.
+ */
+const CHAMPS_RETENUS = {
+  ip: "adresse IP en clair — VIDÉE par la 0026 et plus jamais écrite (arbitrage ADV du "
+    + "01/09/2026). La colonne demeure le temps qu'aucune version supportée ne l'écrive : "
+    + "`docs/MIGRATIONS.md` exige qu'une migration soit sûre pendant que la version PRÉCÉDENTE "
+    + "tourne, or celle-là l'écrit encore et PostgREST rejette une écriture portant une colonne "
+    + "inconnue. Sa suppression est le geste d'une livraison ultérieure ; d'ici là elle est ici, "
+    + "vide, et retenue",
+  ua: "User-Agent brut — VIDÉ par la 0027 et plus jamais écrit (demande ADV du 01/09/2026). Un "
+    + "vecteur d'empreinte, et surtout REDONDANT : `parseUa` en tire `device`, `os` et `browser` à "
+    + "l'écriture, et ces trois-là sont servis. Nous avions plaidé pour le garder — seule source "
+    + "d'où recalculer les trois sur des lignes déjà écrites — et c'est notre propre argument qui "
+    + "l'a emporté contre nous : une chaîne sans lecteur ne se garde pas treize mois pour un "
+    + "recalcul hypothétique. La colonne demeure le temps qu'aucune version supportée ne l'écrive, "
+    + "pour la même raison que `ip`",
+};
+
+/** La projection d'une ligne de session : ce qui sort, et rien d'autre. */
+const sessionServie = (s) => Object.fromEntries(CHAMPS_SERVIS.filter((c) => c in s).map((c) => [c, s[c]]));
+
+/** Le `select=` qui descend dans la requête — la MÊME liste, pas une seconde écriture. */
+const SELECT_SESSION = CHAMPS_SERVIS.join(",");
+
+/**
+ * Les liens nommés, plus TOUS leurs ancêtres, en remontant `parent_slug` par vagues.
+ *
+ * ⚠️ LA CHAÎNE NE TIENT PAS DANS UNE SEULE LECTURE. Pour un document, `listSessionsForDoc` lit tous
+ * ses liens d'un coup et la remontée est locale. Ici les sessions viennent de documents quelconques :
+ * on ne connaît au départ que les liens qui les portent, et leurs parents sont ailleurs. On remonte
+ * donc par vagues, en ne redemandant jamais un `slug` déjà lu.
+ *
+ * ⚠️ ET LE NOMBRE DE VAGUES EST BORNÉ. Une chaîne de re-partages réelle fait un ou deux sauts ; huit
+ * vagues couvrent très large. Au-delà, on rend ce qu'on a : la remontée qui s'appuie dessus échoue
+ * alors fermée, ce qui est le bon sens de l'erreur — on ne montre pas une session qu'on n'a pas su
+ * rattacher.
+ */
+async function liensEtAncetres(slugs, vaguesMax = 8) {
+  const parSlug = new Map();
+  let aLire = [...new Set(slugs.filter(Boolean))];
+  for (let vague = 0; vague < vaguesMax && aLire.length; vague += 1) {
+    const liste = aLire.map((x) => `"${String(x).replace(/[",()]/g, "")}"`).join(",");
+    const lus = await PLAYER.db.request(`commercial_doc_shares?slug=in.(${enc(liste)})&select=slug,parent_slug,created_by,recipient_email,recipient_name,doc_id,doc_title`);
+    const vus = Array.isArray(lus) ? lus : [];
+    if (!vus.length) break;
+    for (const sh of vus) parSlug.set(sh.slug, sh);
+    aLire = [...new Set(vus.map((sh) => sh.parent_slug).filter((x) => x && !parSlug.has(x)))];
+  }
+  return parSlug;
+}
+
+/**
+ * Le curseur d'une page : l'horodatage de la dernière ligne examinée, ET les sessions déjà rendues
+ * à CET horodatage.
+ *
+ * ⚠️ `last_at` NE SUFFIT PAS. Deux sessions peuvent porter le même horodatage — deux battements
+ * dans la même milliseconde — et un curseur qui ne retiendrait que le temps sauterait l'une des
+ * deux (`lt`) ou la rendrait deux fois (`lte`).
+ *
+ * ⚠️ ET LA FORME ÉVIDENTE EST INTERDITE ICI, POUR UNE RAISON ÉCRITE. La façon habituelle
+ * d'écrire ça est un `or=(last_at.lt.T,and(last_at.eq.T,session_id.lt.ID))` — et `ci.yml` refuse
+ * `or=(` et `and=(` dans `server/*.js` : « ce qui coûte, ce sont les jointures imbriquées et les
+ * arbres booléens — là, un portage cesse d'être une traduction et devient une réécriture ». Le
+ * zéro qu'annonçait `docs/API.md` n'était pas un nombre périmé, c'était une POLITIQUE, et je l'ai
+ * pris pour l'autre avant que la garde ne me reprenne.
+ *
+ * La forme portable dit la même chose sans arbre booléen : « au plus tard que T, et pas l'une de
+ * celles-ci » — `last_at=lte.T & session_id=not.in.(…)`, qui se traduit mot pour mot en
+ * `WHERE last_at <= T AND session_id NOT IN (…)`. La liste ne grandit que pour les ex æquo de
+ * l'horodatage de bord, et chaque page ajoute au moins une exclusion ou avance le temps : la
+ * progression est garantie, sans quoi une page d'ex æquo tournerait en rond.
+ */
+const curseurDe = (at, ids) => (at ? `${at}|${[...ids].join(",")}` : null);
+
+function curseurLu(brut) {
+  const texte = String(brut || "");
+  const coupe = texte.indexOf("|");
+  if (coupe <= 0) return null;
+  const at = texte.slice(0, coupe);
+  const ids = texte.slice(coupe + 1).split(",").filter(Boolean);
+  // Un curseur qu'on ne sait pas lire n'est pas « le début » : ce serait rendre la première page à
+  // qui demandait la troisième, en silence. On le REFUSE, et l'appelant le saura.
+  if (!ids.length || Number.isNaN(Date.parse(at))) return null;
+  return { at, ids };
+}
+
+/**
+ * Toutes les sessions d'un DESTINATAIRE, tous documents confondus.
+ *
+ * ⚠️ LA PORTÉE EST CELLE DE `listSessionsForDoc`, POUR LA MÊME RAISON — et elle ne peut pas être
+ * poussée dans la requête. « La chaîne d'origine part d'un lien que j'ai créé » est récursif :
+ * `created_by` change à chaque saut de re-partage. On lit donc une page de CANDIDATS, on résout
+ * leurs chaînes, et on ne rend que ce qui appartient à l'appelant.
+ *
+ * ⚠️ CONSÉQUENCE ASSUMÉE, ET ÉCRITE PLUTÔT QUE MASQUÉE : une page peut être PLUS COURTE que
+ * `limite` sans être la dernière. Le curseur rendu est la position de la dernière ligne EXAMINÉE,
+ * pas de la dernière rendue — donc rien n'est sauté ni rendu deux fois, et la fin se lit à
+ * `curseur: null`, jamais à la longueur de la page. Boucler jusqu'à remplir la page ferait payer à
+ * un appelant restreint un balayage dont il ne verrait rien, et le nombre de requêtes deviendrait
+ * une fonction de ce que ses collègues ont envoyé.
+ *
+ * `depuis` borne le temps (défaut : la fenêtre analytique). L'appelant peut remonter plus loin en
+ * la passant explicitement — la fiche promet « tout l'historique », vingt-quatre mois n'en sont que
+ * le défaut raisonnable.
+ */
+async function listSessionsForRecipient(email, { owner = null, depuis = null, apres = null, limite = 100 } = {}) {
+  const destinataire = low(email);
+  if (!destinataire) return { sessions: [], curseur: null };
+  const borne = depuis || depuisFenetre();
+  const taille = Math.min(Math.max(Number(limite) || 100, 1), 500);
+  const position = curseurLu(apres);
+
+  // ⚠️ « AU PLUS TARD QUE T, ET PAS L'UNE DE CELLES-CI » — deux filtres plats, pas un arbre booléen.
+  // `not.in.(…)` se traduit en `NOT IN (…)`, que toute base sait faire ; c'est ce qui distingue une
+  // traduction d'une réécriture, et c'est la règle que `ci.yml` fait respecter.
+  const apresQuoi = position
+    ? `&last_at=lte.${enc(position.at)}&session_id=not.in.(${enc(position.ids.map((x) => `"${String(x).replace(/[",()]/g, "")}"`).join(","))})`
+    : "";
+  const candidats = await PLAYER.db.request(
+    `commercial_doc_sessions?recipient_email=eq.${enc(destinataire)}&last_at=gte.${enc(borne)}${apresQuoi}`
+    + `&select=${SELECT_SESSION}&order=last_at.desc,session_id.desc&limit=${taille}`);
+  const lignes = Array.isArray(candidats) ? candidats : [];
+  if (!lignes.length) return { sessions: [], curseur: null };
+
+  const parSlug = await liensEtAncetres(lignes.map((s) => s.slug));
+  const parParent = new Map([...parSlug].map(([slug, sh]) => [slug, sh.parent_slug || null]));
+  const proprietaire = low(owner || "");
+
+  const sessions = [];
+  for (const s of lignes) {
+    const lien = parSlug.get(s.slug) || null;
+    const racine = racineDuLien(s.slug, parParent);
+    const createurRacine = racine ? low(parSlug.get(racine)?.created_by || "") : "";
+    if (proprietaire && createurRacine !== proprietaire) continue;
+    const parent = lien && lien.parent_slug ? parSlug.get(lien.parent_slug) || null : null;
+    sessions.push({
+      ...sessionServie(s),
+      doc_title: (lien && lien.doc_title) || null,
+      recipient_name: (lien && lien.recipient_name) || null,
+      parent_slug: (lien && lien.parent_slug) || null,
+      parent_recipient_email: parent ? parent.recipient_email || null : null,
+      parent_recipient_name: parent ? parent.recipient_name || null : null,
+    });
+  }
+  // La page est pleine ⇒ il reste peut-être quelque chose : on rend l'horodatage de la dernière
+  // ligne EXAMINÉE, et les sessions déjà servies à cet horodatage. Elle ne l'est pas ⇒ la source
+  // est épuisée, et `null` le dit sans ambiguïté.
+  if (lignes.length < taille) return { sessions, curseur: null };
+  const bord = lignes[lignes.length - 1].last_at;
+  const dejaVues = lignes.filter((s) => s.last_at === bord).map((s) => s.session_id);
+  // Le curseur entrant portait le MÊME horodatage de bord ⇒ ses exclusions valent encore, sinon
+  // les ex æquo déjà servis reviendraient. Il en portait un autre ⇒ elles sont sans objet.
+  const exclues = position && position.at === bord ? [...new Set([...position.ids, ...dejaVues])] : dejaVues;
+  return { sessions, curseur: curseurDe(bord, exclues) };
 }
 
 // Envoi AUTO du re-partage via 3D Discovery (Resend). Contenu 100% templé (pas de texte libre → anti-spam),
@@ -671,4 +944,4 @@ async function internalStatsForDoc(docId) {
 }
 
 module.exports = {
-  cleIdempotence, init, createShare, createReshare, sendReshareEmail, getShareBySlug, logView, upsertSession, listSharesForDoc, listSessionsForDoc, revokeShare, setShareAuth, overview, upsertInternalSession, internalStatsForDoc };
+  cleIdempotence, init, createShare, createReshare, sendReshareEmail, getShareBySlug, logView, upsertSession, listSharesForDoc, listSessionsForDoc, listSessionsForRecipient, racineDuLien, curseurDe, curseurLu, sessionServie, CHAMPS_SERVIS, CHAMPS_RETENUS, revokeShare, setShareAuth, overview, upsertInternalSession, internalStatsForDoc };

package/supabase/init.sql

@@ -108,6 +108,10 @@ create table if not exists public.commercial_doc_views (
   seconds         integer constraint ck_views_seconds_borne check (seconds is null or (seconds >= 0 and seconds <= 86400)),
   session_id      text,
   at              timestamptz not null default now(),
+  -- ⚠️ VIDE, ET PLUS JAMAIS ÉCRITE (0027, demande ADV du 01/09/2026). Cette table n'a ni `device`,
+  -- ni `os`, ni `browser` : elle ne dérivait RIEN de cette chaîne, l'écrivait, et aucune requête ne
+  -- l'a jamais relue. Elle demeure le temps qu'aucune version supportée ne l'écrive — voir la note
+  -- de `commercial_doc_sessions.ip` ci-dessous pour la raison, qui est la même.
   ua              text
 );
 create index if not exists cdv_slug_idx on public.commercial_doc_views (slug);
@@ -128,7 +132,17 @@ create table if not exists public.commercial_doc_sessions (
   max_page        integer constraint ck_sessions_max_page_borne check (max_page is null or (max_page >= 0 and max_page <= 10000)),
   total_seconds   integer default 0 constraint ck_sessions_total_seconds_borne check (total_seconds is null or (total_seconds >= 0 and total_seconds <= 86400)),
   pages_time      jsonb   default '{}'::jsonb,
+  -- ⚠️ VIDE, ET PLUS JAMAIS ÉCRITE (0027). `device`, `os` et `browser` ci-dessous en sont dérivés À
+  -- L'ÉCRITURE et sont, eux, servis : la chaîne brute n'a plus de lecteur. Même sort que `ip`, même
+  -- raison de survivre encore.
   ua              text,
+  -- ⚠️ VIDE, ET PLUS JAMAIS ÉCRITE (0026, arbitrage ADV du 01/09/2026). Elle a porté l'adresse du
+  -- lecteur en clair ; la 0.1.146 a cessé de la SERVIR, la 0026 efface ce qui restait et plus
+  -- aucune écriture ne la remplit. Elle demeure ici parce qu'une migration doit rester sûre
+  -- pendant que la version PRÉCÉDENTE du code tourne — celle-là l'écrit encore, et PostgREST
+  -- rejette une écriture portant une colonne inconnue : la supprimer aujourd'hui ferait échouer
+  -- TOUTES les écritures de session d'un hôte pas encore déployé. Sa suppression est le geste
+  -- d'une livraison ULTÉRIEURE, quand plus aucune version supportée ne l'écrit.
   ip              text,
   device          text,
   os              text,
@@ -139,6 +153,12 @@ create table if not exists public.commercial_doc_sessions (
 create index if not exists cds_sess_slug_idx on public.commercial_doc_sessions (slug);
 create index if not exists cds_sess_doc_idx  on public.commercial_doc_sessions (doc_id, last_at desc);
 create index if not exists idx_cds_last_at on public.commercial_doc_sessions (last_at);
+-- « Toutes les lectures de cette personne, la plus récente d'abord » — la question de la fiche
+-- par destinataire. Partiel : un lien anonyme laisse `recipient_email` nul et ne répond jamais à
+-- cette question ; le porter dans l'index le grossirait sans qu'aucune requête ne l'y cherche.
+create index if not exists idx_cds_recipient_last_at
+  on public.commercial_doc_sessions (recipient_email, last_at desc)
+  where recipient_email is not null;
 
 create table if not exists public.commercial_doc_internal_sessions (
   session_id    text primary key,
@@ -787,6 +807,27 @@ update public.commercial_doc_shares set revoked_at = now() where revoked = true
 alter table public.doc_presentations
   add column if not exists view_rotation integer not null default 0;
 
+-- ⚠️ ET LE RATTRAPAGE VAUT AUSSI POUR CE QU'ON EFFACE (0026). Une base installée avant aujourd'hui
+-- porte treize mois d'adresses ; `create table if not exists` ne touche pas une table déjà là, donc
+-- rejouer ce fichier ne les effacerait jamais. Le geste est celui de la 0026, à l'identique, et il
+-- ne coûte rien sur une base neuve — où la colonne est vide par construction.
+update public.commercial_doc_sessions set ip = null where ip is not null;
+-- 0027 — même geste pour le User-Agent brut, sur les DEUX tables.
+update public.commercial_doc_sessions set ua = null where ua is not null;
+update public.commercial_doc_views set ua = null where ua is not null;
+comment on column public.commercial_doc_sessions.ua is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0027. A porte le User-Agent brut du lecteur. Les champs '
+  'device, os et browser en sont derives A L''ECRITURE et sont, eux, servis. Conservee le temps '
+  'qu''aucune version supportee du lecteur ne l''ecrive. Voir docs/RETENTION.md.';
+comment on column public.commercial_doc_views.ua is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0027. A porte le User-Agent brut du lecteur. Cette table '
+  'n''en derivait rien et aucune requete ne l''a jamais relue. Conservee le temps qu''aucune '
+  'version supportee du lecteur ne l''ecrive. Voir docs/RETENTION.md.';
+comment on column public.commercial_doc_sessions.ip is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0026. A porte l''adresse IP du lecteur en clair. '
+  'Conservee le temps qu''aucune version supportee du lecteur ne l''ecrive : la supprimer '
+  'aujourd''hui casserait les ecritures d''un hote pas encore deploye. Voir docs/RETENTION.md.';
+
 -- ⚠️ ET LE RATTRAPAGE VAUT AUSSI POUR LES CONTRAINTES, PAS SEULEMENT POUR LES COLONNES (0020).
 -- Elles sont déclarées dans le corps des tables ci-dessus, ce qui règle la base VIERGE — et ne
 -- touche pas une base déjà installée, où `create table if not exists` ne fait rien. Le scénario

package/supabase/migrations/0025-sessions-par-destinataire.sql

@@ -0,0 +1,47 @@
+-- LIRE LES SESSIONS D'UNE PERSONNE, TOUS DOCUMENTS CONFONDUS, SANS BALAYER LA TABLE.
+--
+-- ⚠️ CE QUI MANQUAIT. Les trois index de `commercial_doc_sessions` répondent à trois questions :
+-- « les sessions de ce lien » (`cds_sess_slug_idx`), « les sessions de ce document, les plus
+-- récentes d'abord » (`cds_sess_doc_idx`), et « les sessions récentes, tous documents confondus »
+-- (`idx_cds_last_at`, posé par la 0014 pour la rétention). Aucun ne répond à « toutes les lectures
+-- de cette personne » — la question que pose la fiche par destinataire.
+--
+-- Sans lui, `recipient_email=eq.…&order=last_at.desc` est un balayage complet suivi d'un tri : le
+-- coût croît avec le JOURNAL, pas avec ce qu'on rend. C'est la forme de requête qui va bien tant
+-- que la table est jeune et qui devient le point de rupture le jour où elle ne l'est plus — et ce
+-- jour-là, elle ne casse pas, elle ralentit tout le reste avec elle.
+--
+-- ⚠️ POURQUOI `(recipient_email, last_at desc)` ET PAS DEUX INDEX SÉPARÉS. La question est toujours
+-- posée dans cet ordre : une personne, puis ses lectures de la plus récente à la plus ancienne, par
+-- pages. Un index composite sert le filtre ET le tri ET la pagination par curseur en une seule
+-- descente ; deux index simples obligeraient le planificateur à choisir, et à trier après coup ce
+-- qu'il aurait filtré. `desc` est écrit parce que la lecture est toujours descendante : c'est
+-- l'ordre de la fiche, pas une préférence.
+--
+-- ⚠️ ON N'INDEXE PAS LES LIGNES SANS DESTINATAIRE. Un lien anonyme laisse `recipient_email` nul, et
+-- ces lignes ne peuvent JAMAIS répondre à « les lectures de telle personne » — les porter dans
+-- l'index le grossirait sans qu'aucune requête ne les y cherche. L'index partiel dit cette règle
+-- plutôt que de la laisser deviner.
+--
+-- ⚠️ SANS LUI : RIEN NE CASSE. `docshare.sessionsByRecipient` répond de la même façon chez un hôte
+-- non migré — plus lentement, et d'autant plus lentement que son journal est vieux. Aucune colonne
+-- n'est ajoutée, aucune donnée n'est réécrite : c'est une aide au planificateur, pas un contrat.
+--
+-- ⚠️ `CONCURRENTLY` N'EST PAS EMPLOYÉ ICI, ET C'EST DÉLIBÉRÉ. Il ne peut pas tourner dans une
+-- transaction, or ce dossier est joué comme un script transactionnel par les hôtes qui l'appliquent
+-- d'un bloc. Sur une table de journal, la pose verrouille les écritures le temps de la
+-- construction : quelques secondes sur des volumes ordinaires, et les sessions perdues pendant ce
+-- temps sont des upserts qui repasseront au battement suivant. Un hôte dont le journal est
+-- volumineux peut poser l'index à la main en `concurrently` AVANT d'appliquer ce fichier — le
+-- `if not exists` le rend alors sans effet.
+--
+-- ⚠️ IDEMPOTENTE : `if not exists`, rejouable sans effet.
+
+create index if not exists idx_cds_recipient_last_at
+  on public.commercial_doc_sessions (recipient_email, last_at desc)
+  where recipient_email is not null;
+
+comment on index public.idx_cds_recipient_last_at is
+  'Sert « toutes les lectures de cette personne, la plus récente d''abord », la question de la fiche '
+  'par destinataire : filtre, tri et pagination par curseur en une seule descente. Partiel sur '
+  'recipient_email non nul — un lien anonyme ne répond jamais à cette question.';

package/supabase/migrations/0026-purge-des-adresses-ip.sql

@@ -0,0 +1,73 @@
+-- L'ADRESSE IP D'UN LECTEUR EST EFFACÉE — ARBITRAGE DE L'ADV, RENDU LE 01/09/2026.
+--
+-- La 0.1.146 a cessé de la SERVIR : ni `docshare.sessions` ni `docshare.sessionsByRecipient` ne la
+-- rendent, et ce qui sort d'une session est depuis une liste de ce qui est PERMIS. Restait la
+-- moitié qui ne se règle pas dans le code : treize mois de journal la portaient encore en clair.
+-- Ne plus servir une donnée et ne plus la garder sont deux décisions ; voici la seconde.
+--
+-- ⚠️ SANS LUI : rien ne casse, et c'est bien le problème. Les adresses déjà écrites restent en
+-- base, en clair. Aucun chemin du lecteur ne les relit depuis la 0.1.146 et plus rien ne les écrit
+-- depuis la 0.1.147 — un hôte non migré cesse donc d'en accumuler dès qu'il déploie le code, mais
+-- il CONSERVE tout l'historique. La dégradation n'est pas une panne : c'est une rétention qui
+-- continue en silence, jusqu'à la purge des treize mois, ligne par ligne.
+--
+-- ⚠️ POURQUOI CE FICHIER NE SUPPRIME PAS LA COLONNE, alors que la demande le préférait. La règle
+-- de ce dossier — `docs/MIGRATIONS.md`, éprouvée par un banc — est qu'une migration doit être sûre
+-- à appliquer PENDANT QUE LA VERSION PRÉCÉDENTE DU CODE TOURNE. La 0.1.146 écrit encore `ip`, et
+-- PostgREST rejette une écriture portant une colonne inconnue : supprimer la colonne aujourd'hui
+-- ferait échouer TOUTES les écritures de session d'un hôte qui applique les migrations avant de
+-- déployer — pas seulement celles qui touchent l'adresse. Et le message parlerait d'une colonne,
+-- pas d'une version : il n'aurait aucun moyen de le deviner. La suppression est donc le geste
+-- d'une livraison ULTÉRIEURE, quand plus aucune version supportée ne l'écrit.
+--
+-- ⚠️ ET CE REPORT NE COÛTE RIEN À L'EFFACEMENT — c'est la mesure qui le dit, pas une commodité.
+-- Mesuré le 01/09 sur PostgreSQL 16.13 avec `pageinspect`, sur des lignes portant une adresse :
+--
+--     après ALTER TABLE … DROP COLUMN           toutes encore dans les pages
+--     après VACUUM ordinaire                    toutes encore là — les lignes sont VIVANTES
+--     après VACUUM FULL                          aucune — mais il RÉÉCRIT la table, sous verrou
+--
+--     après UPDATE … SET ip = NULL              anciennes versions de ligne, désormais MORTES
+--     après VACUUM ordinaire                     aucune — celui qui passe TOUT SEUL, sans verrou
+--
+-- Autrement dit : `DROP COLUMN` n'efface RIEN. Il marque l'attribut supprimé et laisse les octets
+-- dans les pages jusqu'à une réécriture complète de la table — indéfiniment chez un hôte qui ne
+-- fait rien de particulier, et invisibles à toute requête, donc plus jamais vérifiés par personne.
+-- C'est l'UPDATE qui efface : il écrit de nouvelles versions de ligne sans l'adresse et rend les
+-- anciennes mortes, que l'autovacuum de routine récupère de lui-même. Ce fichier fait donc
+-- AUJOURD'HUI tout ce qui relève de l'effacement ; ce qui est reporté est la forme du schéma, pas
+-- la donnée.
+--
+-- ⚠️ CE QU'IL NE PEUT PAS ATTEINDRE, ET QUI DOIT ÊTRE DIT PLUTÔT QUE SIMULÉ. Les WAL déjà écrits,
+-- les sauvegardes, les exports et les dumps portent encore les adresses ; ils suivent la politique
+-- de rétention de l'hôte, pas ce fichier. `docs/RETENTION.md` posait déjà la règle générale — une
+-- colonne de données personnelles qu'on retire est elle-même un acte de rétention, et les copies
+-- antérieures suivent la politique de sauvegarde de l'hôte. Ce fichier en est le premier cas
+-- concret. Un hôte qui doit attester une purge COMPLÈTE fait expirer ou réécrit ses sauvegardes.
+--
+-- ⚠️ CE QUI RESTE, ET POURQUOI. `ua` reste : elle n'était pas demandée, et elle est la SOURCE de
+-- `device`, `os` et `browser` — la seule à permettre de les recalculer sur les lignes déjà écrites
+-- si l'analyse s'améliore. Elle n'est plus servie depuis la 0.1.146. La supprimer se défend et se
+-- décidera séparément : une destruction irréversible se demande, elle ne se déduit pas.
+-- `player_rate_limits.key` peut porter une adresse en clair : elle expire d'elle-même.
+-- `doc_presentation_attendees.creator_ip_hash` est un HMAC salé, pas une adresse — l'asymétrie que
+-- `docs/RETENTION.md` signalait entre les deux tables cesse ici, par le haut.
+--
+-- ⚠️ LE SIGNE QU'UN HÔTE PEUT SONDER est le COMMENTAIRE de la colonne, `col_description()`. Une
+-- migration qui n'efface que des données ne laisse aucune trace dans `information_schema` : elle
+-- serait inattestable, et une purge est justement la migration qu'un DPO demandera de prouver.
+--
+-- ⚠️ ADDITIVE au sens de `docs/MIGRATIONS.md` : aucune colonne, table ou contrainte n'est retirée,
+-- rien n'est renommé, rien ne devient obligatoire. Sûre pendant que la 0.1.146 tourne — elle
+-- continue d'écrire dans une colonne qui existe toujours.
+--
+-- ⚠️ IDEMPOTENTE : rejouable sans effet ; le second passage ne trouve plus rien à vider.
+
+update public.commercial_doc_sessions
+   set ip = null
+ where ip is not null;
+
+comment on column public.commercial_doc_sessions.ip is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0026. A porte l''adresse IP du lecteur en clair. '
+  'Conservee le temps qu''aucune version supportee du lecteur ne l''ecrive : la supprimer '
+  'aujourd''hui casserait les ecritures d''un hote pas encore deploye. Voir docs/RETENTION.md.';

package/supabase/migrations/0027-purge-des-user-agents.sql

@@ -0,0 +1,67 @@
+-- LE USER-AGENT BRUT EST EFFACÉ, SUR LES DEUX TABLES — DEMANDE EXPLICITE DE L'ADV, 01/09/2026.
+--
+-- La 0.1.146 avait cessé de le SERVIR. La 0026 a effacé l'adresse IP par la même mécanique et l'a
+-- laissé de côté : il n'était pas demandé, et nous avions plaidé pour le garder — seule source d'où
+-- `device`, `os` et `browser` pourraient être recalculés sur les lignes déjà écrites. L'ADV a
+-- tranché, et l'argument qui emporte est le nôtre retourné contre nous : les trois champs dérivés
+-- sont extraits À L'ÉCRITURE et servis, la chaîne brute n'a plus de lecteur, et « pouvoir
+-- recalculer un jour » ne justifie pas treize mois d'empreinte conservée pour personne. Une donnée
+-- sans lecteur n'a pas de raison d'exister.
+--
+-- ⚠️ SANS LUI : rien ne casse, et c'est le même piège que pour l'adresse. Les chaînes déjà écrites
+-- restent en base. Aucune requête de ce dépôt ne les relit — vérifié en énumérant les six requêtes
+-- qui touchent ces deux tables : `ua` n'apparaît dans aucun `select=`. La 0.1.147 cesse en plus de
+-- les ÉCRIRE. La dégradation n'est donc pas une panne : c'est une rétention qui continue en
+-- silence jusqu'à la purge des treize mois, ligne par ligne.
+--
+-- ⚠️ LE CAS DE `commercial_doc_views` EST PLUS NET ENCORE. Cette table n'a ni `device`, ni `os`, ni
+-- `browser` : elle ne dérivait RIEN de cette chaîne. Elle l'écrivait, et personne ne l'a jamais
+-- relue. Là où les sessions gardaient au moins une justification discutable, les consultations n'en
+-- avaient aucune — et personne ne l'avait remarqué, parce que la question n'avait jamais été posée
+-- table par table.
+--
+-- ⚠️ MÊME FORME QUE LA 0026, POUR LA MÊME RAISON MESURÉE. On VIDE, on ne supprime pas la colonne.
+-- `DROP COLUMN` marque l'attribut supprimé sans réécrire une seule ligne : les octets restent dans
+-- les pages jusqu'à une réécriture complète de la table, qu'un hôte ne déclenche pas de lui-même —
+-- indéfiniment, et désormais invisibles à toute requête, donc plus jamais vérifiés par personne.
+-- C'est l'UPDATE qui efface : il écrit de nouvelles versions de ligne sans la chaîne et rend les
+-- anciennes mortes, que l'autovacuum de routine récupère seul, sans verrou. La mesure complète est
+-- dans la 0026 et dans `docs/RETENTION.md`.
+--
+-- ⚠️ ET LA SUPPRESSION DES COLONNES RESTE DIFFÉRÉE, pour la raison qui vaut déjà pour `ip` :
+-- `docs/MIGRATIONS.md` exige qu'une migration soit sûre à appliquer PENDANT QUE LA VERSION
+-- PRÉCÉDENTE DU CODE TOURNE. La 0.1.146 écrit encore ces colonnes, et PostgREST rejette une
+-- écriture portant une colonne inconnue : les supprimer aujourd'hui ferait échouer TOUTES les
+-- écritures de consultation et de session d'un hôte qui migre avant de déployer. Les trois
+-- colonnes — `commercial_doc_sessions.ip`, `commercial_doc_sessions.ua`,
+-- `commercial_doc_views.ua` — partiront ensemble, dans une livraison ultérieure, quand plus aucune
+-- version supportée ne les écrira. L'effacement, lui, est complet aujourd'hui.
+--
+-- ⚠️ CE QU'IL NE PEUT PAS ATTEINDRE : les WAL déjà écrits, les sauvegardes, les exports et les
+-- dumps. Ils suivent la politique de l'hébergeur, pas ce fichier. `docs/RETENTION.md` le dit, avec
+-- ce que la rétention de ce lecteur fait expirer et ce qu'elle ne touche pas.
+--
+-- ⚠️ LE SIGNE SONDABLE est le COMMENTAIRE des colonnes, `col_description()` — une migration qui
+-- n'efface que des données ne laisse aucune trace dans `information_schema`, et c'est justement la
+-- migration qu'un hôte devra prouver.
+--
+-- ⚠️ ADDITIVE : aucune colonne, table ou contrainte retirée, rien renommé, rien rendu obligatoire.
+-- ⚠️ IDEMPOTENTE : rejouable sans effet ; le second passage ne trouve plus rien à vider.
+
+update public.commercial_doc_sessions
+   set ua = null
+ where ua is not null;
+
+update public.commercial_doc_views
+   set ua = null
+ where ua is not null;
+
+comment on column public.commercial_doc_sessions.ua is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0027. A porte le User-Agent brut du lecteur. Les champs '
+  'device, os et browser en sont derives A L''ECRITURE et sont, eux, servis. Conservee le temps '
+  'qu''aucune version supportee du lecteur ne l''ecrive. Voir docs/RETENTION.md.';
+
+comment on column public.commercial_doc_views.ua is
+  'VIDE ET PLUS JAMAIS ECRITE depuis la 0027. A porte le User-Agent brut du lecteur. Cette table '
+  'n''en derivait rien et aucune requete ne l''a jamais relue. Conservee le temps qu''aucune '
+  'version supportee du lecteur ne l''ecrive. Voir docs/RETENTION.md.';