diff --git a/index.html b/index.html
index 67c9d393..786cdc5b 100644
--- a/index.html
+++ b/index.html
@@ -51,17 +51,20 @@
         try {
           var standalone = (window.matchMedia && window.matchMedia('(display-mode: standalone)').matches)
             || window.navigator.standalone === true;
-          var profile = false, skipped = false, hasImport = false;
+          var profile = false, skipped = false, hasBootFragment = false;
           // Deux clés : `multiplix-profiles` (index multi-profils) et
           // `multiplix-profile` (ancien schéma mono-profil, migré au boot).
           try { profile = !!(localStorage.getItem('multiplix-profiles') || localStorage.getItem('multiplix-profile')); } catch (e) {}
           try { skipped = localStorage.getItem('multiplix-skip-install') === '1'; } catch (e) {}
-          // Profil dans le fragment d'URL → on boote l'app directement (pas la
-          // landing) : #import= (migration cross-origin depuis l'ancien domaine)
-          // ou #transfer= (transfert depuis un autre appareil, QR de l'espace
-          // parent). L'import réel a lieu dans main.tsx.
-          try { hasImport = location.hash.indexOf('import=') !== -1 || location.hash.indexOf('transfer=') !== -1; } catch (e) {}
-          if (standalone || profile || skipped || hasImport) {
+          // Fragment d'URL porteur d'un profil ou d'un appairage → on boote
+          // l'app directement (pas la landing) : #import= (migration
+          // cross-origin depuis l'ancien domaine), #transfer= (transfert depuis
+          // un autre appareil, QR de l'espace parent), ou #watch= (suivi à
+          // distance : un parent scanne le QR de l'appareil de son enfant, et
+          // n'a rien à faire de la landing). Le traitement réel a lieu dans
+          // main.tsx.
+          try { hasBootFragment = /(import|transfer|watch)=/.test(location.hash); } catch (e) {}
+          if (standalone || profile || skipped || hasBootFragment) {
             document.documentElement.classList.add('skip-static-landing');
           }
           // Langue de l'interface (globale) : préférence explicite stockée,
@@ -79,7 +82,7 @@
           if (lang === 'en') {
             document.title = 'Tablito — Practise the times tables (free, no ads)';
             var desc = document.querySelector('meta[name="description"]');
-            if (desc) desc.setAttribute('content', 'Free, ad-free app to learn the multiplication tables gently, from age 7. Leitner method, no grades or rankings, works offline. Data stays on the device.');
+            if (desc) desc.setAttribute('content', 'Free, ad-free app to learn the multiplication tables gently, from age 7. Leitner method, no grades or rankings, works offline. Data stays on the device by default.');
             // Manifest localisé : le standard n'a pas de description multilingue,
             // donc un fichier par langue, basculé ici (le <link rel="manifest">
             // existe déjà plus haut). Seule la `description` diffère ; le nom et
@@ -123,7 +126,7 @@
           media="(device-width: 834px) and (device-height: 1194px) and (-webkit-device-pixel-ratio: 2) and (orientation: portrait)" />
 
     <title>Tablito — Réviser les tables de multiplication (gratuit, sans pub)</title>
-    <meta name="description" content="Appli gratuite et sans publicité pour apprendre les tables de multiplication en douceur, dès le CE1. Méthode Leitner, sans notes ni classement, fonctionne hors-ligne. Les données restent sur l'appareil." />
+    <meta name="description" content="Appli gratuite et sans publicité pour apprendre les tables de multiplication en douceur, dès le CE1. Méthode Leitner, sans notes ni classement, fonctionne hors-ligne. Les données restent sur l'appareil par défaut." />
     <link rel="canonical" href="https://tablito.app/" />
 
     <!-- Open Graph / Twitter : aperçu riche quand l'URL est partagée (groupes
@@ -251,8 +254,8 @@ <h1 class="landing-title">Tablito</h1>
             <span class="landing-principle-icon" aria-hidden="true">
               <svg viewBox="0 0 24 24" width="22" height="22"><circle cx="12" cy="12" r="9" fill="none" stroke="currentColor" stroke-width="1.8" /><path d="M8 12l3 3 5-6" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" /></svg>
             </span>
-            <span data-lang="fr"><strong>Hors-ligne, sans pub, sans compte.</strong> Une fois installé, plus besoin de connexion. Les données restent sur l'appareil.</span>
-            <span data-lang="en"><strong>Offline, no ads, no account.</strong> Once installed, no connection needed. Data stays on the device.</span>
+            <span data-lang="fr"><strong>Hors-ligne, sans pub, sans compte.</strong> Une fois installé, plus besoin de connexion. Les données restent sur l'appareil par défaut.</span>
+            <span data-lang="en"><strong>Offline, no ads, no account.</strong> Once installed, no connection needed. Data stays on the device by default.</span>
           </li>
         </ul>
 
diff --git a/public/specs/index.html b/public/specs/index.html
index fc33b9cb..dd4e17cd 100644
--- a/public/specs/index.html
+++ b/public/specs/index.html
@@ -347,6 +347,7 @@ <h1>Tablito<em>.</em></h1>
     <li><a href="#division">Niveau 2 — Réviser par la division</a></li>
     <li><a href="#reste">Niveau 3 — La division avec reste</a></li>
     <li><a href="#profils">Multi-profils — plusieurs enfants par appareil</a></li>
+    <li><a href="#suivi">Suivi à distance — le parent sur son propre appareil</a></li>
     <li><a href="#evolutions">Évolutions possibles (V2)</a></li>
     <li><a href="#references">Références</a></li>
   </ol>
@@ -783,6 +784,7 @@ <h3 id="prog-parent"><span class="num">5.2</span>Vue parent : tableau de bord</h
     <li><strong>Envoyer un avis</strong> : formulaire texte libre + email optionnel. Les envois atterrissent dans une table Supabase (policy RLS insert-only via la publishable key). Un contexte anonyme (user-agent, viewport, stats agrégées du profil — nombre de séances, faits maîtrisés, streak) est joint pour faciliter le triage. Lecture réservée au propriétaire de l'app via la secret key (stockée en local, hors du repo)</li>
     <li><strong>Partager l'app</strong> : ouvre la feuille de partage native du téléphone (iMessage, WhatsApp, mail…) pour envoyer le lien de Tablito ; sur ordinateur, le lien est copié dans le presse-papiers</li>
     <li><strong>Rappel quotidien</strong> : toggle opt-in qui active une notification push quotidienne (détails en §8.1)</li>
+    <li><strong>Suivi à distance</strong> : partager la progression de cet appareil vers celui d'un parent, ou suivre un enfant qui pratique ailleurs (détails en §14)</li>
     <li><strong>Confidentialité</strong> : page dédiée expliquant le traitement des données (localStorage, Supabase pour avis et push, droits associés)</li>
     <li><strong>Nouveautés</strong> : journal des évolutions visibles côté enfant ou parent (alimenté par <code>src/lib/changelog.ts</code>)</li>
     <li><strong>Réinitialiser le profil</strong> : efface les données locales et relance le test de positionnement — utile pour repartir de zéro ou changer d'enfant</li>
@@ -1068,15 +1070,37 @@ <h3 id="profils-stockage"><span class="num">13.2</span>Stockage et migration</h3
   <p>Le <strong>transfert par QR code</strong> (§7) est lui aussi par-profil : le profil reçu devient un nouveau profil actif sur l'appareil de destination — sauf si le même enfant (prénom + date de début identiques) y existe déjà, auquel cas son profil est mis à jour au lieu d'être dupliqué (cas du re-transfert). Pendant la récupération, l'app affiche « Récupération de la progression… » (pas d'écran vide entre le scan et l'arrivée) ; l'import réussi est confirmé par une bannière « bien arrivée ✓ », un transfert échoué (lien expiré ou déjà servi) par une bannière d'erreur.</p>
 </section>
 
+<section class="chapter" id="suivi">
+  <h2><span class="num">14</span>Suivi à distance — le parent sur son propre appareil</h2>
+  <p>Le multi-profils (§13) couvre la tablette familiale partagée. Il ne couvre pas le cas, très courant, où l'enfant pratique sur un <strong>appareil qui n'est pas celui du parent</strong> — un ancien téléphone de la famille, en WiFi seul, gardé pour lui. Le parent n'a alors aucune visibilité sur la progression : le tableau de bord parent (§8) existe, mais il vit sur l'appareil de l'enfant.</p>
+  <p>Le suivi à distance répond à ce besoin sans introduire ni compte, ni mot de passe, ni adresse e-mail. Deux rôles, non exclusifs sur un même appareil : <strong>publieur</strong> (l'appareil de l'enfant) et <strong>suiveur</strong> (celui du parent).</p>
+
+  <h3 id="suivi-parcours"><span class="num">14.1</span>Parcours</h3>
+  <ul>
+    <li><strong>Ouvrir le partage</strong> (appareil de l'enfant) : « Partager la progression de &lt;prénom&gt; » dans l'espace parent, section « Suivi à distance ». Affiche un QR code — et un lien copiable en repli.</li>
+    <li><strong>Appairer</strong> (appareil du parent) : deux chemins. Scanner le QR avec l'appareil photo du téléphone, ce qui ouvre Tablito sur le lien ; ou, si Tablito est déjà installé, « Suivre un enfant à distance » depuis l'espace parent, qui filme le QR avec la caméra in-app (indispensable sur iPhone, où un lien n'ouvre jamais la web app installée).</li>
+    <li><strong>Parent qui n'a pas encore Tablito</strong> : le QR l'amène sur le site, et l'app boote <em>directement</em> sur l'espace parent avec la progression de l'enfant. Aucun onboarding enfant (prénom, test de placement) ne lui est proposé — ce serait un contresens : il n'est pas venu s'entraîner. La landing statique est également sautée.</li>
+    <li><strong>Consulter</strong> : le tableau de bord distant est le même écran que le tableau de bord local, aux mêmes statistiques. Une barre de fraîcheur indique la date du dernier dépôt (« Synchronisé il y a 2 h ») avec un bouton « Actualiser » — sans elle, un appareil enfant éteint depuis une semaine afficherait des chiffres périmés sans le dire.</li>
+    <li><strong>Deux sources côte à côte</strong> : un parent peut avoir son propre profil local (pour s'entraîner lui-même) <em>et</em> suivre un enfant à distance. Un sélecteur en tête de l'espace parent bascule d'une source à l'autre. Il n'apparaît que s'il y a vraiment un choix à faire.</li>
+    <li><strong>Arrêter</strong> : « Ne plus partager » côté enfant supprime le dépôt (les appareils suiveurs l'annoncent explicitement, distinct d'une panne réseau) ; « Ne plus suivre » côté parent oublie le suivi localement.</li>
+  </ul>
+
+  <h3 id="suivi-modele"><span class="num">14.2</span>Modèle et garanties</h3>
+  <p>Après chaque séance, l'appareil de l'enfant dépose un instantané de son profil, <strong>gzippé puis chiffré côté client</strong> (AES-GCM, clé aléatoire), sous un code de 96 bits. C'est la primitive du transfert (§7) : la clé de déchiffrement voyage dans le fragment d'URL du QR, jamais transmise au serveur, qui ne voit donc passer qu'un blob opaque.</p>
+  <p>Deux différences avec un transfert, qui justifient une table distincte : le dépôt est <strong>durable</strong> (rafraîchi à chaque séance au lieu d'être consommé) et la lecture est <strong>non consommante</strong>. Le code est donc une capacité permanente jusqu'à révocation — garde-fous : entropie inénumérable, clé jamais exposée au serveur (un dump de la base ne donne rien de lisible), révocation explicite, et purge automatique d'un suivi que plus aucune séance n'a rafraîchi depuis 6 mois.</p>
+  <p>Le profil suivi n'est <strong>jamais installé</strong> sur l'appareil du parent : il ne vit qu'en mémoire, le temps de l'afficher. Installé, il se mêlerait aux profils locaux (« Qui joue ? »), et une séance faite par erreur dessus divergerait de l'appareil de l'enfant, que le dépôt suivant écraserait.</p>
+  <p>Conséquence assumée sur les sections propres à l'appareil : sauvegarde, transfert, rappel quotidien et suppression de profil disparaissent quand la source affichée est un enfant distant — elles parleraient d'une progression qu'on n'a pas en main.</p>
+</section>
+
 <section class="chapter" id="evolutions">
-  <h2><span class="num">14</span>Évolutions possibles (V2)</h2>
+  <h2><span class="num">15</span>Évolutions possibles (V2)</h2>
   <ul>
     <li>Mode défi : séance bonus optionnelle le week-end</li>
   </ul>
 </section>
 
 <section class="chapter" id="references">
-  <h2><span class="num">15</span>Références</h2>
+  <h2><span class="num">16</span>Références</h2>
   <ol class="references">
     <li>Axtell, P. K., McCallum, R. S., Bell, S. M., &amp; Poncy, B. (2009). Developing math automaticity using a classwide fluency building procedure for middle school students: A preliminary study. <em>Psychology in the Schools, 46</em>(6), 526–538.</li>
     <li>Brendefur, J., Strother, S., Thiede, K., &amp; Appleton, S. (2015). Developing multiplication fact fluency. <em>Advances in Social Sciences Research Journal, 2</em>(8). <a href="https://doi.org/10.14738/assrj.28.1396">doi:10.14738/assrj.28.1396</a></li>
diff --git a/src/App.tsx b/src/App.tsx
index 57b8d5dd..c30574e7 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -27,6 +27,7 @@ import {
   deleteActiveProfile,
   setActiveProfile,
   listProfiles,
+  getActiveProfileId,
   createNewProfile,
   exportProfile,
   importProfile,
@@ -41,6 +42,8 @@ import { applyStreakUpdate } from './lib/streak';
 import { isStandalone, clearInstallSkipped } from './lib/install';
 import { preflightMicPermission } from './lib/micPreflight';
 import { syncLastSession } from './lib/push';
+import { listWatched } from './lib/watchStore';
+import type { WatchPairing } from './lib/watch';
 import { isVoiceMode } from './hooks/useInputMode';
 import { useAppStrings } from './i18n/app';
 // Eager : parcours principal (onboarding + boucle quotidienne). Ces
@@ -99,7 +102,13 @@ function initialScreen(profile: UserProfile | null, profileCount: number): Scree
   // devine jamais quel enfant tient la tablette. Mono-profil : parcours
   // inchangé, zéro friction ajoutée.
   if (profileCount > 1) return 'profiles';
-  if (!profile) return 'welcome';
+  if (!profile) {
+    // Aucun profil local mais au moins un enfant suivi à distance : l'appareil
+    // est celui d'un parent (il a peut-être découvert Tablito en scannant le QR
+    // de son enfant). Lui proposer l'onboarding enfant — prénom, test de
+    // placement — serait un contresens : on ouvre son espace parent.
+    return listWatched().length > 0 ? 'parent' : 'welcome';
+  }
   return profileHome(profile);
 }
 
@@ -125,13 +134,22 @@ interface AppProps {
   // expiré, déjà consommé, hors-ligne…). Annoncé une fois, quel que soit
   // l'écran d'arrivée.
   transferResult?: 'imported' | 'error' | null;
+  // Issu d'un #watch= présent au boot : le parent vient de scanner le QR de
+  // l'appareil de son enfant. Déjà déchiffré par main.tsx, transmis tel quel à
+  // l'espace parent pour un affichage immédiat.
+  watchPairing?: WatchPairing | 'error' | null;
 }
 
-export default function App({ transferResult = null }: AppProps) {
+export default function App({ transferResult = null, watchPairing = null }: AppProps) {
   const appStrings = useAppStrings();
   const [transferNotice, setTransferNotice] = useState(transferResult);
   const [profile, setProfile] = useState<UserProfile | null>(() => loadProfile());
-  const [screen, setScreen] = useState<Screen>(() => initialScreen(profile, listProfiles().length));
+  // Un #watch= au boot signifie que le parent vient de scanner le QR de son
+  // enfant : quoi qu'il y ait par ailleurs sur l'appareil, ce qu'il veut voir
+  // est l'espace parent (même en cas d'échec — il peut y réessayer l'appairage).
+  const [screen, setScreen] = useState<Screen>(() =>
+    watchPairing ? 'parent' : initialScreen(profile, listProfiles().length),
+  );
   // Pilote l'affichage du bouton « changer de joueur » sur Home et le retour
   // du Welcome « ajout d'un enfant ». Lu à chaque render : l'index est
   // minuscule et ne change que via des flows qui re-rendent déjà App.
@@ -615,6 +633,18 @@ export default function App({ transferResult = null }: AppProps) {
       // pour que le cron saute l'envoi du soir. Best-effort (no-op si non
       // abonné / push non configuré), jamais bloquant pour le recap.
       void syncLastSession();
+
+      // Suivi à distance : rafraîchit l'instantané chiffré que consulte le
+      // parent sur son propre appareil. Même esprit que ci-dessus — no-op si le
+      // profil n'est pas partagé, et un échec (hors-ligne) sera rattrapé par la
+      // séance suivante, donc jamais bloquant pour le recap.
+      // Import dynamique : lib/watch tire le chiffrement (et transfer.ts) —
+      // hors de question de les faire entrer dans le graphe eager du boot pour
+      // un chemin qui ne sert qu'aux profils partagés.
+      const activeId = getActiveProfileId();
+      if (activeId) {
+        void import('./lib/watch').then((m) => m.publishWatchSnapshot(activeId, updatedProfile));
+      }
     },
     [profile, divisionUnlocked, remainderUnlocked, sessionMode],
   );
@@ -688,6 +718,13 @@ export default function App({ transferResult = null }: AppProps) {
     if (!profile) return;
     const ok = window.confirm(appStrings.confirmDeleteProfile(profile.name));
     if (!ok) return;
+    // Le profil part d'ici, donc son suivi à distance n'a plus d'objet : on
+    // révoque le dépôt AVANT de perdre l'id qui porte ses identifiants, sinon un
+    // instantané relisible survivrait à l'enfant (purgé au mieux après 6 mois).
+    const deletedId = getActiveProfileId();
+    if (deletedId) {
+      void import('./lib/watch').then((m) => m.stopWatch(deletedId));
+    }
     deleteActiveProfile();
     // Même décision qu'au boot : plusieurs enfants → « Qui joue ? » ; un seul
     // → son accueil directement ; aucun → onboarding complet.
@@ -728,7 +765,10 @@ export default function App({ transferResult = null }: AppProps) {
           // Annulable uniquement en mode « ajout d'un enfant » (il existe
           // déjà au moins un profil) : au tout premier onboarding il n'y a
           // nulle part où revenir.
-          onCancel={profileCount > 0 ? handleWelcomeCancel : undefined}
+          // Annulable dès qu'il y a un écran d'arrivée ailleurs : un profil
+          // local, OU un enfant suivi à distance (sinon le parent qui tape
+          // « Créer un profil sur cet appareil » reste piégé dans l'onboarding).
+          onCancel={profileCount > 0 || listWatched().length > 0 ? handleWelcomeCancel : undefined}
         />
       )}
 
@@ -806,10 +846,16 @@ export default function App({ transferResult = null }: AppProps) {
         <RulesScreen onBack={() => setScreen('home')} showRule11={rule11Unlocked} />
       )}
 
-      {screen === 'parent' && profile && (
+      {/* `watchPairing` compte, y compris quand il vaut 'error' : un parent sans
+          Tablito qui scanne un QR périmé n'a ni profil local ni suivi mémorisé,
+          et sans ce terme il tomberait sur un écran blanc au lieu de l'espace
+          parent, d'où il peut réessayer l'appairage. */}
+      {screen === 'parent' && (profile || watchPairing || listWatched().length > 0) && (
         <ParentDashboard
           profile={profile}
-          onBack={() => setScreen('home')}
+          initialWatch={watchPairing && watchPairing !== 'error' ? watchPairing : null}
+          // Sans profil local, l'espace parent EST l'app : nulle part où revenir.
+          onBack={profile ? () => setScreen('home') : undefined}
           onExport={handleExport}
           onImport={handleImport}
           onAddProfile={handleAddProfile}
diff --git a/src/__tests__/helpers/watchServer.ts b/src/__tests__/helpers/watchServer.ts
new file mode 100644
index 00000000..3eb8dbaf
--- /dev/null
+++ b/src/__tests__/helpers/watchServer.ts
@@ -0,0 +1,57 @@
+// Serveur `watches` en mémoire pour les tests du suivi à distance, avec la
+// sémantique exacte des RPC de supabase/watches.sql : dépôt idempotent par code,
+// lecture NON consommante (à l'inverse de read_transfer), révocation destructive.
+//
+// Partagé par watch.test.ts et remoteFollow.test.tsx pour que le contrat de fil
+// (`p_code`, `p_payload`, `updated_at`, codes de statut) n'ait qu'un seul endroit
+// à corriger le jour où le SQL bouge. Ce fichier n'est pas un `*.test.ts` : il
+// n'est donc pas collecté comme suite par la config vitest par défaut.
+
+import { vi } from 'vitest';
+
+export interface WatchRow {
+  payload: string;
+  updated_at: string;
+}
+
+interface MockOptions {
+  // Que faire des appels hors `watches`. 'throw' pour les tests unitaires (tout
+  // appel inattendu est un bug du test) ; 'ignore' pour les tests d'intégration,
+  // où l'app émet aussi des appels push / feedback qui ne sont pas le sujet.
+  otherCalls?: 'throw' | 'ignore';
+}
+
+/** Stub `fetch` et renvoie la table, pour inspection dans les assertions. */
+export function mockWatchServer({ otherCalls = 'throw' }: MockOptions = {}): Map<string, WatchRow> {
+  const rows = new Map<string, WatchRow>();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async (url: string, init?: RequestInit) => {
+      const name = String(url).split('/rpc/')[1];
+      if (name === 'publish_watch' || name === 'read_watch' || name === 'revoke_watch') {
+        const body = JSON.parse(String(init?.body));
+        if (name === 'publish_watch') {
+          rows.set(body.p_code, {
+            payload: body.p_payload,
+            updated_at: new Date().toISOString(),
+          });
+          return new Response(null, { status: 204 });
+        }
+        if (name === 'read_watch') {
+          return new Response(JSON.stringify(rows.get(body.p_code) ?? null), { status: 200 });
+        }
+        rows.delete(body.p_code);
+        return new Response(null, { status: 204 });
+      }
+      if (otherCalls === 'ignore') return new Response(null, { status: 204 });
+      throw new Error(`unexpected fetch ${url}`);
+    }),
+  );
+  return rows;
+}
+
+/** Config Supabase minimale attendue par lib/watch (à appeler en beforeEach). */
+export function stubSupabaseEnv(): void {
+  vi.stubEnv('VITE_SUPABASE_URL', 'https://sb.test');
+  vi.stubEnv('VITE_SUPABASE_PUBLISHABLE_KEY', 'pk_test');
+}
diff --git a/src/__tests__/remoteFollow.test.tsx b/src/__tests__/remoteFollow.test.tsx
new file mode 100644
index 00000000..7a37fa6e
--- /dev/null
+++ b/src/__tests__/remoteFollow.test.tsx
@@ -0,0 +1,284 @@
+import { act, cleanup, fireEvent, render } from '@testing-library/preact';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import App from '../App';
+import { addProfile, createNewProfile, listProfiles } from '../lib/storage';
+import { startWatch, addWatched, type WatchPairing } from '../lib/watch';
+import { listWatched } from '../lib/watchStore';
+import { mockWatchServer, stubSupabaseEnv } from './helpers/watchServer';
+// Préchauffe le chunk de ParentDashboard pour que le React.lazy() côté App.tsx
+// se résolve en synchrone dans les tests qui ouvrent le dashboard.
+import '../screens/ParentDashboard';
+
+// ---------------------------------------------------------------------------
+// Suivi à distance, vu de l'app entière : l'appareil du parent affiche la
+// progression d'un enfant qui pratique ailleurs. Le cas nerveux est l'appareil
+// SANS profil local — un parent qui découvre Tablito en scannant le QR de son
+// enfant ne doit jamais tomber sur l'onboarding enfant (prénom, test de
+// placement), qui n'a aucun sens pour lui.
+// ---------------------------------------------------------------------------
+
+// Joue le côté enfant : un profil pratiquant, partagé, et le lien à scanner.
+async function shareChildProgress(name: string, totalSessions = 9) {
+  const profile = createNewProfile(name);
+  profile.hasSeenRulesIntro = true;
+  profile.totalSessions = totalSessions;
+  const id = addProfile(profile);
+  const link = (await startWatch(id, profile))!;
+  return { link, id, profile };
+}
+
+// Monte l'app et laisse le React.lazy() de ParentDashboard se résoudre : il se
+// règle en microtâche, donc le tout premier rendu d'un fichier de test a besoin
+// d'un tick de plus que les suivants (où le module est déjà résolu).
+async function renderApp(props: { watchPairing?: WatchPairing | 'error' | null } = {}) {
+  await act(async () => {
+    render(<App {...props} />);
+  });
+  await flush();
+}
+
+// Boucle de flush, dans l'esprit de openParentDashboard (multiProfile.test.tsx),
+// mais sur des MACROtâches : deux chaînes asynchrones s'enchaînent ici, l'import
+// dynamique de ParentDashboard (lazy + Suspense) puis la relecture du suivi, et
+// le Response.json() d'undici ne se règle pas en microtâche — un flush de
+// Promise.resolve() laisserait la vue bloquée sur « Récupération… ».
+async function flush(rounds = 20) {
+  for (let i = 0; i < rounds; i++) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  }
+}
+
+function findButton(label: RegExp): HTMLButtonElement | null {
+  return (
+    (Array.from(document.querySelectorAll('button')).find((b) =>
+      label.test((b.textContent ?? '').trim()),
+    ) as HTMLButtonElement | null) ?? null
+  );
+}
+
+function tabLabels(): string[] {
+  return Array.from(document.querySelectorAll('.parent-op-tabs .progress-tab')).map((t) =>
+    (t.textContent ?? '').trim(),
+  );
+}
+
+// Nombre affiché sous le libellé « Séances » de la vue d'ensemble.
+function sessionsShown(): string {
+  const cards = Array.from(document.querySelectorAll('.parent-stat-card'));
+  const card = cards.find((c) =>
+    /Séances/.test(c.querySelector('.parent-stat-label')?.textContent ?? ''),
+  );
+  return card?.querySelector('.parent-stat-value')?.textContent ?? '';
+}
+
+beforeEach(() => {
+  localStorage.clear();
+  localStorage.setItem('multiplix-lang', 'fr');
+  stubSupabaseEnv();
+  window.location.hash = '';
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+
+describe('appareil qui ne fait que suivre (aucun profil local)', () => {
+  // Reproduit l'appareil du parent : l'enfant a partagé depuis le sien, le
+  // parent a scanné, et il ne reste QUE l'entrée de suivi en local.
+  async function seedWatcherOnly(name = 'Zoé', totalSessions = 9) {
+    const { link } = await shareChildProgress(name, totalSessions);
+    localStorage.clear();
+    localStorage.setItem('multiplix-lang', 'fr');
+    const paired = await addWatched(link);
+    return { link, paired: paired! };
+  }
+
+  it('boote sur l’espace parent au lieu de l’onboarding enfant', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedWatcherOnly();
+    expect(listProfiles()).toHaveLength(0);
+
+    await renderApp();
+
+    // Espace parent, pas le Welcome : aucun champ de prénom ni test de placement.
+    expect(document.querySelector('.parent-dashboard')).not.toBeNull();
+    expect(document.querySelector('.welcome-screen')).toBeNull();
+    expect(sessionsShown()).toBe('9');
+    // Rien où revenir : pas de chevron de retour.
+    expect(document.querySelector('.parent-back-btn')).toBeNull();
+  });
+
+  it('masque les sections propres à un profil local', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedWatcherOnly();
+
+    await renderApp();
+
+    // Sauvegarde / transfert / rappels / suppression parleraient d'une
+    // progression qui n'est pas sur cet appareil.
+    expect(findButton(/^Transférer$/)).toBeNull();
+    expect(findButton(/^Supprimer ce profil$/)).toBeNull();
+    expect(document.querySelector('.notification-settings')).toBeNull();
+    // En revanche, la porte de sortie vers un profil local est offerte.
+    expect(findButton(/Créer un profil sur cet appareil/)).not.toBeNull();
+  });
+
+  it('laisse ressortir de l’onboarding après « Créer un profil sur cet appareil »', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedWatcherOnly();
+
+    await renderApp();
+    await act(async () => {
+      fireEvent.click(findButton(/Créer un profil sur cet appareil/)!);
+    });
+
+    // L'onboarding enfant s'ouvre — mais il DOIT être annulable : sans profil
+    // local, l'ancien garde (`profileCount > 0`) n'affichait aucun bouton
+    // Annuler et le parent restait piégé là, sans retour vers son espace.
+    const cancel = findButton(/^Annuler$/);
+    expect(cancel).not.toBeNull();
+    await act(async () => {
+      fireEvent.click(cancel!);
+    });
+    await flush();
+    expect(document.querySelector('.parent-dashboard')).not.toBeNull();
+  });
+
+  it('affiche directement l’enfant appairé au boot depuis un #watch=', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    const { paired } = await seedWatcherOnly('Nino', 21);
+
+    await renderApp({ watchPairing: paired });
+
+    expect(document.querySelector('.parent-title')?.textContent).toContain('Nino');
+    expect(sessionsShown()).toBe('21');
+  });
+
+  it('reste sur l’espace parent si l’appairage a échoué, pour pouvoir réessayer', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedWatcherOnly();
+
+    await renderApp({ watchPairing: 'error' });
+
+    expect(document.querySelector('.parent-dashboard')).not.toBeNull();
+    expect(findButton(/Suivre un enfant à distance/)).not.toBeNull();
+  });
+  it('n’affiche pas un écran blanc quand un QR périmé est scanné sur un appareil vierge', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    // Appareil totalement vierge : ni profil local, ni suivi déjà connu. C'est le
+    // cas d'un parent sans Tablito qui scanne un QR expiré ou révoqué.
+    expect(listProfiles()).toHaveLength(0);
+    expect(listWatched()).toHaveLength(0);
+
+    await renderApp({ watchPairing: 'error' });
+
+    // Quelque chose DOIT s'afficher, avec un chemin de récupération.
+    expect(document.querySelector('.parent-dashboard')).not.toBeNull();
+    expect(findButton(/Suivre un enfant à distance/)).not.toBeNull();
+  });
+});
+
+// Crée un profil via le vrai parcours Welcome (prénom + « Passer le test »),
+// puis ferme l'intro des règles. Même helper que multiProfile.test.tsx.
+function completeWelcome(name: string): void {
+  fireEvent.click(findButton(/^Suivant/)!);
+  const nameInput = document.querySelector<HTMLInputElement>('input.welcome-input')!;
+  fireEvent.change(nameInput, { target: { value: name } });
+  fireEvent.click(findButton(/^C'est moi/)!);
+  fireEvent.click(findButton(/Passer le test/)!);
+  fireEvent.click(findButton(/C'est parti/)!);
+  fireEvent.click(findButton(/Suivant/)!);
+  fireEvent.click(findButton(/J'ai compris/)!);
+}
+
+describe('appareil mixte : un profil local ET un enfant suivi', () => {
+  // Le cas d'usage d'origine : le parent pratique lui-même sur son téléphone et
+  // suit son enfant, qui pratique sur un autre appareil.
+  async function seedMixed() {
+    const { link } = await shareChildProgress('Zoé', 30);
+    localStorage.clear();
+    localStorage.setItem('multiplix-lang', 'fr');
+    await addWatched(link);
+    const mine = createNewProfile('Papa');
+    mine.hasSeenRulesIntro = true;
+    mine.totalSessions = 4;
+    addProfile(mine);
+  }
+
+  it('un suiveur peut se créer un profil après coup, et les deux coexistent', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    // Départ : appareil de parent, aucun profil local, un enfant suivi.
+    const { link } = await shareChildProgress('Zoé', 30);
+    localStorage.clear();
+    localStorage.setItem('multiplix-lang', 'fr');
+    await addWatched(link);
+
+    await renderApp();
+    // Il est bien sur l'espace parent, et la porte de sortie est offerte.
+    await act(async () => {
+      fireEvent.click(findButton(/Créer un profil sur cet appareil/)!);
+    });
+
+    // Parcours d'onboarding complet, pour lui cette fois. Hors act() : fireEvent
+    // enveloppe déjà chaque événement, et tout batcher empêcherait les étapes de
+    // Welcome de se rendre entre les clics.
+    completeWelcome('Papa');
+    await flush();
+
+    // Le profil local existe SANS avoir chassé le suivi de Zoé.
+    expect(listProfiles().map((p) => p.name)).toEqual(['Papa']);
+    expect(listWatched().map((w) => w.name)).toEqual(['Zoé']);
+    // Et il atterrit sur SON accueil, pas sur l'espace parent.
+    expect(document.querySelector('.home-greeting')?.textContent).toContain('Papa');
+  });
+
+  it('propose les deux sources et bascule de l’une à l’autre', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedMixed();
+
+    await renderApp();
+    // Boot normal : l'accueil de l'enfant local, pas l'espace parent.
+    expect(document.querySelector('.parent-dashboard')).toBeNull();
+
+    // Le suivi ne pollue PAS les profils locaux (« Qui joue ? » reste mono).
+    expect(listProfiles()).toHaveLength(1);
+    expect(listWatched()).toHaveLength(1);
+  });
+
+  it('sélecteur de source : profil local par défaut, puis l’enfant distant', async () => {
+    mockWatchServer({ otherCalls: 'ignore' });
+    await seedMixed();
+    const paired = listWatched()[0];
+
+    // On ouvre l'espace parent via l'appairage au boot, ce qui évite de rejouer
+    // le ParentGate (déjà couvert par multiProfile.test.tsx).
+    const child = { ...createNewProfile('Zoé'), totalSessions: 30 };
+    await renderApp({
+      watchPairing: { entry: paired, snapshot: { profile: child, updatedAt: new Date().toISOString() } },
+    });
+
+    // Deux onglets de source : le profil local et l'enfant suivi.
+    const labels = tabLabels();
+    expect(labels.some((l) => /Papa/.test(l))).toBe(true);
+    expect(labels.some((l) => /Zoé/.test(l) && /distance/.test(l))).toBe(true);
+
+    // On arrive sur l'enfant scanné…
+    expect(sessionsShown()).toBe('30');
+
+    // …et la bascule vers le profil local montre bien SES stats.
+    const localTab = Array.from(
+      document.querySelectorAll('.parent-op-tabs .progress-tab'),
+    ).find((t) => /Papa/.test(t.textContent ?? '')) as HTMLButtonElement;
+    await act(async () => {
+      fireEvent.click(localTab);
+    });
+    expect(sessionsShown()).toBe('4');
+    // Sur le profil local, les actions locales réapparaissent.
+    expect(findButton(/^Supprimer ce profil$/)).not.toBeNull();
+  });
+});
diff --git a/src/__tests__/setup.ts b/src/__tests__/setup.ts
index 72c2d31f..11b909d7 100644
--- a/src/__tests__/setup.ts
+++ b/src/__tests__/setup.ts
@@ -1,3 +1,5 @@
+import { webcrypto } from 'node:crypto';
+
 // Vitest setup file — runs once per test file before the tests.
 //
 // i18n : jsdom ET Node 22 exposent `navigator.language` = 'en-US', ce qui
@@ -104,3 +106,10 @@ globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
   }
   return realFetch(input as RequestInfo, init);
 }) as typeof fetch;
+
+// jsdom expose parfois un `crypto` sans SubtleCrypto, alors que le chiffrement
+// du transfert et du suivi à distance (AES-GCM) en dépend. On garantit l'API
+// WebCrypto complète de Node — même implémentation que les navigateurs.
+if (!globalThis.crypto?.subtle) {
+  Object.defineProperty(globalThis, 'crypto', { value: webcrypto, configurable: true });
+}
diff --git a/src/__tests__/watch.test.ts b/src/__tests__/watch.test.ts
new file mode 100644
index 00000000..13475c13
--- /dev/null
+++ b/src/__tests__/watch.test.ts
@@ -0,0 +1,223 @@
+// Suivi à distance (src/lib/watch.ts) : l'appareil de l'enfant publie des
+// instantanés chiffrés durables, l'appareil du parent les relit sans jamais
+// installer le profil — y compris quand il n'a aucun profil local (parent qui
+// découvre Tablito en scannant le QR).
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { addProfile, createNewProfile, listProfiles } from '../lib/storage';
+import {
+  startWatch,
+  stopWatch,
+  publishWatchSnapshot,
+  addWatched,
+  fetchWatched,
+  importWatchFromUrl,
+} from '../lib/watch';
+import {
+  listWatched,
+  loadWatchCredentials,
+  parseWatchLink,
+  removeWatched,
+} from '../lib/watchStore';
+import { mockWatchServer, stubSupabaseEnv } from './helpers/watchServer';
+
+function makeProfile(name = 'Zoé') {
+  const profile = createNewProfile(name);
+  profile.totalSessions = 7;
+  profile.currentStreak = 3;
+  return profile;
+}
+
+beforeEach(() => {
+  localStorage.clear();
+  localStorage.setItem('multiplix-lang', 'fr');
+  stubSupabaseEnv();
+  window.location.hash = '';
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+
+describe('côté publieur (appareil de l’enfant)', () => {
+  it('ouvre un partage, mémorise les identifiants et publie un instantané', async () => {
+    const rows = mockWatchServer();
+    const profile = makeProfile();
+    const id = addProfile(profile);
+
+    const link = await startWatch(id, profile);
+    expect(link).toMatch(/#watch=[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]+$/);
+    expect(rows.size).toBe(1);
+
+    const creds = loadWatchCredentials(id);
+    expect(creds).not.toBeNull();
+    // Le blob déposé est opaque : le prénom n'y apparaît pas.
+    expect(rows.get(creds!.code)!.payload).not.toContain('Zoé');
+  });
+
+  it('réutilise le même code si le partage est déjà ouvert', async () => {
+    mockWatchServer();
+    const profile = makeProfile();
+    const id = addProfile(profile);
+
+    const first = await startWatch(id, profile);
+    const second = await startWatch(id, profile);
+    // Un code neuf couperait silencieusement les appareils déjà appairés.
+    expect(second).toBe(first);
+  });
+
+  it('ne mémorise rien si le premier dépôt échoue', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => new Response(null, { status: 500 })));
+    const profile = makeProfile();
+    const id = addProfile(profile);
+
+    expect(await startWatch(id, profile)).toBeNull();
+    // Sinon l'espace parent afficherait « partagé » sans ligne côté serveur.
+    expect(loadWatchCredentials(id)).toBeNull();
+  });
+
+  it('rafraîchit l’instantané en fin de séance, no-op si non partagé', async () => {
+    const rows = mockWatchServer();
+    const profile = makeProfile();
+    const id = addProfile(profile);
+
+    // Non partagé : aucun appel réseau.
+    await publishWatchSnapshot(id, profile);
+    expect(rows.size).toBe(0);
+
+    await startWatch(id, profile);
+    const { code } = loadWatchCredentials(id)!;
+    const firstBlob = rows.get(code)!.payload;
+
+    await publishWatchSnapshot(id, { ...profile, totalSessions: 8 });
+    expect(rows.get(code)!.payload).not.toBe(firstBlob);
+    expect(rows.size).toBe(1); // rafraîchi, pas empilé
+  });
+});
+
+describe('côté suiveur (appareil du parent)', () => {
+  // Rejoue un appairage complet : l'enfant partage, le parent scanne. Renvoie
+  // le lien et le profil publié.
+  async function pairedLink(name = 'Zoé') {
+    const profile = makeProfile(name);
+    const id = addProfile(profile);
+    const link = (await startWatch(id, profile))!;
+    return { link, profile, id };
+  }
+
+  it('suit un profil sans jamais l’installer localement', async () => {
+    mockWatchServer();
+    const { link } = await pairedLink();
+
+    // « Téléphone du parent » : appareil distinct, sans aucun profil.
+    localStorage.clear();
+    const paired = await addWatched(link);
+
+    expect(paired?.snapshot.profile.name).toBe('Zoé');
+    expect(paired?.snapshot.profile.totalSessions).toBe(7);
+    expect(paired?.snapshot.updatedAt).toBeTruthy();
+    // L'entrée créée est renvoyée : l'UI sélectionne le bon onglet sans avoir à
+    // retrouver le suivi par prénom (deux enfants peuvent s'appeler pareil).
+    expect(paired?.entry.code).toBe(parseWatchLink(link)!.code);
+    // L'essentiel : le profil suivi ne rejoint PAS les profils locaux, sinon il
+    // apparaîtrait dans « Qui joue ? » et une séance dessus le ferait diverger.
+    expect(listProfiles()).toHaveLength(0);
+    expect(listWatched()).toHaveLength(1);
+    expect(listWatched()[0].name).toBe('Zoé');
+  });
+
+  it('voit les mises à jour publiées ensuite (lecture non consommante)', async () => {
+    mockWatchServer();
+    const { link, profile, id } = await pairedLink();
+    await addWatched(link);
+    const creds = parseWatchLink(link)!;
+
+    // Deux relectures d'affilée : rien n'est consommé côté serveur.
+    expect(await fetchWatched(creds)).not.toBe('error');
+    await publishWatchSnapshot(id, { ...profile, totalSessions: 42 });
+
+    const result = await fetchWatched(creds);
+    expect(typeof result).toBe('object');
+    expect(typeof result === 'object' && result.profile.totalSessions).toBe(42);
+  });
+
+  it('signale un partage arrêté côté enfant', async () => {
+    mockWatchServer();
+    const { link, id } = await pairedLink();
+    await addWatched(link);
+
+    await stopWatch(id);
+    expect(loadWatchCredentials(id)).toBeNull();
+    // « revoked » et non « error » : c'est définitif, le message doit différer.
+    expect(await fetchWatched(parseWatchLink(link)!)).toBe('revoked');
+  });
+
+  it('ne duplique pas un QR rescanné et suit le renommage de l’enfant', async () => {
+    mockWatchServer();
+    const { link, profile, id } = await pairedLink('Zoe');
+
+    await addWatched(link);
+    await addWatched(link);
+    expect(listWatched()).toHaveLength(1);
+
+    // L'enfant corrige son prénom sur son appareil → le libellé suit.
+    await publishWatchSnapshot(id, { ...profile, name: 'Zoé' });
+    await fetchWatched(parseWatchLink(link)!);
+    expect(listWatched()[0].name).toBe('Zoé');
+  });
+
+  it('refuse un lien étranger ou une clé invalide sans rien mémoriser', async () => {
+    mockWatchServer();
+    const { link } = await pairedLink();
+
+    expect(parseWatchLink('https://example.com/menu-du-jour')).toBeNull();
+    expect(await addWatched('bonjour')).toBeNull();
+    // Bonne ligne, mauvaise clé : le déchiffrement échoue.
+    const tampered = link.replace(/\.[A-Za-z0-9_-]+$/, '.aaaabbbbccccddddeeeeffff');
+    expect(await addWatched(tampered)).toBeNull();
+    expect(listWatched()).toHaveLength(0);
+  });
+
+  it('oublie un suivi retiré', async () => {
+    mockWatchServer();
+    const { link } = await pairedLink();
+    await addWatched(link);
+    removeWatched(parseWatchLink(link)!.code);
+    expect(listWatched()).toHaveLength(0);
+  });
+});
+
+describe('appairage au boot (importWatchFromUrl)', () => {
+  it('appaire depuis le fragment sur un appareil vierge et nettoie l’URL', async () => {
+    mockWatchServer();
+    const profile = makeProfile('Nino');
+    const link = (await startWatch(addProfile(profile), profile))!;
+
+    // Parent qui découvre Tablito en scannant le QR : rien en local.
+    localStorage.clear();
+    window.location.hash = link.slice(link.indexOf('#'));
+
+    const result = await importWatchFromUrl();
+    expect(result).not.toBe('error');
+    expect(result !== 'error' && result?.snapshot.profile.name).toBe('Nino');
+    expect(listWatched()).toHaveLength(1);
+    expect(listProfiles()).toHaveLength(0);
+    // Fragment nettoyé : un refresh ne relance pas l'appairage.
+    expect(window.location.hash).toBe('');
+  });
+
+  it('ne fait rien sans fragment #watch=', async () => {
+    const fetchSpy = vi.fn();
+    vi.stubGlobal('fetch', fetchSpy);
+    expect(await importWatchFromUrl()).toBeNull();
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it('renvoie « error » si le code est inconnu', async () => {
+    mockWatchServer();
+    window.location.hash = '#watch=abcdefgh12345678.aaaabbbbccccddddeeeeffff';
+    expect(await importWatchFromUrl()).toBe('error');
+    expect(listWatched()).toHaveLength(0);
+  });
+});
diff --git a/src/components/ParentStats.tsx b/src/components/ParentStats.tsx
new file mode 100644
index 00000000..87af2201
--- /dev/null
+++ b/src/components/ParentStats.tsx
@@ -0,0 +1,346 @@
+// Corps de statistiques de l'espace parent : tout ce qui se déduit d'un profil
+// et rien d'autre (vue d'ensemble, sélecteur d'opération, répartition Leitner,
+// grille, évolution, faits difficiles, historique).
+//
+// Extrait de ParentDashboard pour être rendu à l'identique sur un profil LOCAL
+// ou sur un profil SUIVI À DISTANCE (instantané déchiffré, cf. lib/watch) : le
+// parent doit voir exactement la même chose de son enfant que s'il tenait son
+// appareil. Ce qui dépend de l'appareil (sauvegarde, transfert, notifications,
+// suppression de profil) reste dans ParentDashboard.
+
+import { memo, useMemo, useState } from 'react';
+import type { UserProfile } from '../types';
+import { isDivisionUnlocked, isRemainderUnlocked, activeLevel } from '../lib/badges';
+import { countMastered } from '../lib/leitner';
+import { getHardestFacts } from '../lib/hardestFacts';
+import { getActiveStreak } from '../lib/streak';
+import { todayISO } from '../lib/utils';
+import ProgressGrid from './ProgressGrid';
+import DivisionProgressGrid from './DivisionProgressGrid';
+import RemainderProgressGrid from './RemainderProgressGrid';
+import EvolutionChart from './EvolutionChart';
+import { useGuideBase } from '../i18n/lang';
+import { useParentDashboardStrings } from '../i18n/parent';
+
+const HARD_FACTS_WINDOW = 10;
+const EVOLUTION_WINDOW = 20;
+
+// Mémoïsé : `profile` est une référence stable (prop d'App, ou instantané tenu en
+// state), alors que ParentDashboard se re-rend à chaque frappe dans ses zones de
+// texte (collage d'une sauvegarde, collage d'un lien de suivi) et à chaque
+// « Copié ✓ ». Sans memo, chaque frappe rediffe tout cet arbre : histogramme,
+// grille Leitner (~100 cases), deux graphes SVG, historique.
+function ParentStats({ profile }: { profile: UserProfile }) {
+  const t = useParentDashboardStrings();
+  const guideBase = useGuideBase();
+
+  const divisionUnlocked = useMemo(() => isDivisionUnlocked(profile), [profile]);
+  const remainderUnlocked = useMemo(() => isRemainderUnlocked(profile), [profile]);
+  const divisionFacts = useMemo(() => profile.divisionFacts ?? [], [profile.divisionFacts]);
+  const remainderFacts = useMemo(() => profile.remainderFacts ?? [], [profile.remainderFacts]);
+  // Onglet par défaut : le niveau actif — c'est l'activité d'apprentissage en
+  // cours (les niveaux passés sont déjà en boîte 5 par hypothèse, et surtout
+  // l'objet de l'attention du parent au quotidien).
+  const [gridView, setGridView] = useState<'mult' | 'div' | 'rem'>(() => activeLevel(profile));
+  const showRem = remainderUnlocked && gridView === 'rem';
+  const showDiv = divisionUnlocked && gridView === 'div';
+
+  // Descripteur de l'opération sélectionnée par le parent (× / ÷ / reste) —
+  // un seul point de vérité pour toutes les sections pilotées par le
+  // sélecteur (compteur de maîtrise, répartition par boîte, grille Leitner).
+  const activeView = showRem
+    ? {
+        facts: remainderFacts,
+        mastered: `${countMastered(remainderFacts)}/${remainderFacts.length}`,
+        masteredLabel: t.remaindersMastered,
+        opPlural: t.opRemaindersPlural,
+        opSingular: t.opRemainder,
+        grid: <RemainderProgressGrid facts={remainderFacts} />,
+      }
+    : showDiv
+      ? {
+          facts: divisionFacts,
+          mastered: `${countMastered(divisionFacts)}/${divisionFacts.length}`,
+          masteredLabel: t.divisionsMastered,
+          opPlural: t.opDivisionsPlural,
+          opSingular: t.opDivision,
+          grid: <DivisionProgressGrid facts={divisionFacts} />,
+        }
+      : {
+          facts: profile.facts,
+          mastered: `${countMastered(profile.facts)}/${profile.facts.length}`,
+          masteredLabel: t.multiplicationsMastered,
+          opPlural: t.opMultiplicationsPlural,
+          opSingular: t.opMultiplication,
+          grid: <ProgressGrid facts={profile.facts} />,
+        };
+
+  // Onglets du sélecteur — même pattern que « Mes images » (ProgressScreen).
+  const opTabs: Array<{ key: 'mult' | 'div' | 'rem'; label: string }> = [
+    { key: 'mult', label: t.multiplications },
+    { key: 'div', label: t.divisions },
+    ...(remainderUnlocked ? [{ key: 'rem' as const, label: t.remainders }] : []),
+  ];
+
+  // Histogramme de l'opération sélectionnée.
+  const { boxCounts, maxBoxCount } = useMemo(() => {
+    const counts = [0, 0, 0, 0, 0, 0];
+    for (const fact of activeView.facts) {
+      if (!fact.introduced) counts[0]++;
+      else counts[fact.box]++;
+    }
+    return { boxCounts: counts, maxBoxCount: Math.max(...counts, 1) };
+  }, [activeView.facts]);
+
+  // Liste UNIFIÉE × + ÷ — indépendante du sélecteur (mélange les deux opérations
+  // pour montrer où l'enfant bute en ce moment, cf. lib/hardestFacts).
+  const hardFacts = useMemo(() => getHardestFacts(profile, HARD_FACTS_WINDOW, 5), [profile]);
+
+  const recentSessions = useMemo(
+    () => [...profile.sessionHistory].reverse().slice(0, 10),
+    [profile.sessionHistory],
+  );
+
+  const evolution = useMemo(() => {
+    const sessions = profile.sessionHistory.slice(-EVOLUTION_WINDOW);
+    if (sessions.length < 2) return null;
+
+    const accuracy: Array<{ date: string; value: number }> = [];
+    const time: Array<{ date: string; value: number }> = [];
+    for (const s of sessions) {
+      const date = t.formatShortDate(new Date(s.date));
+      accuracy.push({
+        date,
+        value: Math.round((s.correctCount / s.questionsCount) * 100),
+      });
+      time.push({ date, value: s.averageTimeMs / 1000 });
+    }
+    // Au moins 4s d'amplitude pour éviter qu'une variation de 0,2s ne paraisse
+    // dramatique sur un enfant déjà rapide.
+    const timeYMax = Math.max(Math.ceil(Math.max(...time.map((t) => t.value))), 4);
+
+    return { accuracy, time, timeYMax };
+  }, [profile.sessionHistory, t]);
+
+  // Compteurs de maîtrise (× et ÷) au même format — réutilisés par la carte
+  // « Faits maîtrisés » (avant déblocage) et la carte de maîtrise (après).
+  const multMastered = `${countMastered(profile.facts)}/${profile.facts.length}`;
+
+  const boxColors = [
+    'var(--box-gray)', 'var(--box-red)', 'var(--box-orange)',
+    'var(--box-yellow)', 'var(--box-lightgreen)', 'var(--box-green)',
+  ];
+  const boxLabels = ['N/A', 'B1', 'B2', 'B3', 'B4', 'B5'];
+
+  return (
+    <>
+      {/* Stats transverses (activité / séries) — indépendantes de l'opération,
+          donc valables pour × comme pour ÷. Les compteurs de maîtrise, eux,
+          vivent plus bas sous le sélecteur (cf. carte de maîtrise). */}
+      <div className="parent-section">
+        <h3>{t.overview}</h3>
+        <div className={`parent-stats-grid${divisionUnlocked ? ' parent-stats-grid--three' : ''}`}>
+          <div className="parent-stat-card">
+            <div className="parent-stat-value">{profile.totalSessions}</div>
+            <div className="parent-stat-label">{t.sessions}</div>
+          </div>
+          <div className="parent-stat-card">
+            <div className="parent-stat-value">{getActiveStreak(profile, todayISO())}</div>
+            <div className="parent-stat-label">{t.currentStreak}</div>
+          </div>
+          <div className="parent-stat-card">
+            <div className="parent-stat-value">{profile.longestStreak}</div>
+            <div className="parent-stat-label">{t.bestStreak}</div>
+          </div>
+          {!divisionUnlocked && (
+            <div className="parent-stat-card">
+              <div className="parent-stat-value">{multMastered}</div>
+              <div className="parent-stat-label">{t.masteredFacts}</div>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Sélecteur d'opération — partagé par la carte de maîtrise, la Répartition
+          et la Grille Leitner ci-dessous. Réutilise les classes du sélecteur
+          « Mes images » côté enfant (.progress-tabs, CSS concaténé global).
+          Visible uniquement après déblocage : avant, la division ne doit pas
+          apparaître (specs §11.3). */}
+      {divisionUnlocked && (
+        <>
+          <div className="progress-tabs parent-op-tabs" role="tablist" aria-label={t.operation}>
+            {opTabs.map(({ key, label }) => (
+              <button
+                key={key}
+                type="button"
+                className={`progress-tab ${gridView === key ? 'active' : ''}`}
+                onClick={() => setGridView(key)}
+              >
+                {label}
+              </button>
+            ))}
+          </div>
+
+          {/* Compteur de maîtrise de l'opération sélectionnée — sorti de la
+              « Vue d'ensemble » pour vivre dans la section pilotée par le
+              sélecteur, au même titre que la Répartition et la Grille. */}
+          <div className="parent-section">
+            <div className="parent-stat-card parent-mastery-card">
+              <div className="parent-stat-value">{activeView.mastered}</div>
+              <div className="parent-stat-label">{activeView.masteredLabel}</div>
+            </div>
+          </div>
+        </>
+      )}
+
+      {/* Box histogram */}
+      <div className="parent-section">
+        <h3>
+          {t.boxDistribution}
+          <a
+            className="parent-section-help"
+            href={`${guideBase}#principes`}
+            target="_blank"
+            rel="noopener noreferrer"
+            aria-label={t.learnMoreLeitner}
+          >
+            ?
+          </a>
+        </h3>
+        <p className="parent-section-subtitle">
+          {t.boxDistributionSubtitle(activeView.opPlural)}
+        </p>
+        <div className="parent-histogram">
+          {boxCounts.map((count, i) => (
+            <div key={i} className="parent-histogram-bar">
+              <div className="parent-histogram-count">{count}</div>
+              <div
+                className="parent-histogram-fill"
+                style={{
+                  height: `${(count / maxBoxCount) * 100}%`,
+                  background: boxColors[i],
+                }}
+              />
+              <div className="parent-histogram-label">{boxLabels[i]}</div>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      {/* Leitner color grid (diagnostic view — complements the child's
+          mystery image in §5.1 by showing the raw box state per fact) */}
+      <div className="parent-section">
+        <h3>
+          {t.leitnerGrid}
+          <a
+            className="parent-section-help"
+            href={`${guideBase}#principes`}
+            target="_blank"
+            rel="noopener noreferrer"
+            aria-label={t.learnMoreLeitner}
+          >
+            ?
+          </a>
+        </h3>
+        <p className="parent-section-subtitle">
+          {t.leitnerGridSubtitle(activeView.opSingular)}
+        </p>
+        {activeView.grid}
+      </div>
+
+      {/* Evolution: accuracy + response time */}
+      {evolution && (
+        <>
+          <div className="parent-section">
+            <h3>{t.correctAnswerRate}</h3>
+            <EvolutionChart
+              data={evolution.accuracy}
+              yMin={0}
+              yMax={100}
+              yTicks={[0, 25, 50, 75, 100]}
+              formatY={(v) => `${v}%`}
+              color="var(--primary)"
+            />
+          </div>
+          <div className="parent-section">
+            <h3>{t.averageResponseTime}</h3>
+            <EvolutionChart
+              data={evolution.time}
+              yMin={0}
+              yMax={evolution.timeYMax}
+              yTicks={[0, evolution.timeYMax / 2, evolution.timeYMax]}
+              formatY={(v) => `${v.toFixed(1)}s`}
+              color="var(--sage)"
+            />
+          </div>
+        </>
+      )}
+
+      {/* Hardest facts */}
+      {hardFacts.length > 0 && (
+        <div className="parent-section">
+          <h3>{t.hardestFacts}</h3>
+          <p className="parent-section-subtitle">
+            {t.hardestFactsSubtitle(HARD_FACTS_WINDOW)}
+          </p>
+          <div className="parent-hard-facts">
+            {hardFacts.map((f) => (
+              <div key={`${f.kind}-${f.key}`} className="parent-hard-fact">
+                <span
+                  className={`parent-hard-fact-kind parent-hard-fact-kind--${f.kind}`}
+                  aria-label={
+                    f.kind === 'rem'
+                      ? t.factRemainder
+                      : f.kind === 'div'
+                        ? t.factDivision
+                        : t.factMultiplication
+                  }
+                >
+                  {f.kind === 'rem' ? t.remSymbol : f.kind === 'div' ? t.divSymbol : t.multSymbol}
+                </span>
+                <span className="parent-hard-fact-name">
+                  {f.kind === 'rem'
+                    ? t.formatRemFact(
+                        f.divisor * f.quotient,
+                        f.divisor * f.quotient + f.divisor - 1,
+                        f.divisor,
+                      )
+                    : f.kind === 'div'
+                      ? t.formatDivFact(f.dividend, f.divisor, f.quotient)
+                      : t.formatMultFact(f.a, f.b, f.product)}
+                </span>
+                <span className="parent-hard-fact-errors">
+                  {t.errors(f.errorCount)} | {t.boxLabel(f.box)}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {/* Session history */}
+      {profile.sessionHistory.length > 0 && (
+        <div className="parent-section">
+          <h3>{t.sessionHistory}</h3>
+          <div className="parent-session-history">
+            {recentSessions.map((session) => {
+              const dateStr = t.formatLongDate(new Date(session.date));
+              const avgSec = (session.averageTimeMs / 1000).toFixed(1);
+              return (
+                <div key={session.date} className="parent-session-row">
+                  <span className="parent-session-date">{dateStr}</span>
+                  <span className="parent-session-score">
+                    {session.correctCount}/{session.questionsCount}
+                  </span>
+                  <span className="parent-session-time">{avgSec}s</span>
+                </div>
+              );
+            })}
+          </div>
+        </div>
+      )}
+    </>
+  );
+}
+
+export default memo(ParentStats);
diff --git a/src/components/QrCanvas.tsx b/src/components/QrCanvas.tsx
new file mode 100644
index 00000000..65abe751
--- /dev/null
+++ b/src/components/QrCanvas.tsx
@@ -0,0 +1,36 @@
+// QR code rendu sur un <canvas>. lean-qr est chargé à la demande : inutile
+// d'alourdir le chunk de l'espace parent pour des actions rares (transfert vers
+// un autre appareil, partage d'un suivi à distance).
+
+import { useEffect, useRef } from 'react';
+
+interface QrCanvasProps {
+  value: string;
+  ariaLabel: string;
+  className?: string;
+  // Signalé si lean-qr est introuvable (hors-ligne au premier usage) : l'appelant
+  // propose alors la copie du lien, qui ne dépend d'aucune lib.
+  onError?: () => void;
+}
+
+export default function QrCanvas({ value, ariaLabel, className, onError }: QrCanvasProps) {
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+
+  useEffect(() => {
+    let cancelled = false;
+    import('lean-qr')
+      .then(({ generate }) => {
+        if (!cancelled && canvasRef.current) generate(value).toCanvas(canvasRef.current);
+      })
+      .catch(() => {
+        if (!cancelled) onErrorRef.current?.();
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [value]);
+
+  return <canvas ref={canvasRef} className={className} role="img" aria-label={ariaLabel} />;
+}
diff --git a/src/hooks/useQrScan.ts b/src/hooks/useQrScan.ts
new file mode 100644
index 00000000..03407df8
--- /dev/null
+++ b/src/hooks/useQrScan.ts
@@ -0,0 +1,73 @@
+// Caméra + détection de QR code, partagée par les deux appairages de l'app :
+// le transfert de profil (WelcomeScreen) et le suivi à distance (espace
+// parent). qr-scanner est vendoré et chargé à la demande — un boot ordinaire ne
+// paie pas la lib.
+//
+// `onCode` décide du sort de chaque détection : renvoyer false ignore le QR
+// (l'utilisateur vise peut-être encore à côté) et la caméra continue de filmer ;
+// renvoyer true l'accepte et arrête la caméra. Le callback peut être asynchrone
+// (récupération réseau + déchiffrement) : les détections qui tombent pendant ce
+// traitement sont ignorées, qr-scanner se déclenchant plusieurs fois par seconde
+// sur un même QR.
+
+import { useEffect, useRef } from 'react';
+import type QrScanner from 'qr-scanner';
+
+interface UseQrScanOptions {
+  // Filme tant que vrai. Repasser à faux libère la caméra.
+  active: boolean;
+  onCode: (data: string) => boolean | Promise<boolean>;
+  // Caméra absente, refusée, ou lib introuvable — à l'appelant de proposer son
+  // repli (collage manuel du lien).
+  onCameraError: () => void;
+}
+
+export function useQrScan({ active, onCode, onCameraError }: UseQrScanOptions) {
+  const videoRef = useRef<HTMLVideoElement>(null);
+  // Callbacks via refs : sans ça, une closure recréée à chaque render du parent
+  // relancerait la caméra en boucle.
+  const onCodeRef = useRef(onCode);
+  const onCameraErrorRef = useRef(onCameraError);
+  onCodeRef.current = onCode;
+  onCameraErrorRef.current = onCameraError;
+
+  useEffect(() => {
+    if (!active) return;
+    let scanner: QrScanner | null = null;
+    let cancelled = false;
+    let busy = false;
+    (async () => {
+      try {
+        const { default: QrScanner } = await import('qr-scanner');
+        if (cancelled || !videoRef.current) return;
+        const qr = new QrScanner(
+          videoRef.current,
+          async ({ data }) => {
+            if (busy) return;
+            busy = true;
+            try {
+              if (await onCodeRef.current(data)) qr.stop();
+            } finally {
+              busy = false;
+            }
+          },
+          { returnDetailedScanResult: true },
+        );
+        scanner = qr;
+        await qr.start();
+        // Si le cleanup est passé pendant le start(), son destroy() a tourné
+        // avant que getUserMedia ne rende la piste : on relibère, sinon la LED
+        // caméra reste allumée après la fermeture du panneau.
+        if (cancelled) qr.destroy();
+      } catch {
+        if (!cancelled) onCameraErrorRef.current();
+      }
+    })();
+    return () => {
+      cancelled = true;
+      scanner?.destroy(); // destroy() arrête aussi la caméra
+    };
+  }, [active]);
+
+  return videoRef;
+}
diff --git a/src/i18n/changelog.ts b/src/i18n/changelog.ts
index 1c2d8d16..c6dea2f3 100644
--- a/src/i18n/changelog.ts
+++ b/src/i18n/changelog.ts
@@ -8,6 +8,12 @@ import type { ChangelogEntry } from '../lib/changelog';
 // parent (anglais adulte clair). Consommé par lib/changelog.ts via getLang().
 
 const fr: ChangelogEntry[] = [
+  {
+    date: '2026-07-25',
+    items: [
+      "Suivi à distance : votre enfant pratique sur un autre appareil (une tablette, un ancien téléphone) et vous n'aviez aucune visibilité sur sa progression. Depuis son espace parent, « Partager la progression » affiche un QR code ; scannez-le avec votre téléphone et son tableau de bord apparaît chez vous, mis à jour après chaque séance. Vous n'avez pas besoin d'avoir Tablito : le QR l'installe et ouvre directement l'espace parent. Si vous avez aussi un profil sur votre appareil, un sélecteur en haut de l'espace parent bascule entre le vôtre et celui de votre enfant. Aucune adresse e-mail, aucun compte : tout est chiffré, et « Ne plus partager » coupe le suivi immédiatement.",
+    ],
+  },
   {
     date: '2026-07-23',
     items: [
@@ -171,6 +177,12 @@ const fr: ChangelogEntry[] = [
 ];
 
 const en: ChangelogEntry[] = [
+  {
+    date: '2026-07-25',
+    items: [
+      "Remote follow: your child practises on another device (a tablet, an old phone) and you had no visibility on their progress. From their parent area, \"Share progress\" shows a QR code; scan it with your phone and their dashboard appears on yours, refreshed after every session. You don't need to have Tablito already: the QR installs it and opens straight into the parent area. If you also have a profile on your device, a switcher at the top of the parent area flips between yours and your child's. No email address, no account: everything is encrypted, and \"Stop sharing\" cuts the follow immediately.",
+    ],
+  },
   {
     date: '2026-07-23',
     items: [
diff --git a/src/i18n/lang.ts b/src/i18n/lang.ts
index 900e505a..c26575bd 100644
--- a/src/i18n/lang.ts
+++ b/src/i18n/lang.ts
@@ -103,6 +103,16 @@ export function useLang(): LangContextValue {
 }
 
 /** Locale BCP-47 de la langue courante du contexte (pour les composants React). */
+/**
+ * Base du guide utilisateur pour la langue courante : FR à `/guide/`, autres
+ * langues sous `/guide/<lang>/` (cf. scripts/generate-user-guide.mjs). Partagé
+ * par tous les liens d'aide — la convention de chemin ne doit vivre qu'ici.
+ */
+export function useGuideBase(): string {
+  const { lang } = useLang();
+  return `${import.meta.env.BASE_URL}guide/${lang === 'fr' ? '' : `${lang}/`}`;
+}
+
 export function useLocale(): string {
   return LOCALE[useContext(LangContext).lang];
 }
diff --git a/src/i18n/onboarding.ts b/src/i18n/onboarding.ts
index b0bce2f9..23001635 100644
--- a/src/i18n/onboarding.ts
+++ b/src/i18n/onboarding.ts
@@ -16,6 +16,14 @@ export const transferFetchingStrings = {
   en: 'Fetching your progress…',
 };
 
+// Même écran d'attente pré-montage, pour un appairage de suivi à distance
+// (#watch=) : c'est la progression de l'ENFANT qu'on récupère, sur l'appareil du
+// parent — d'où une formulation distincte de celle du transfert.
+export const watchFetchingStrings = {
+  fr: 'Récupération de la progression de votre enfant…',
+  en: "Fetching your child's progress…",
+};
+
 interface WelcomeStrings {
   dontKnow: string;
   testHint: string;
diff --git a/src/i18n/parent.ts b/src/i18n/parent.ts
index 40bdc9a5..cf7a5b4d 100644
--- a/src/i18n/parent.ts
+++ b/src/i18n/parent.ts
@@ -1,10 +1,22 @@
-import { localeFor, useStrings } from './lang';
+import { localeFor, useStrings, type Lang } from './lang';
 
 // Strings de l'espace parent : ParentDashboard, ParentGate, NotificationSettings
 // et FeedbackModal. Même pattern que voice.ts — un dico `fr` source, un `en`
 // contraint à la même forme via une interface explicite (pour typer les
 // fonctions d'interpolation), et un hook `useXStrings()` par composant.
 
+// Fraîcheur du dernier instantané d'un suivi à distance, en relatif (« il y a
+// 2 heures »). Renvoie null sous la minute : l'appelant affiche alors son propre
+// « à l'instant », Intl.RelativeTimeFormat ne sachant pas le dire joliment.
+function timeAgo(iso: string, lang: Lang): string | null {
+  const minutes = Math.round((Date.now() - new Date(iso).getTime()) / 60000);
+  if (minutes < 1) return null;
+  const rtf = new Intl.RelativeTimeFormat(localeFor(lang), { numeric: 'always' });
+  if (minutes < 60) return rtf.format(-minutes, 'minute');
+  const hours = Math.round(minutes / 60);
+  return hours < 24 ? rtf.format(-hours, 'hour') : rtf.format(-Math.round(hours / 24), 'day');
+}
+
 // === ParentDashboard ===
 
 interface ParentDashboardStrings {
@@ -53,6 +65,34 @@ interface ParentDashboardStrings {
   transferHint: (minutes: number) => string;
   transferCopyLink: string;
   transferQrAlt: string;
+  // Sélecteur de source (profil local / profils suivis à distance)
+  sourceLabel: string;
+  remoteSourceTab: (name: string) => string;
+  remoteLoading: string;
+  remoteError: string;
+  remoteRevoked: (name: string) => string;
+  remoteSyncedAgo: (iso: string) => string;
+  remoteRefresh: string;
+  remoteNoData: string;
+  // Suivi à distance : partager la progression d'ici, suivre celle d'ailleurs
+  watchTitle: string;
+  watchSubtitle: string;
+  watchShare: (name: string) => string;
+  watchShowQr: (name: string) => string;
+  watchStopSharing: string;
+  watchPreparing: string;
+  watchShareError: string;
+  watchShareHint: string;
+  watchQrAlt: string;
+  watchScanQr: string;
+  watchScanPrompt: string;
+  watchCameraError: string;
+  watchLinkError: string;
+  watchPasteLink: string;
+  watchPastePlaceholder: string;
+  watchPasteConfirm: string;
+  watchStopFollowing: string;
+  cancel: string;
   helpAndFeedback: string;
   userGuide: string;
   sendFeedback: string;
@@ -65,7 +105,9 @@ interface ParentDashboardStrings {
   privacy: string;
   profiles: string;
   profilesSubtitle: (name: string) => string;
+  profilesSubtitleWatcher: string;
   addChild: string;
+  createLocalProfile: string;
   deleteThisProfile: string;
   pasteJsonHere: string;
   confirmImport: string;
@@ -133,6 +175,41 @@ const parentDashboardFr: ParentDashboardStrings = {
     `Scannez ce QR code avec l'appareil photo du nouvel appareil : Tablito s'y ouvrira avec la progression. Valable ${minutes} minutes, une seule fois.`,
   transferCopyLink: 'Ou copier le lien',
   transferQrAlt: 'QR code de transfert vers un autre appareil',
+  sourceLabel: 'Profil affiché',
+  remoteSourceTab: (name) => `${name}\u00a0· à distance`,
+  remoteLoading: 'Récupération de la progression…',
+  remoteError:
+    'Impossible de récupérer la progression pour le moment. Vérifiez la connexion internet, ou réessayez plus tard.',
+  remoteRevoked: (name) =>
+    `Le partage a été arrêté sur l'appareil de ${name}. Pour reprendre le suivi, scannez un nouveau QR code depuis son espace parent.`,
+  remoteSyncedAgo: (iso) => {
+    const ago = timeAgo(iso, 'fr');
+    return ago ? `Synchronisé ${ago}` : "Synchronisé à l'instant";
+  },
+  remoteRefresh: 'Actualiser',
+  remoteNoData: 'Aucune progression à afficher pour le moment.',
+  watchTitle: 'Suivi à distance',
+  watchSubtitle:
+    "Votre enfant pratique sur un autre appareil\u00a0? Suivez sa progression depuis celui-ci, sans y installer son profil. Chaque séance met le suivi à jour, et rien n'est lisible en dehors de vos appareils.",
+  watchShare: (name) => `Partager la progression de ${name}`,
+  watchShowQr: (name) => `Revoir le QR code de ${name}`,
+  watchStopSharing: 'Ne plus partager',
+  watchPreparing: 'Préparation du partage…',
+  watchShareError:
+    'Partage impossible pour le moment. Vérifiez la connexion internet, puis réessayez.',
+  watchShareHint:
+    "Scannez ce QR code depuis l'appareil du parent\u00a0: la progression y apparaîtra, et se mettra à jour après chaque séance. Le partage reste ouvert jusqu'à ce que vous l'arrêtiez.",
+  watchQrAlt: 'QR code de suivi à distance',
+  watchScanQr: 'Suivre un enfant à distance',
+  watchScanPrompt: "Visez le QR code affiché sur l'appareil de l'enfant.",
+  watchCameraError: 'Caméra indisponible. Vous pouvez coller le lien de suivi à la place.',
+  watchLinkError:
+    "Ce lien de suivi n'est pas lisible. Il a peut-être été arrêté\u00a0: affichez un nouveau QR code depuis l'appareil de l'enfant.",
+  watchPasteLink: 'Coller un lien',
+  watchPastePlaceholder: 'https://tablito.app/#watch=…',
+  watchPasteConfirm: 'Suivre',
+  watchStopFollowing: 'Ne plus suivre',
+  cancel: 'Annuler',
   helpAndFeedback: 'Aide & retours',
   userGuide: 'Guide utilisateur',
   sendFeedback: 'Envoyer un avis',
@@ -146,7 +223,10 @@ const parentDashboardFr: ParentDashboardStrings = {
   profiles: 'Profils',
   profilesSubtitle: (name) =>
     `Plusieurs enfants sur le même appareil\u00a0? Chacun a son profil\u00a0: progression, badges et images séparés. La suppression efface le profil de ${name} de cet appareil — pour recommencer à zéro, supprimez puis recréez le profil.`,
+  profilesSubtitleWatcher:
+    "Cet appareil ne sert qu'à suivre la progression d'un enfant qui pratique ailleurs. Vous pouvez aussi créer un profil ici, par exemple pour vous entraîner vous-même\u00a0: les deux coexistent, et vous basculez de l'un à l'autre en haut de cette page.",
   addChild: 'Ajouter un enfant',
+  createLocalProfile: 'Créer un profil sur cet appareil',
   deleteThisProfile: 'Supprimer ce profil',
   pasteJsonHere: 'Collez le JSON ici...',
   confirmImport: "Confirmer l'import",
@@ -216,6 +296,40 @@ const parentDashboardEn: ParentDashboardStrings = {
     `Scan this QR code with the new device's camera: Tablito will open there with the progress. Valid for ${minutes} minutes, one use only.`,
   transferCopyLink: 'Or copy the link',
   transferQrAlt: 'QR code to transfer to another device',
+  sourceLabel: 'Profile shown',
+  remoteSourceTab: (name) => `${name}\u00a0· remote`,
+  remoteLoading: 'Fetching progress…',
+  remoteError:
+    'Cannot fetch the progress right now. Check the internet connection, or try again later.',
+  remoteRevoked: (name) =>
+    `Sharing was turned off on ${name}'s device. To resume, scan a new QR code from their parent area.`,
+  remoteSyncedAgo: (iso) => {
+    const ago = timeAgo(iso, 'en');
+    return ago ? `Synced ${ago}` : 'Synced just now';
+  },
+  remoteRefresh: 'Refresh',
+  remoteNoData: 'No progress to show yet.',
+  watchTitle: 'Remote follow',
+  watchSubtitle:
+    'Is your child practising on another device? Follow their progress from this one, without installing their profile here. Every session updates it, and nothing is readable outside your devices.',
+  watchShare: (name) => `Share ${name}'s progress`,
+  watchShowQr: (name) => `Show ${name}'s QR code again`,
+  watchStopSharing: 'Stop sharing',
+  watchPreparing: 'Setting up sharing…',
+  watchShareError: 'Cannot set up sharing right now. Check the internet connection, then try again.',
+  watchShareHint:
+    "Scan this QR code from the parent's device: the progress will show up there, and refresh after every session. Sharing stays on until you stop it.",
+  watchQrAlt: 'Remote follow QR code',
+  watchScanQr: 'Follow a child remotely',
+  watchScanPrompt: "Point at the QR code shown on the child's device.",
+  watchCameraError: 'Camera unavailable. You can paste the follow link instead.',
+  watchLinkError:
+    "This follow link cannot be read. It may have been turned off: show a new QR code from the child's device.",
+  watchPasteLink: 'Paste a link',
+  watchPastePlaceholder: 'https://tablito.app/#watch=…',
+  watchPasteConfirm: 'Follow',
+  watchStopFollowing: 'Stop following',
+  cancel: 'Cancel',
   helpAndFeedback: 'Help & feedback',
   userGuide: 'User guide',
   sendFeedback: 'Send feedback',
@@ -229,7 +343,10 @@ const parentDashboardEn: ParentDashboardStrings = {
   profiles: 'Profiles',
   profilesSubtitle: (name) =>
     `Several children on the same device?\u00a0Each has their own profile: progress, badges and pictures kept separate. Deleting removes ${name}'s profile from this device — to start over, delete then recreate the profile.`,
+  profilesSubtitleWatcher:
+    'This device only follows the progress of a child practising elsewhere. You can also create a profile here — to practise yourself, for instance: the two coexist, and you switch between them at the top of this page.',
   addChild: 'Add a child',
+  createLocalProfile: 'Create a profile on this device',
   deleteThisProfile: 'Delete this profile',
   pasteJsonHere: 'Paste the JSON here...',
   confirmImport: 'Confirm import',
diff --git a/src/i18n/privacy.tsx b/src/i18n/privacy.tsx
index 34d788b7..96b64e42 100644
--- a/src/i18n/privacy.tsx
+++ b/src/i18n/privacy.tsx
@@ -24,6 +24,8 @@ interface PrivacyStrings {
   reminderOutro: ReactNode;
   transferTitle: string;
   transferBody: ReactNode;
+  watchTitle: string;
+  watchBody: ReactNode;
   notCollectedTitle: string;
   notCollectedItems: ReactNode[];
   rightsTitle: string;
@@ -53,8 +55,8 @@ const fr: PrivacyStrings = {
       L'application fonctionne entièrement hors-ligne après le premier
       chargement. Par défaut, rien n'est envoyé sur un serveur : les seules
       exceptions sont déclenchées par vous et décrites ci-dessous (l'envoi
-      d'un avis, l'activation du rappel quotidien, et le transfert vers un
-      autre appareil).
+      d'un avis, l'activation du rappel quotidien, le transfert vers un
+      autre appareil, et le suivi à distance).
     </>
   ),
   feedbackTitle: "Ce qui est envoyé en cas d'avis",
@@ -122,6 +124,26 @@ const fr: PrivacyStrings = {
       automatiquement au bout de 15&nbsp;minutes, récupéré ou non.
     </>
   ),
+  watchTitle: 'Ce qui est envoyé si vous activez le suivi à distance',
+  watchBody: (
+    <>
+      Le suivi à distance (espace parent, section «&nbsp;Suivi à
+      distance&nbsp;») permet de consulter la progression d'un enfant qui
+      pratique sur un autre appareil. Il repose sur le même chiffrement que le
+      transfert&nbsp;: après chaque séance, l'appareil de l'enfant dépose un
+      instantané de son profil <strong>chiffré sur l'appareil</strong> avant
+      l'envoi, et la clé de déchiffrement ne vit que dans le QR code / le lien
+      partagé — jamais transmise au serveur, qui ne peut donc pas lire le
+      contenu. La différence avec un transfert est la{' '}
+      <strong>durée</strong>&nbsp;: là où un transfert s'efface au bout de
+      15&nbsp;minutes, un suivi reste déposé et relisible tant qu'il est actif,
+      pour que la progression affichée sur l'appareil du parent reste à jour. Le
+      bouton «&nbsp;Ne plus partager&nbsp;» supprime immédiatement le dépôt, et un
+      suivi qu'aucune séance n'a rafraîchi depuis 6&nbsp;mois est purgé
+      automatiquement. Aucune adresse e-mail n'est demandée, et aucun compte n'est
+      créé.
+    </>
+  ),
   notCollectedTitle: "Ce qui n'est pas collecté",
   notCollectedItems: [
     <>Aucun cookie de suivi, aucun analytics tiers.</>,
@@ -150,7 +172,7 @@ const fr: PrivacyStrings = {
       formulaire <strong>«&nbsp;Envoyer un avis&nbsp;»</strong> du dashboard parent.
     </>
   ),
-  updated: 'Dernière mise à jour : mai 2026.',
+  updated: 'Dernière mise à jour : juillet 2026.',
 };
 
 const en: PrivacyStrings = {
@@ -170,8 +192,8 @@ const en: PrivacyStrings = {
       locally in the browser (<code>localStorage</code>). The app works
       entirely offline after the first load. By default, nothing is sent to
       a server: the only exceptions are triggered by you and described below
-      (sending feedback, turning on the daily reminder, and transferring to
-      another device).
+      (sending feedback, turning on the daily reminder, transferring to
+      another device, and remote follow).
     </>
   ),
   feedbackTitle: 'What is sent when you send feedback',
@@ -238,6 +260,23 @@ const en: PrivacyStrings = {
       15&nbsp;minutes, picked up or not.
     </>
   ),
+  watchTitle: 'What is sent if you turn on remote follow',
+  watchBody: (
+    <>
+      Remote follow (parent area, "Remote follow" section) lets you check the
+      progress of a child practising on another device. It uses the same
+      encryption as a transfer: after every session, the child's device uploads a
+      snapshot of their profile <strong>encrypted on the device</strong> before
+      sending, and the decryption key only lives in the shared QR code / link —
+      never sent to the server, which therefore cannot read the content. The
+      difference with a transfer is <strong>duration</strong>: where a transfer
+      deletes itself after 15&nbsp;minutes, a follow stays uploaded and readable
+      as long as it is active, so that the progress shown on the parent's device
+      stays up to date. The "Stop sharing" button deletes the upload immediately,
+      and a follow that no session has refreshed for 6&nbsp;months is purged
+      automatically. No email address is asked for, and no account is created.
+    </>
+  ),
   notCollectedTitle: 'What is not collected',
   notCollectedItems: [
     <>No tracking cookies, no third-party analytics.</>,
@@ -266,7 +305,7 @@ const en: PrivacyStrings = {
       <strong>"Send feedback"</strong> form in the parent dashboard.
     </>
   ),
-  updated: 'Last updated: May 2026.',
+  updated: 'Last updated: July 2026.',
 };
 
 export const privacyStrings = { fr, en };
diff --git a/src/lib/supabase.ts b/src/lib/supabase.ts
index 69c582a2..2c948be6 100644
--- a/src/lib/supabase.ts
+++ b/src/lib/supabase.ts
@@ -21,3 +21,23 @@ export function supabaseHeaders(key: string): Record<string, string> {
     'Content-Type': 'application/json',
   };
 }
+
+/**
+ * Appelle une fonction SECURITY DEFINER (`POST /rest/v1/rpc/<name>`). Renvoie
+ * null si la config est absente ou si l'appel n'a pas abouti du tout
+ * (hors-ligne, service injoignable) — à l'appelant de distinguer ce cas d'une
+ * réponse non-ok, qui remonte telle quelle.
+ */
+export async function supabaseRpc(name: string, body: unknown): Promise<Response | null> {
+  const env = supabaseEnv();
+  if (!env) return null;
+  try {
+    return await fetch(`${env.url}/rest/v1/rpc/${name}`, {
+      method: 'POST',
+      headers: supabaseHeaders(env.key),
+      body: JSON.stringify(body),
+    });
+  } catch {
+    return null;
+  }
+}
diff --git a/src/lib/transfer.ts b/src/lib/transfer.ts
index 2e2c1025..00d0b564 100644
--- a/src/lib/transfer.ts
+++ b/src/lib/transfer.ts
@@ -14,7 +14,7 @@
 import type { UserProfile } from '../types';
 import { clearUrlHash, importProfile, installProfile } from './storage';
 import { bytesToBase64url, gunzip, gzip, urlBase64ToUint8Array } from './codec';
-import { supabaseEnv, supabaseHeaders } from './supabase';
+import { supabaseEnv, supabaseRpc } from './supabase';
 
 /** Durée de validité d'un transfert côté serveur — garder en phase avec
  *  l'interval de read_transfer dans supabase/transfers.sql. */
@@ -25,16 +25,32 @@ export function transferConfigured(): boolean {
 }
 
 const IV_LENGTH = 12; // taille standard du nonce AES-GCM
+const KEY_LENGTH = 32; // AES-256
 
-/** Profil → blob opaque (gzip puis AES-GCM) + clé base64url. Exporté pour les
- *  tests ; le flux nominal passe par createTransfer / importTransferFromUrl. */
-export async function packProfile(
+/** Code haute entropie servant de clé de ligne côté serveur : 12 octets
+ *  aléatoires → 16 chars base64url (96 bits), inénumérable, et au-dessus du
+ *  minimum imposé par les RPC SQL. Partagé avec le suivi à distance
+ *  (lib/watch), qui a la même contrainte de non-devinabilité. */
+export function randomCode(): string {
+  return bytesToBase64url(crypto.getRandomValues(new Uint8Array(12)));
+}
+
+/** Profil → blob opaque (gzip puis AES-GCM) sous une clé DONNÉE. Séparé de
+ *  packProfile pour le suivi à distance (lib/watch), qui redépose des
+ *  instantanés successifs sous la clé stable déjà scannée par le parent — là où
+ *  un transfert en tire une neuve à chaque dépôt. */
+export async function packProfileWithKey(
   profile: UserProfile,
-): Promise<{ payload: string; keyB64: string }> {
+  keyB64: string,
+): Promise<string> {
   const plain = await gzip(new TextEncoder().encode(JSON.stringify(profile)));
-  const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, [
-    'encrypt',
-  ]);
+  const key = await crypto.subtle.importKey(
+    'raw',
+    urlBase64ToUint8Array(keyB64),
+    'AES-GCM',
+    false,
+    ['encrypt'],
+  );
   const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
   const cipher = new Uint8Array(
     await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, plain),
@@ -42,8 +58,22 @@ export async function packProfile(
   const blob = new Uint8Array(IV_LENGTH + cipher.length);
   blob.set(iv);
   blob.set(cipher, IV_LENGTH);
-  const raw = new Uint8Array(await crypto.subtle.exportKey('raw', key));
-  return { payload: bytesToBase64url(blob), keyB64: bytesToBase64url(raw) };
+  return bytesToBase64url(blob);
+}
+
+/** Clé AES-256 aléatoire, base64url. Partagée avec le suivi à distance, qui a
+ *  besoin d'en tirer une hors de tout dépôt (elle survit aux instantanés). */
+export function randomKeyB64(): string {
+  return bytesToBase64url(crypto.getRandomValues(new Uint8Array(KEY_LENGTH)));
+}
+
+/** Profil → blob opaque + clé base64url fraîche. Exporté pour les tests ; le
+ *  flux nominal passe par createTransfer / importTransferFromUrl. */
+export async function packProfile(
+  profile: UserProfile,
+): Promise<{ payload: string; keyB64: string }> {
+  const keyB64 = randomKeyB64();
+  return { payload: await packProfileWithKey(profile, keyB64), keyB64 };
 }
 
 /** Blob opaque + clé → profil validé/migré, ou null si déchiffrement ou
@@ -77,19 +107,11 @@ export async function unpackProfile(payload: string, keyB64: string): Promise<Us
  * dépôt échoue (hors-ligne, service indisponible…).
  */
 export async function createTransfer(profile: UserProfile): Promise<string | null> {
-  const env = supabaseEnv();
-  if (!env) return null;
   try {
     const { payload, keyB64 } = await packProfile(profile);
-    // 12 octets aléatoires → 16 chars base64url (96 bits) : inénumérable, et
-    // au-dessus du minimum imposé par create_transfer côté SQL.
-    const code = bytesToBase64url(crypto.getRandomValues(new Uint8Array(12)));
-    const res = await fetch(`${env.url}/rest/v1/rpc/create_transfer`, {
-      method: 'POST',
-      headers: supabaseHeaders(env.key),
-      body: JSON.stringify({ p_code: code, p_payload: payload }),
-    });
-    if (!res.ok) return null;
+    const code = randomCode();
+    const res = await supabaseRpc('create_transfer', { p_code: code, p_payload: payload });
+    if (!res?.ok) return null;
     return `${window.location.origin}${import.meta.env.BASE_URL}#transfer=${code}.${keyB64}`;
   } catch {
     return null;
@@ -112,15 +134,9 @@ export function parseTransferLink(text: string): { code: string; key: string } |
 // profil, qui devient actif (dédup re-transfert : cf. storage.installProfile).
 // Null si échec : code expiré/consommé, déchiffrement impossible, hors-ligne.
 async function consumeTransfer(code: string, key: string): Promise<UserProfile | null> {
-  const env = supabaseEnv();
-  if (!env) return null;
   try {
-    const res = await fetch(`${env.url}/rest/v1/rpc/read_transfer`, {
-      method: 'POST',
-      headers: supabaseHeaders(env.key),
-      body: JSON.stringify({ p_code: code }),
-    });
-    if (!res.ok) return null;
+    const res = await supabaseRpc('read_transfer', { p_code: code });
+    if (!res?.ok) return null;
     const payload = (await res.json()) as string | null;
     if (!payload) return null; // code inconnu, expiré ou déjà consommé
     const profile = await unpackProfile(payload, key);
diff --git a/src/lib/watch.ts b/src/lib/watch.ts
new file mode 100644
index 00000000..97d24d52
--- /dev/null
+++ b/src/lib/watch.ts
@@ -0,0 +1,189 @@
+// Suivi à distance d'un profil : un parent consulte la progression de son
+// enfant depuis SON appareil, alors que l'enfant pratique sur un autre.
+//
+// Deux rôles, non exclusifs sur un même appareil :
+//  - PUBLIEUR (appareil de l'enfant) : après chaque séance, dépose un
+//    instantané du profil — gzippé puis chiffré CÔTÉ CLIENT (AES-GCM) — dans la
+//    table Supabase `watches`, sous un code haute entropie.
+//  - SUIVEUR (appareil du parent) : détient code + clé, scannés une fois à
+//    l'appairage, relit le blob et le déchiffre localement.
+//
+// Le profil suivi n'est JAMAIS installé sur l'appareil du parent : il ne vit
+// qu'en mémoire, le temps de l'afficher. C'est délibéré — installé, il se
+// mêlerait aux profils locaux (« Qui joue ? »), et une séance faite par erreur
+// dessus divergerait de l'appareil de l'enfant, que le dépôt suivant écraserait.
+//
+// Même primitive que lib/transfer : la clé voyage dans le fragment d'URL
+//
+//   https://tablito.app/#watch=<code>.<clé>
+//
+// jamais envoyé au serveur (spéc. HTTP), qui ne voit donc passer qu'un blob
+// opaque. Deux différences avec un transfert : le dépôt est DURABLE (rafraîchi
+// à chaque séance au lieu d'être consommé à la lecture) et relisible autant de
+// fois que nécessaire. Le code est donc une capacité permanente, d'où
+// stopWatch() côté enfant — cf. l'en-tête de supabase/watches.sql.
+//
+// Ce module porte le réseau et le chiffrement ; les types et les accès
+// localStorage vivent dans lib/watchStore (chargé en eager par App, là où ce
+// module-ci ne doit l'être que sur demande).
+
+import type { UserProfile } from '../types';
+import { clearUrlHash } from './storage';
+import { packProfileWithKey, randomCode, randomKeyB64, unpackProfile } from './transfer';
+import { supabaseRpc } from './supabase';
+import {
+  clearWatchCredentials,
+  listWatched,
+  loadWatchCredentials,
+  saveWatchCredentials,
+  saveWatched,
+  parseWatchLink,
+  watchLink,
+  type WatchCredentials,
+  type WatchedProfile,
+} from './watchStore';
+
+// === Côté publieur (appareil de l'enfant) ===
+
+async function publish(creds: WatchCredentials, profile: UserProfile): Promise<boolean> {
+  try {
+    const payload = await packProfileWithKey(profile, creds.key);
+    const res = await supabaseRpc('publish_watch', { p_code: creds.code, p_payload: payload });
+    return res?.ok ?? false;
+  } catch {
+    return false; // chiffrement indisponible (contexte non sécurisé)
+  }
+}
+
+/**
+ * Ouvre le partage de ce profil : tire un code + une clé, dépose un premier
+ * instantané, et mémorise les identifiants pour les dépôts suivants. Renvoie le
+ * lien d'appairage (à afficher en QR), ou null si le dépôt a échoué — dans ce
+ * cas rien n'est mémorisé, pour ne pas laisser un partage à moitié ouvert.
+ */
+export async function startWatch(
+  profileId: string,
+  profile: UserProfile,
+): Promise<string | null> {
+  const existing = loadWatchCredentials(profileId);
+  // Déjà partagé : on ne tire pas un code neuf, sinon les appareils déjà
+  // appairés cesseraient silencieusement de voir les mises à jour.
+  const creds = existing ?? { code: randomCode(), key: randomKeyB64() };
+  if (!(await publish(creds, profile))) return null;
+  if (!existing) saveWatchCredentials(profileId, creds);
+  return watchLink(creds);
+}
+
+/**
+ * Rafraîchit l'instantané publié de ce profil. No-op si le profil n'est pas
+ * partagé. Best-effort et jamais bloquant : appelé en fin de séance, un échec
+ * (hors-ligne) sera rattrapé par la séance suivante.
+ */
+export async function publishWatchSnapshot(
+  profileId: string,
+  profile: UserProfile,
+): Promise<void> {
+  const creds = loadWatchCredentials(profileId);
+  if (creds) await publish(creds, profile);
+}
+
+/**
+ * Ferme le partage : supprime la ligne serveur et oublie les identifiants.
+ * Appelé par « Ne plus partager », et à la suppression d'un profil — sinon un
+ * dépôt relisible survivrait à l'enfant dont il porte la progression.
+ */
+export async function stopWatch(profileId: string): Promise<void> {
+  const creds = loadWatchCredentials(profileId);
+  clearWatchCredentials(profileId);
+  if (creds) await supabaseRpc('revoke_watch', { p_code: creds.code });
+}
+
+// === Côté suiveur (appareil du parent) ===
+
+/** Instantané distant déchiffré, avec la date de son dépôt. */
+export interface WatchSnapshot {
+  profile: UserProfile;
+  updatedAt: string;
+}
+
+// Issue d'une relecture. « revoked » (le partage a été arrêté côté enfant, la
+// ligne n'existe plus) est distingué de « error » : c'est définitif, donc le
+// message affiché diffère.
+export type WatchFetchResult = WatchSnapshot | 'revoked' | 'error';
+
+/** Relit et déchiffre l'instantané d'un profil suivi. */
+export async function fetchWatched(creds: WatchCredentials): Promise<WatchFetchResult> {
+  const res = await supabaseRpc('read_watch', { p_code: creds.code });
+  if (!res?.ok) return 'error';
+  let row: { payload?: string; updated_at?: string } | null = null;
+  try {
+    row = await res.json();
+  } catch {
+    return 'error';
+  }
+  if (!row) return 'revoked';
+  const profile = await unpackProfile(row.payload ?? '', creds.key);
+  if (!profile) return 'error';
+  // Le prénom peut avoir changé depuis l'appairage : on garde le libellé à jour
+  // (écriture seulement s'il a bougé).
+  const list = listWatched();
+  const entry = list.find((w) => w.code === creds.code);
+  if (entry && entry.name !== profile.name) {
+    entry.name = profile.name;
+    saveWatched(list);
+  }
+  return { profile, updatedAt: row.updated_at ?? new Date().toISOString() };
+}
+
+/** Un suivi fraîchement appairé, avec de quoi l'afficher tout de suite. */
+export interface WatchPairing {
+  entry: WatchedProfile;
+  snapshot: WatchSnapshot;
+}
+
+/**
+ * Appaire un suivi depuis un lien scanné ou ouvert : vérifie qu'il est lisible
+ * (un QR mémorisé sans jamais avoir été déchiffré donnerait un onglet mort),
+ * puis l'ajoute à la liste. Renvoie l'entrée créée ET l'instantané, pour un
+ * premier affichage immédiat sans second aller-retour réseau.
+ */
+export async function addWatched(text: string): Promise<WatchPairing | null> {
+  const creds = parseWatchLink(text);
+  if (!creds) return null;
+  const snapshot = await fetchWatched(creds);
+  if (typeof snapshot === 'string') return null;
+  const list = listWatched();
+  let entry = list.find((w) => w.code === creds.code);
+  if (entry) {
+    // Re-scan du même QR (parent qui doute d'avoir réussi) : on rafraîchit la
+    // clé au lieu d'empiler un doublon. Le prénom, lui, vient d'être synchronisé
+    // par fetchWatched.
+    entry.key = creds.key;
+  } else {
+    entry = {
+      ...creds,
+      name: snapshot.profile.name,
+      addedAt: new Date().toISOString(),
+    };
+    list.push(entry);
+  }
+  saveWatched(list);
+  return { entry, snapshot };
+}
+
+/**
+ * Au boot, consomme un éventuel `#watch=` dans l'URL — le parent vient de
+ * scanner le QR affiché sur l'appareil de l'enfant. Contrairement à un
+ * transfert, RIEN n'est installé : l'appareil devient seulement suiveur, ce qui
+ * doit fonctionner même s'il n'a aucun profil local (parent qui découvre
+ * Tablito par ce QR). Renvoie null si le fragment est absent.
+ */
+export async function importWatchFromUrl(): Promise<WatchPairing | 'error' | null> {
+  if (!parseWatchLink(window.location.hash)) return null;
+  try {
+    return (await addWatched(window.location.hash)) ?? 'error';
+  } finally {
+    // Retire le fragment pour qu'un refresh ne relance pas l'appairage.
+    clearUrlHash();
+  }
+}
diff --git a/src/lib/watchStore.ts b/src/lib/watchStore.ts
new file mode 100644
index 00000000..eac99f43
--- /dev/null
+++ b/src/lib/watchStore.ts
@@ -0,0 +1,117 @@
+// Moitié « stockage local » du suivi à distance : types, identifiants, liste des
+// profils suivis, format du lien. Aucune dépendance au chiffrement ni au réseau.
+//
+// Séparé de lib/watch.ts pour une raison de perf de boot : App.tsx a besoin de
+// listWatched() en eager (pour savoir, dès le premier render, si cet appareil
+// suit un enfant — cf. initialScreen). Si ce symbole vivait dans watch.ts,
+// App tirerait watch.ts → transfer.ts dans le graphe de modules eager, et le
+// `await import('./lib/watch')` de main.tsx ne lazy-loaderait plus rien : le
+// projet servant chaque module individuellement (nobuild), ça coûterait 2
+// requêtes HTTP et un niveau de waterfall à TOUS les boots, y compris ceux qui
+// ne touchent jamais au suivi. Ici, rien que des lectures localStorage.
+
+import { supabaseEnv } from './supabase';
+
+/** Identifiants d'un suivi : la ligne serveur (`code`) et de quoi la déchiffrer
+ *  (`key`, base64url). Le couple est ce que transporte le QR d'appairage. */
+export interface WatchCredentials {
+  code: string;
+  key: string;
+}
+
+/** Un profil suivi, tel que mémorisé sur l'appareil du parent. */
+export interface WatchedProfile extends WatchCredentials {
+  // Prénom au dernier rafraîchissement réussi — sert de libellé d'onglet avant
+  // même d'avoir refetché (donc hors-ligne, ou pendant le chargement).
+  name: string;
+  addedAt: string;
+}
+
+// Identifiants du suivi publié pour un profil local, par id de profil. Gardés
+// HORS du UserProfile à dessein : le profil est exporté en JSON et transféré par
+// QR, ce qui ferait fuiter la clé de suivi dans des canaux où elle n'a rien à
+// faire (et rendrait deux appareils publieurs du même code après un transfert).
+const WATCH_KEY_PREFIX = 'multiplix-watch:';
+// Liste des profils suivis à distance sur cet appareil.
+const WATCHED_KEY = 'multiplix-watched';
+
+export function watchConfigured(): boolean {
+  return supabaseEnv() !== null;
+}
+
+// Écriture tolérante : en navigation privée stricte, setItem lève. Même parti
+// pris que lib/storage — on ne casse pas l'action en cours pour ça.
+function write(key: string, value: string): void {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+    // ignore
+  }
+}
+
+/** Lien d'appairage à afficher en QR sur l'appareil de l'enfant. */
+export function watchLink({ code, key }: WatchCredentials): string {
+  return `${window.location.origin}${import.meta.env.BASE_URL}#watch=${code}.${key}`;
+}
+
+// ⚠ Le nom du fragment est aussi testé en dur par l'inline script d'index.html
+// (pré-paint, avant tout module) pour sauter la landing statique — si `watch=`
+// change ici, mettre à jour la regex des fragments de boot là-bas.
+const WATCH_HASH_RE = /[#&]watch=([A-Za-z0-9_-]{16,64})\.([A-Za-z0-9_-]+)/;
+
+/** Extrait {code, clé} d'un lien/fragment de suivi, null si absent. */
+export function parseWatchLink(text: string): WatchCredentials | null {
+  const match = text.match(WATCH_HASH_RE);
+  return match ? { code: match[1], key: match[2] } : null;
+}
+
+// === Côté publieur : identifiants du partage d'un profil local ===
+
+/** Identifiants du suivi publié pour ce profil, null s'il n'est pas partagé. */
+export function loadWatchCredentials(profileId: string): WatchCredentials | null {
+  try {
+    const raw = localStorage.getItem(WATCH_KEY_PREFIX + profileId);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as WatchCredentials;
+    return typeof parsed?.code === 'string' && typeof parsed?.key === 'string' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function saveWatchCredentials(profileId: string, creds: WatchCredentials): void {
+  write(WATCH_KEY_PREFIX + profileId, JSON.stringify(creds));
+}
+
+export function clearWatchCredentials(profileId: string): void {
+  try {
+    localStorage.removeItem(WATCH_KEY_PREFIX + profileId);
+  } catch {
+    // ignore
+  }
+}
+
+// === Côté suiveur : liste des enfants suivis sur cet appareil ===
+
+export function listWatched(): WatchedProfile[] {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(WATCHED_KEY) ?? '[]');
+    return Array.isArray(parsed)
+      ? parsed.filter((w) => typeof w?.code === 'string' && typeof w?.key === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveWatched(list: WatchedProfile[]): void {
+  write(WATCHED_KEY, JSON.stringify(list));
+}
+
+/** Retire un suivi et renvoie la liste restante (évite un relire-après-écrire
+ *  côté appelant, qui doit rafraîchir son état). */
+export function removeWatched(code: string): WatchedProfile[] {
+  const list = listWatched().filter((w) => w.code !== code);
+  saveWatched(list);
+  return list;
+}
diff --git a/src/main.tsx b/src/main.tsx
index ebed9203..98fc88fc 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -5,39 +5,59 @@ import App from './App.tsx'
 import ErrorBoundary from './components/ErrorBoundary'
 import { LangProvider } from './i18n/LangProvider'
 import { importProfileFromUrl } from './lib/storage'
-import { transferFetchingStrings } from './i18n/onboarding'
+import { transferFetchingStrings, watchFetchingStrings } from './i18n/onboarding'
 import type { TransferImportResult } from './lib/transfer'
+import type { WatchPairing } from './lib/watch'
 
-// Deux imports par fragment d'URL, AVANT de monter l'app pour que
-// loadProfile() voie le profil et atterrisse direct sur l'accueil :
+// Écran d'attente affiché AVANT de monter l'app : la récupération (réseau +
+// déchiffrement) prend un instant, sinon l'utilisateur qui vient de scanner un QR
+// regarde un écran vide — ou l'accueil vierge si la PWA était déjà ouverte — et
+// doute que le scan ait marché. Hors LangProvider (rien n'est monté) : on lit la
+// langue posée sur <html> par l'inline script d'index.html, pré-paint.
+function showWaiting(root: HTMLElement, strings: { fr: string; en: string }) {
+  const wait = document.createElement('div')
+  wait.className = 'app-loading'
+  wait.textContent = strings[document.documentElement.lang === 'en' ? 'en' : 'fr']
+  root.replaceChildren(wait)
+}
+
+// Trois traitements par fragment d'URL, AVANT de monter l'app pour que
+// loadProfile() voie le profil et qu'on atterrisse direct sur le bon écran :
 //  - #import=   : migration cross-origin (ancien domaine → tablito.app)
-//  - #transfer= : transfert depuis un autre appareil (QR de l'espace parent).
-//    lib/transfer n'est chargé que si le fragment est là : un boot ordinaire
-//    (l'immense majorité) garde son graphe de modules eager inchangé.
+//  - #transfer= : transfert depuis un autre appareil (QR de l'espace parent)
+//  - #watch=    : appairage d'un suivi à distance — le parent scanne le QR de
+//    l'appareil de son enfant. Rien n'est installé ici : l'appareil devient
+//    seulement suiveur, ce qui doit marcher même sans aucun profil local.
+// Les libs correspondantes ne sont chargées que si le fragment est là : un boot
+// ordinaire (l'immense majorité) garde son graphe de modules eager inchangé.
 async function boot() {
   await importProfileFromUrl()
   const root = document.getElementById('root')!
+  // Avant l'appairage, pas après : registerSW ne dépend d'aucun de ses résultats,
+  // et le faire attendre un aller-retour réseau retarderait d'autant le précache
+  // du shell — précisément sur le boot le plus froid (première visite du parent).
+  registerSW()
   let transferResult: TransferImportResult = null
-  if (window.location.hash.includes('transfer=')) {
-    // La récupération (réseau + déchiffrement) prend un instant : l'afficher
-    // tout de suite, sinon l'utilisateur qui vient de scanner le QR regarde un
-    // écran vide — ou l'accueil vierge si la PWA était déjà ouverte — et doute
-    // que le scan ait marché. Hors LangProvider (rien n'est monté) : on lit la
-    // langue posée sur <html> par l'inline script d'index.html, pré-paint.
-    const wait = document.createElement('div')
-    wait.className = 'app-loading'
-    wait.textContent =
-      transferFetchingStrings[document.documentElement.lang === 'en' ? 'en' : 'fr']
-    root.replaceChildren(wait)
+  let watchPairing: WatchPairing | 'error' | null = null
+  const hash = window.location.hash
+  if (hash.includes('transfer=')) {
+    showWaiting(root, transferFetchingStrings)
     transferResult = await (await import('./lib/transfer')).importTransferFromUrl()
     root.replaceChildren()
+  } else if (hash.includes('watch=')) {
+    showWaiting(root, watchFetchingStrings)
+    // Un appairage atterrit sur l'espace parent, qui est lazy : on amorce son
+    // chunk en parallèle de la relecture réseau, au lieu d'enchaîner les deux
+    // allers-retours. Sans await — c'est un préchargement, pas une dépendance.
+    void import('./screens/ParentDashboard')
+    watchPairing = await (await import('./lib/watch')).importWatchFromUrl()
+    root.replaceChildren()
   }
-  registerSW()
   createRoot(root).render(
     <StrictMode>
       <ErrorBoundary>
         <LangProvider>
-          <App transferResult={transferResult} />
+          <App transferResult={transferResult} watchPairing={watchPairing} />
         </LangProvider>
       </ErrorBoundary>
     </StrictMode>,
diff --git a/src/screens/ParentDashboard.css b/src/screens/ParentDashboard.css
index 4d299a4d..94117303 100644
--- a/src/screens/ParentDashboard.css
+++ b/src/screens/ParentDashboard.css
@@ -465,3 +465,78 @@
 .parent-hard-fact-kind--rem {
   background: var(--coral);
 }
+
+/* === Suivi à distance === */
+
+/* Barre de fraîcheur du profil suivi, juste sous le sélecteur de source. */
+.parent-remote-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin: 0 20px 4px;
+  padding: 10px 14px;
+  border: 1.5px solid var(--line);
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--sage) 8%, var(--paper));
+}
+
+.parent-remote-status {
+  font-size: 13px;
+  color: var(--ink-soft);
+}
+
+.parent-remote-status--error {
+  color: var(--box-red);
+}
+
+/* Bouton compact : il vit dans la barre, pas dans une grille d'actions. */
+.parent-remote-refresh {
+  flex-shrink: 0;
+  width: auto;
+  padding: 6px 12px;
+  font-size: 13px;
+}
+
+.parent-remote-refresh:disabled {
+  opacity: 0.5;
+}
+
+/* Un bloc par sens du suivi (partager d'ici / suivre d'ailleurs). */
+.parent-watch-block {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 10px;
+  margin-top: 12px;
+}
+
+.parent-watch-list {
+  margin: 14px 20px 0;
+  border-top: 1.5px solid var(--line);
+}
+
+.parent-watch-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--line);
+}
+
+.parent-watch-name {
+  font-weight: 700;
+}
+
+.parent-watch-remove {
+  flex-shrink: 0;
+  background: none;
+  border: none;
+  padding: 4px 0;
+  font: inherit;
+  font-size: 13px;
+  color: var(--box-red);
+  text-decoration: underline;
+  cursor: pointer;
+}
diff --git a/src/screens/ParentDashboard.tsx b/src/screens/ParentDashboard.tsx
index 2508a2c3..3b403e8d 100644
--- a/src/screens/ParentDashboard.tsx
+++ b/src/screens/ParentDashboard.tsx
@@ -1,28 +1,43 @@
-import { useState, useMemo, useEffect, useRef } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import type { UserProfile } from '../types';
-import { isDivisionUnlocked, isRemainderUnlocked, activeLevel } from '../lib/badges';
-import { countMastered } from '../lib/leitner';
-import { getHardestFacts } from '../lib/hardestFacts';
-import { getActiveStreak } from '../lib/streak';
-import { todayISO } from '../lib/utils';
-import ProgressGrid from '../components/ProgressGrid';
-import DivisionProgressGrid from '../components/DivisionProgressGrid';
-import RemainderProgressGrid from '../components/RemainderProgressGrid';
 import BackChevron from '../components/BackChevron';
 import FeedbackModal from '../components/FeedbackModal';
-import EvolutionChart from '../components/EvolutionChart';
 import NotificationSettings from '../components/NotificationSettings';
 import LanguageToggle from '../components/LanguageToggle';
-import { useLang } from '../i18n/lang';
+import ParentStats from '../components/ParentStats';
+import QrCanvas from '../components/QrCanvas';
+import { useGuideBase } from '../i18n/lang';
 import { useParentDashboardStrings } from '../i18n/parent';
+import { getActiveProfileId } from '../lib/storage';
 import { createTransfer, transferConfigured, TRANSFER_TTL_MINUTES } from '../lib/transfer';
-
-const HARD_FACTS_WINDOW = 10;
-const EVOLUTION_WINDOW = 20;
+import {
+  addWatched,
+  fetchWatched,
+  startWatch,
+  stopWatch,
+  type WatchFetchResult,
+  type WatchPairing,
+} from '../lib/watch';
+import {
+  listWatched,
+  loadWatchCredentials,
+  parseWatchLink,
+  removeWatched,
+  watchConfigured,
+  watchLink,
+  type WatchCredentials,
+  type WatchedProfile,
+} from '../lib/watchStore';
+import { useQrScan } from '../hooks/useQrScan';
 
 interface ParentDashboardProps {
-  profile: UserProfile;
-  onBack: () => void;
+  // Profil local actif. NULL sur un appareil qui ne fait que suivre un enfant à
+  // distance : un parent peut découvrir Tablito en scannant le QR de l'appareil
+  // de son enfant, sans jamais créer de profil ici.
+  profile: UserProfile | null;
+  // Absent quand il n'y a pas de profil local : il n'y a alors nulle part où
+  // revenir, l'espace parent EST l'app.
+  onBack?: () => void;
   onExport: () => void;
   onImport: (json: string) => void;
   // Multi-profils : lance l'onboarding Welcome pour un nouvel enfant.
@@ -31,8 +46,22 @@ interface ParentDashboardProps {
   onDeleteProfile: () => void;
   onShowPrivacy: () => void;
   onShowChangelog: () => void;
+  // Suivi appairé au boot depuis un `#watch=` : déjà déchiffré par main.tsx, on
+  // l'affiche sans second aller-retour réseau.
+  initialWatch?: WatchPairing | null;
 }
 
+// État de la relecture du suivi sélectionné ('loading' + les trois issues de
+// fetchWatched : instantané, partage révoqué, échec).
+type RemoteState = 'loading' | WatchFetchResult;
+
+// Cible d'un « Copié ✓ » — un seul état pour les trois boutons qui copient.
+type CopyTarget = 'app' | 'transfer' | 'watch';
+
+// État du partage de la progression locale (côté appareil de l'enfant) — un
+// seul état, l'objet {link} valant « partagé, QR affichable ».
+type ShareState = 'idle' | 'loading' | 'error' | { link: string };
+
 export default function ParentDashboard({
   profile,
   onBack,
@@ -42,186 +71,204 @@ export default function ParentDashboard({
   onDeleteProfile,
   onShowPrivacy,
   onShowChangelog,
+  initialWatch = null,
 }: ParentDashboardProps) {
+  const t = useParentDashboardStrings();
+  const guideBase = useGuideBase();
+
   const [showImport, setShowImport] = useState(false);
   const [importJson, setImportJson] = useState('');
   const [showFeedback, setShowFeedback] = useState(false);
-  const [shareCopied, setShareCopied] = useState(false);
+  // Un seul drapeau « Copié ✓ » pour les trois boutons qui copient un lien.
+  const [copied, setCopied] = useState<CopyTarget | null>(null);
   // Transfert vers un autre appareil : un seul état, l'objet {link} valant
   // « prêt, QR à afficher » (cf. lib/transfer) — aucune combinaison incohérente
   // possible entre statut et lien.
-  const [transfer, setTransfer] = useState<'idle' | 'loading' | 'error' | { link: string }>('idle');
+  const [transfer, setTransfer] = useState<ShareState>('idle');
   const transferLink = typeof transfer === 'object' ? transfer.link : null;
-  const [transferCopied, setTransferCopied] = useState(false);
-  const qrCanvasRef = useRef<HTMLCanvasElement | null>(null);
 
-  // « Copié ✓ » pendant 2 s — partagé par « Partager l'app » et le lien de
-  // transfert. Échec silencieux : clipboard indisponible (contexte non
-  // sécurisé), l'utilisateur a d'autres chemins (feuille de partage, QR).
-  const copyWithFeedback = async (text: string, setFlag: (v: boolean) => void) => {
+  const profileId = getActiveProfileId();
+
+  // === Sources : profil local + profils suivis à distance ===
+  const [watched, setWatched] = useState<WatchedProfile[]>(listWatched);
+  // Source affichée : null = la progression stockée ICI, sinon le code d'un
+  // suivi. Une chaîne (et non un objet) parce que c'est l'identité stable dont
+  // dépend la relecture : re-cliquer l'onglet courant repose la même valeur,
+  // React court-circuite le render, et aucune relecture n'est relancée.
+  const [selectedCode, setSelectedCode] = useState<string | null>(() => {
+    // Appairage au boot : on ouvre directement sur l'enfant qu'on vient de
+    // scanner, c'est la raison même de l'ouverture de l'app.
+    if (initialWatch) return initialWatch.entry.code;
+    if (profile) return null;
+    return listWatched()[0]?.code ?? null;
+  });
+
+  // L'instantané distant, ÉTIQUETÉ du code auquel il appartient : c'est ce qui
+  // répond à « ai-je déjà les données de la source affichée ? » sans état de
+  // coordination supplémentaire (ni drapeau « saute le premier fetch », ni
+  // compteur de rafraîchissement, ni dépendance d'effet à museler).
+  const [remote, setRemote] = useState<{ code: string; state: RemoteState } | null>(() =>
+    initialWatch ? { code: initialWatch.entry.code, state: initialWatch.snapshot } : null,
+  );
+
+  // Code de la relecture la plus récemment lancée. Écrit hors render (dans
+  // l'effet et dans le handler d'actualisation, cf. react-hooks/refs) : sert à
+  // ignorer un résultat qui arrive après une bascule d'onglet, et à ne pas
+  // relancer une relecture déjà en vol.
+  const inFlightRef = useRef<string | null>(initialWatch?.entry.code ?? null);
+
+  // Relecture au changement de source. La promesse est chaînée INLINE et non
+  // déportée dans un useCallback : c'est la forme que la règle
+  // react-hooks/set-state-in-effect accepte, et celle déjà employée par
+  // NotificationSettings. Aucun état « chargement » n'est posé ici — l'absence
+  // d'instantané pour la source affichée EST le chargement (cf. remoteState).
+  useEffect(() => {
+    if (!selectedCode || inFlightRef.current === selectedCode) return;
+    const entry = listWatched().find((w) => w.code === selectedCode);
+    if (!entry) return;
+    inFlightRef.current = selectedCode;
+    let cancelled = false;
+    void fetchWatched(entry).then((state) => {
+      if (!cancelled) setRemote({ code: selectedCode, state });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedCode]);
+
+  // « Actualiser » : même relecture, mais avec un retour visuel explicite —
+  // un instantané est déjà à l'écran, donc son remplacement doit se voir. Dans un
+  // handler d'événement, poser l'état est légitime (à l'inverse de l'effet).
+  const refreshRemote = async (entry: WatchedProfile) => {
+    inFlightRef.current = entry.code;
+    setRemote({ code: entry.code, state: 'loading' });
+    const state = await fetchWatched(entry);
+    if (inFlightRef.current === entry.code) setRemote({ code: entry.code, state });
+  };
+
+  const watchedEntry = selectedCode
+    ? watched.find((w) => w.code === selectedCode) ?? null
+    : null;
+  // N'est vrai que si l'état chargé correspond bien à la source affichée.
+  const remoteState: RemoteState | null =
+    watchedEntry && remote?.code === watchedEntry.code ? remote.state : null;
+  const remoteSnapshot = typeof remoteState === 'object' ? remoteState : null;
+  // Profil réellement rendu par ParentStats.
+  const shown = watchedEntry ? remoteSnapshot?.profile ?? null : profile;
+  const shownName = shown?.name ?? watchedEntry?.name ?? '';
+
+  const sources: Array<{ code: string | null; label: string }> = [
+    ...(profile ? [{ code: null, label: profile.name }] : []),
+    ...watched.map((w) => ({ code: w.code as string | null, label: t.remoteSourceTab(w.name) })),
+  ];
+
+  // === Partage de la progression locale (appareil de l'enfant) ===
+  const [share, setShare] = useState<ShareState>('idle');
+  const shareLink = typeof share === 'object' ? share.link : null;
+  // Identifiants du partage déjà ouvert (possiblement lors d'une session
+  // précédente). En state et non relus à chaque render : startWatch/stopWatch
+  // écrivent dans localStorage sans repasser par React, donc c'est ici que vit
+  // la vérité affichée — sinon « Ne plus partager » laisse le bouton continuer à
+  // proposer « Revoir le QR code » jusqu'au prochain render fortuit.
+  const [sharedCreds, setSharedCreds] = useState<WatchCredentials | null>(() =>
+    profileId ? loadWatchCredentials(profileId) : null,
+  );
+
+  // === Appairage d'un suivi (appareil du parent) ===
+  type PairState = 'idle' | 'scanning' | 'fetching' | 'cameraError' | 'linkError' | 'manual';
+  const [pair, setPair] = useState<PairState>('idle');
+  const [pairText, setPairText] = useState('');
+
+  const acceptWatchLink = async (text: string): Promise<boolean> => {
+    if (!parseWatchLink(text)) return false;
+    setPair('fetching');
+    const paired = await addWatched(text);
+    if (!paired) {
+      setPair('linkError');
+      return true; // lien reconnu mais illisible : inutile de continuer à filmer
+    }
+    setWatched(listWatched());
+    // L'instantané est déjà déchiffré : on l'étiquette, et marquer le code comme
+    // servi évite que l'effet relance une relecture inutile juste après.
+    inFlightRef.current = paired.entry.code;
+    setRemote({ code: paired.entry.code, state: paired.snapshot });
+    setSelectedCode(paired.entry.code);
+    setPair('idle');
+    return true;
+  };
+
+  const scanVideoRef = useQrScan({
+    active: pair === 'scanning',
+    onCode: acceptWatchLink,
+    onCameraError: () => setPair('cameraError'),
+  });
+
+  // « Copié ✓ » pendant 2 s. Échec silencieux : clipboard indisponible (contexte
+  // non sécurisé), l'utilisateur a d'autres chemins (QR, feuille de partage).
+  const copyWithFeedback = async (text: string, target: CopyTarget) => {
     try {
       await navigator.clipboard.writeText(text);
-      setFlag(true);
-      setTimeout(() => setFlag(false), 2000);
+      setCopied(target);
+      setTimeout(() => setCopied((c) => (c === target ? null : c)), 2000);
     } catch {
       // ignore
     }
   };
-  const t = useParentDashboardStrings();
-  const { lang } = useLang();
-  // Le guide est bilingue : FR à `/guide/`, autres langues sous `/guide/<lang>/`
-  // (cf. scripts/generate-user-guide.mjs). On pointe vers la version courante.
-  const guideBase = `${import.meta.env.BASE_URL}guide/${lang === 'fr' ? '' : `${lang}/`}`;
-
-  const divisionUnlocked = useMemo(() => isDivisionUnlocked(profile), [profile]);
-  const remainderUnlocked = useMemo(() => isRemainderUnlocked(profile), [profile]);
-  const divisionFacts = useMemo(() => profile.divisionFacts ?? [], [profile.divisionFacts]);
-  const remainderFacts = useMemo(() => profile.remainderFacts ?? [], [profile.remainderFacts]);
-  // Onglet par défaut : le niveau actif — c'est l'activité d'apprentissage en
-  // cours (les niveaux passés sont déjà en boîte 5 par hypothèse, et surtout
-  // l'objet de l'attention du parent au quotidien).
-  const [gridView, setGridView] = useState<'mult' | 'div' | 'rem'>(() => activeLevel(profile));
-  const showRem = remainderUnlocked && gridView === 'rem';
-  const showDiv = divisionUnlocked && gridView === 'div';
-
-  const handleShare = async () => {
+
+  const handleShareApp = async () => {
     const url = window.location.origin + import.meta.env.BASE_URL;
     if (navigator.share) {
       try {
-        await navigator.share({
-          title: 'Tablito',
-          text: t.shareText,
-          url,
-        });
+        await navigator.share({ title: 'Tablito', text: t.shareText, url });
       } catch {
         // Annulation utilisateur : pas de fallback clipboard, sinon on copie
         // un lien que l'utilisateur a explicitement refusé de partager.
       }
       return;
     }
-    await copyWithFeedback(url, setShareCopied);
+    await copyWithFeedback(url, 'app');
   };
 
   const handleTransfer = async () => {
     if (transfer !== 'idle') {
       // Second clic : replie le panneau. Le code déposé expirera tout seul.
       setTransfer('idle');
-      setTransferCopied(false);
       return;
     }
+    if (!profile) return;
     setTransfer('loading');
     const link = await createTransfer(profile);
     setTransfer(link ? { link } : 'error');
   };
 
-  // Dessine le QR quand le lien est prêt. lean-qr est chargé à la demande :
-  // inutile d'alourdir le chunk du dashboard pour une action rare.
-  useEffect(() => {
-    if (!transferLink) return;
-    let cancelled = false;
-    import('lean-qr')
-      .then(({ generate }) => {
-        if (!cancelled && qrCanvasRef.current) {
-          generate(transferLink).toCanvas(qrCanvasRef.current);
-        }
-      })
-      .catch(() => {
-        if (!cancelled) setTransfer('error');
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [transferLink]);
-
-  // Descripteur de l'opération sélectionnée par le parent (× / ÷ / reste) —
-  // un seul point de vérité pour toutes les sections pilotées par le
-  // sélecteur (compteur de maîtrise, répartition par boîte, grille Leitner).
-  const activeView = showRem
-    ? {
-        facts: remainderFacts,
-        mastered: `${countMastered(remainderFacts)}/${remainderFacts.length}`,
-        masteredLabel: t.remaindersMastered,
-        opPlural: t.opRemaindersPlural,
-        opSingular: t.opRemainder,
-        grid: <RemainderProgressGrid facts={remainderFacts} />,
-      }
-    : showDiv
-      ? {
-          facts: divisionFacts,
-          mastered: `${countMastered(divisionFacts)}/${divisionFacts.length}`,
-          masteredLabel: t.divisionsMastered,
-          opPlural: t.opDivisionsPlural,
-          opSingular: t.opDivision,
-          grid: <DivisionProgressGrid facts={divisionFacts} />,
-        }
-      : {
-          facts: profile.facts,
-          mastered: `${countMastered(profile.facts)}/${profile.facts.length}`,
-          masteredLabel: t.multiplicationsMastered,
-          opPlural: t.opMultiplicationsPlural,
-          opSingular: t.opMultiplication,
-          grid: <ProgressGrid facts={profile.facts} />,
-        };
-
-  // Onglets du sélecteur — même pattern que « Mes images » (ProgressScreen).
-  const opTabs: Array<{ key: 'mult' | 'div' | 'rem'; label: string }> = [
-    { key: 'mult', label: t.multiplications },
-    { key: 'div', label: t.divisions },
-    ...(remainderUnlocked ? [{ key: 'rem' as const, label: t.remainders }] : []),
-  ];
-
-  // Histogramme de l'opération sélectionnée.
-  const { boxCounts, maxBoxCount } = useMemo(() => {
-    const counts = [0, 0, 0, 0, 0, 0];
-    for (const fact of activeView.facts) {
-      if (!fact.introduced) counts[0]++;
-      else counts[fact.box]++;
+  // Ouvre le partage, ou réaffiche le QR d'un partage déjà ouvert (le lien est
+  // reconstruit depuis les identifiants locaux, sans redéposer d'instantané).
+  const handleShareProgress = async () => {
+    if (share !== 'idle') {
+      setShare('idle');
+      return;
     }
-    return { boxCounts: counts, maxBoxCount: Math.max(...counts, 1) };
-  }, [activeView.facts]);
-
-  // Liste UNIFIÉE × + ÷ — indépendante du sélecteur (mélange les deux opérations
-  // pour montrer où l'enfant bute en ce moment, cf. lib/hardestFacts).
-  const hardFacts = useMemo(
-    () => getHardestFacts(profile, HARD_FACTS_WINDOW, 5),
-    [profile],
-  );
-
-  const recentSessions = useMemo(
-    () => [...profile.sessionHistory].reverse().slice(0, 10),
-    [profile.sessionHistory],
-  );
-
-  const evolution = useMemo(() => {
-    const sessions = profile.sessionHistory.slice(-EVOLUTION_WINDOW);
-    if (sessions.length < 2) return null;
-
-    const accuracy: Array<{ date: string; value: number }> = [];
-    const time: Array<{ date: string; value: number }> = [];
-    for (const s of sessions) {
-      const date = t.formatShortDate(new Date(s.date));
-      accuracy.push({
-        date,
-        value: Math.round((s.correctCount / s.questionsCount) * 100),
-      });
-      time.push({ date, value: s.averageTimeMs / 1000 });
+    if (!profile || !profileId) return;
+    if (sharedCreds) {
+      setShare({ link: watchLink(sharedCreds) });
+      return;
     }
-    // Au moins 4s d'amplitude pour éviter qu'une variation de 0,2s ne paraisse
-    // dramatique sur un enfant déjà rapide.
-    const timeYMax = Math.max(Math.ceil(Math.max(...time.map((t) => t.value))), 4);
-
-    return { accuracy, time, timeYMax };
-  }, [profile.sessionHistory, t]);
-
-  // Compteurs de maîtrise (× et ÷) au même format — réutilisés par la carte
-  // « Faits maîtrisés » (avant déblocage) et la carte de maîtrise (après).
-  const multMastered = `${countMastered(profile.facts)}/${profile.facts.length}`;
+    setShare('loading');
+    const link = await startWatch(profileId, profile);
+    if (!link) {
+      setShare('error');
+      return;
+    }
+    setSharedCreds(loadWatchCredentials(profileId));
+    setShare({ link });
+  };
 
-  const boxColors = [
-    'var(--box-gray)', 'var(--box-red)', 'var(--box-orange)',
-    'var(--box-yellow)', 'var(--box-lightgreen)', 'var(--box-green)',
-  ];
-  const boxLabels = ['N/A', 'B1', 'B2', 'B3', 'B4', 'B5'];
+  const handleStopSharing = async () => {
+    if (!profileId) return;
+    setShare('idle');
+    setSharedCreds(null);
+    await stopWatch(profileId);
+  };
 
   const handleImport = () => {
     if (importJson.trim()) {
@@ -231,275 +278,267 @@ export default function ParentDashboard({
     }
   };
 
+  const handleStopWatching = (code: string) => {
+    const list = removeWatched(code);
+    setWatched(list);
+    // Le suivi affiché disparaît : on retombe sur le profil local, ou à défaut
+    // sur un autre enfant suivi.
+    if (selectedCode === code) setSelectedCode(profile ? null : list[0]?.code ?? null);
+  };
+
+  // Sections qui n'ont de sens que sur la progression stockée ICI : sauvegarde,
+  // transfert, rappels, suppression de profil. Sur un profil suivi à distance,
+  // elles parleraient d'un appareil qu'on n'a pas en main.
+  const localSelected = selectedCode === null && profile !== null;
+
   return (
     <div className="parent-dashboard">
       <div className="parent-header">
-        <button className="parent-back-btn" onClick={onBack} aria-label={t.back}>
-          <BackChevron />
-        </button>
+        {onBack && (
+          <button className="parent-back-btn" onClick={onBack} aria-label={t.back}>
+            <BackChevron />
+          </button>
+        )}
         <div className="parent-header-titles">
           <div className="parent-eyebrow">{t.parentArea}</div>
-          <div className="parent-title">{t.profileSuffix(profile.name)}</div>
+          <div className="parent-title">{t.profileSuffix(shownName)}</div>
         </div>
       </div>
 
-      {/* Stats transverses (activité / séries) — indépendantes de l'opération,
-          donc valables pour × comme pour ÷. Les compteurs de maîtrise, eux,
-          vivent plus bas sous le sélecteur (cf. carte de maîtrise). */}
-      <div className="parent-section">
-        <h3>{t.overview}</h3>
-        <div className={`parent-stats-grid${divisionUnlocked ? ' parent-stats-grid--three' : ''}`}>
-          <div className="parent-stat-card">
-            <div className="parent-stat-value">{profile.totalSessions}</div>
-            <div className="parent-stat-label">{t.sessions}</div>
-          </div>
-          <div className="parent-stat-card">
-            <div className="parent-stat-value">{getActiveStreak(profile, todayISO())}</div>
-            <div className="parent-stat-label">{t.currentStreak}</div>
-          </div>
-          <div className="parent-stat-card">
-            <div className="parent-stat-value">{profile.longestStreak}</div>
-            <div className="parent-stat-label">{t.bestStreak}</div>
-          </div>
-          {!divisionUnlocked && (
-            <div className="parent-stat-card">
-              <div className="parent-stat-value">{multMastered}</div>
-              <div className="parent-stat-label">{t.masteredFacts}</div>
-            </div>
-          )}
+      {/* Sélecteur de source — n'apparaît que s'il y a vraiment un choix à
+          faire. Mêmes classes que le sélecteur d'opération. */}
+      {sources.length > 1 && (
+        <div className="progress-tabs parent-op-tabs" role="tablist" aria-label={t.sourceLabel}>
+          {sources.map((item) => (
+            <button
+              key={item.code ?? 'local'}
+              type="button"
+              className={`progress-tab ${item.code === selectedCode ? 'active' : ''}`}
+              onClick={() => setSelectedCode(item.code)}
+            >
+              {item.label}
+            </button>
+          ))}
         </div>
-      </div>
-
-      {/* Sélecteur d'opération — partagé par la carte de maîtrise, la Répartition
-          et la Grille Leitner ci-dessous. Réutilise les classes du sélecteur
-          « Mes images » côté enfant (.progress-tabs, CSS concaténé global).
-          Visible uniquement après déblocage : avant, la division ne doit pas
-          apparaître (specs §11.3). */}
-      {divisionUnlocked && (
-        <>
-          <div className="progress-tabs parent-op-tabs" role="tablist" aria-label={t.operation}>
-            {opTabs.map(({ key, label }) => (
-              <button
-                key={key}
-                type="button"
-                className={`progress-tab ${gridView === key ? 'active' : ''}`}
-                onClick={() => setGridView(key)}
-              >
-                {label}
-              </button>
-            ))}
-          </div>
-
-          {/* Compteur de maîtrise de l'opération sélectionnée — sorti de la
-              « Vue d'ensemble » pour vivre dans la section pilotée par le
-              sélecteur, au même titre que la Répartition et la Grille. */}
-          <div className="parent-section">
-            <div className="parent-stat-card parent-mastery-card">
-              <div className="parent-stat-value">{activeView.mastered}</div>
-              <div className="parent-stat-label">{activeView.masteredLabel}</div>
-            </div>
-          </div>
-        </>
       )}
 
-      {/* Box histogram */}
-      <div className="parent-section">
-        <h3>
-          {t.boxDistribution}
-          <a
-            className="parent-section-help"
-            href={`${guideBase}#principes`}
-            target="_blank"
-            rel="noopener noreferrer"
-            aria-label={t.learnMoreLeitner}
+      {/* Fraîcheur du suivi : sans elle, un appareil enfant éteint depuis une
+          semaine afficherait des stats périmées sans le dire. */}
+      {watchedEntry && (
+        <div className="parent-remote-bar">
+          {(remoteState === null || remoteState === 'loading') && (
+            <span className="parent-remote-status">{t.remoteLoading}</span>
+          )}
+          {remoteState === 'error' && (
+            <span className="parent-remote-status parent-remote-status--error">
+              {t.remoteError}
+            </span>
+          )}
+          {remoteState === 'revoked' && (
+            <span className="parent-remote-status parent-remote-status--error">
+              {t.remoteRevoked(watchedEntry.name)}
+            </span>
+          )}
+          {remoteSnapshot && (
+            <span className="parent-remote-status">
+              {t.remoteSyncedAgo(remoteSnapshot.updatedAt)}
+            </span>
+          )}
+          <button
+            className="parent-action-btn parent-remote-refresh"
+            onClick={() => void refreshRemote(watchedEntry)}
+            disabled={remoteState === null || remoteState === 'loading'}
           >
-            ?
-          </a>
-        </h3>
-        <p className="parent-section-subtitle">
-          {t.boxDistributionSubtitle(activeView.opPlural)}
-        </p>
-        <div className="parent-histogram">
-          {boxCounts.map((count, i) => (
-            <div key={i} className="parent-histogram-bar">
-              <div className="parent-histogram-count">{count}</div>
-              <div
-                className="parent-histogram-fill"
-                style={{
-                  height: `${(count / maxBoxCount) * 100}%`,
-                  background: boxColors[i],
-                }}
-              />
-              <div className="parent-histogram-label">{boxLabels[i]}</div>
-            </div>
-          ))}
+            {t.remoteRefresh}
+          </button>
         </div>
-      </div>
-
-      {/* Leitner color grid (diagnostic view — complements the child's
-          mystery image in §5.1 by showing the raw box state per fact) */}
-      <div className="parent-section">
-        <h3>
-          {t.leitnerGrid}
-          <a
-            className="parent-section-help"
-            href={`${guideBase}#principes`}
-            target="_blank"
-            rel="noopener noreferrer"
-            aria-label={t.learnMoreLeitner}
-          >
-            ?
-          </a>
-        </h3>
-        <p className="parent-section-subtitle">
-          {t.leitnerGridSubtitle(activeView.opSingular)}
-        </p>
-        {activeView.grid}
-      </div>
-
-      {/* Evolution: accuracy + response time */}
-      {evolution && (
-        <>
-          <div className="parent-section">
-            <h3>{t.correctAnswerRate}</h3>
-            <EvolutionChart
-              data={evolution.accuracy}
-              yMin={0}
-              yMax={100}
-              yTicks={[0, 25, 50, 75, 100]}
-              formatY={(v) => `${v}%`}
-              color="var(--primary)"
-            />
-          </div>
-          <div className="parent-section">
-            <h3>{t.averageResponseTime}</h3>
-            <EvolutionChart
-              data={evolution.time}
-              yMin={0}
-              yMax={evolution.timeYMax}
-              yTicks={[0, evolution.timeYMax / 2, evolution.timeYMax]}
-              formatY={(v) => `${v.toFixed(1)}s`}
-              color="var(--sage)"
-            />
-          </div>
-        </>
       )}
 
-      {/* Hardest facts */}
-      {hardFacts.length > 0 && (
+      {shown ? (
+        <ParentStats profile={shown} />
+      ) : (
         <div className="parent-section">
-          <h3>{t.hardestFacts}</h3>
           <p className="parent-section-subtitle">
-            {t.hardestFactsSubtitle(HARD_FACTS_WINDOW)}
+            {remoteState === null || remoteState === 'loading' ? t.remoteLoading : t.remoteNoData}
           </p>
-          <div className="parent-hard-facts">
-            {hardFacts.map((f) => (
-              <div key={`${f.kind}-${f.key}`} className="parent-hard-fact">
-                <span
-                  className={`parent-hard-fact-kind parent-hard-fact-kind--${f.kind}`}
-                  aria-label={
-                    f.kind === 'rem'
-                      ? t.factRemainder
-                      : f.kind === 'div'
-                        ? t.factDivision
-                        : t.factMultiplication
-                  }
-                >
-                  {f.kind === 'rem' ? t.remSymbol : f.kind === 'div' ? t.divSymbol : t.multSymbol}
-                </span>
-                <span className="parent-hard-fact-name">
-                  {f.kind === 'rem'
-                    ? t.formatRemFact(
-                        f.divisor * f.quotient,
-                        f.divisor * f.quotient + f.divisor - 1,
-                        f.divisor,
-                      )
-                    : f.kind === 'div'
-                      ? t.formatDivFact(f.dividend, f.divisor, f.quotient)
-                      : t.formatMultFact(f.a, f.b, f.product)}
-                </span>
-                <span className="parent-hard-fact-errors">
-                  {t.errors(f.errorCount)} | {t.boxLabel(f.box)}
-                </span>
-              </div>
-            ))}
-          </div>
         </div>
       )}
 
-      {/* Session history */}
-      {profile.sessionHistory.length > 0 && (
+      {/* Actions de sauvegarde — propres à la progression stockée ici. */}
+      {localSelected && (
         <div className="parent-section">
-          <h3>{t.sessionHistory}</h3>
-          <div className="parent-session-history">
-            {recentSessions.map((session) => {
-              const dateStr = t.formatLongDate(new Date(session.date));
-              const avgSec = (session.averageTimeMs / 1000).toFixed(1);
-              return (
-                <div key={session.date} className="parent-session-row">
-                  <span className="parent-session-date">{dateStr}</span>
-                  <span className="parent-session-score">
-                    {session.correctCount}/{session.questionsCount}
-                  </span>
-                  <span className="parent-session-time">{avgSec}s</span>
-                </div>
-              );
-            })}
+          <h3>{t.backup}</h3>
+          <div className="parent-actions">
+            {transferConfigured() && (
+              <button className="parent-action-btn" onClick={handleTransfer}>
+                {t.transfer}
+              </button>
+            )}
+            <button className="parent-action-btn" onClick={onExport}>
+              {t.export}
+            </button>
+            <button className="parent-action-btn" onClick={() => setShowImport(!showImport)}>
+              {t.import}
+            </button>
           </div>
+          {transfer !== 'idle' && (
+            <div className="parent-transfer-area">
+              {transfer === 'loading' && (
+                <p className="parent-transfer-status">{t.transferPreparing}</p>
+              )}
+              {transfer === 'error' && (
+                <p className="parent-transfer-status parent-transfer-status--error">
+                  {t.transferError}
+                </p>
+              )}
+              {transferLink && (
+                <>
+                  <QrCanvas
+                    value={transferLink}
+                    className="parent-transfer-qr"
+                    ariaLabel={t.transferQrAlt}
+                    onError={() => setTransfer('error')}
+                  />
+                  <p className="parent-transfer-hint">{t.transferHint(TRANSFER_TTL_MINUTES)}</p>
+                  <button
+                    className="parent-action-btn"
+                    onClick={() => void copyWithFeedback(transferLink, 'transfer')}
+                  >
+                    {copied === 'transfer' ? t.linkCopied : t.transferCopyLink}
+                  </button>
+                </>
+              )}
+            </div>
+          )}
         </div>
       )}
 
-      {/* Actions */}
-      <div className="parent-section">
-        <h3>{t.backup}</h3>
-        <div className="parent-actions">
-          {transferConfigured() && (
-            <button className="parent-action-btn" onClick={handleTransfer}>
-              {t.transfer}
-            </button>
+      {/* Suivi à distance — les deux sens : partager la progression de cet
+          appareil, et suivre celle d'un autre. */}
+      {watchConfigured() && (
+        <div className="parent-section">
+          <h3>{t.watchTitle}</h3>
+          <p className="parent-section-subtitle">{t.watchSubtitle}</p>
+
+          {localSelected && (
+            <div className="parent-watch-block">
+              <div className="parent-actions">
+                <button className="parent-action-btn" onClick={handleShareProgress}>
+                  {sharedCreds ? t.watchShowQr(profile.name) : t.watchShare(profile.name)}
+                </button>
+                {sharedCreds && (
+                  <button
+                    className="parent-action-btn parent-action-btn--danger"
+                    onClick={handleStopSharing}
+                  >
+                    {t.watchStopSharing}
+                  </button>
+                )}
+              </div>
+              {share !== 'idle' && (
+                <div className="parent-transfer-area">
+                  {share === 'loading' && (
+                    <p className="parent-transfer-status">{t.watchPreparing}</p>
+                  )}
+                  {share === 'error' && (
+                    <p className="parent-transfer-status parent-transfer-status--error">
+                      {t.watchShareError}
+                    </p>
+                  )}
+                  {shareLink && (
+                    <>
+                      <QrCanvas
+                        value={shareLink}
+                        className="parent-transfer-qr"
+                        ariaLabel={t.watchQrAlt}
+                        onError={() => setShare('error')}
+                      />
+                      <p className="parent-transfer-hint">{t.watchShareHint}</p>
+                      <button
+                        className="parent-action-btn"
+                        onClick={() => void copyWithFeedback(shareLink, 'watch')}
+                      >
+                        {copied === 'watch' ? t.linkCopied : t.transferCopyLink}
+                      </button>
+                    </>
+                  )}
+                </div>
+              )}
+            </div>
           )}
-          <button className="parent-action-btn" onClick={onExport}>
-            {t.export}
-          </button>
-          <button
-            className="parent-action-btn"
-            onClick={() => setShowImport(!showImport)}
-          >
-            {t.import}
-          </button>
-        </div>
-        {transfer !== 'idle' && (
-          <div className="parent-transfer-area">
-            {transfer === 'loading' && (
-              <p className="parent-transfer-status">{t.transferPreparing}</p>
-            )}
-            {transfer === 'error' && (
-              <p className="parent-transfer-status parent-transfer-status--error">
-                {t.transferError}
-              </p>
-            )}
-            {transferLink && (
+
+          <div className="parent-watch-block">
+            {pair === 'scanning' || pair === 'fetching' ? (
               <>
-                <canvas
-                  ref={qrCanvasRef}
-                  className="parent-transfer-qr"
-                  role="img"
-                  aria-label={t.transferQrAlt}
-                />
-                <p className="parent-transfer-hint">
-                  {t.transferHint(TRANSFER_TTL_MINUTES)}
+                <video ref={scanVideoRef} className="parent-scan-video" />
+                <p className="parent-transfer-status">
+                  {pair === 'fetching' ? t.remoteLoading : t.watchScanPrompt}
                 </p>
+                <button className="parent-action-btn" onClick={() => setPair('idle')}>
+                  {t.cancel}
+                </button>
+              </>
+            ) : (
+              <>
+                {pair === 'cameraError' && (
+                  <p className="parent-transfer-status parent-transfer-status--error">
+                    {t.watchCameraError}
+                  </p>
+                )}
+                {pair === 'linkError' && (
+                  <p className="parent-transfer-status parent-transfer-status--error">
+                    {t.watchLinkError}
+                  </p>
+                )}
+                <div className="parent-actions">
+                  <button className="parent-action-btn" onClick={() => setPair('scanning')}>
+                    {t.watchScanQr}
+                  </button>
+                  <button className="parent-action-btn" onClick={() => setPair('manual')}>
+                    {t.watchPasteLink}
+                  </button>
+                </div>
+              </>
+            )}
+            {pair === 'manual' && (
+              <div className="parent-import-area">
+                <textarea
+                  className="parent-import-textarea"
+                  placeholder={t.watchPastePlaceholder}
+                  value={pairText}
+                  onChange={(e) => setPairText((e.target as HTMLTextAreaElement).value)}
+                />
                 <button
-                  className="parent-action-btn"
-                  onClick={() => copyWithFeedback(transferLink, setTransferCopied)}
+                  className="parent-import-confirm"
+                  disabled={!pairText.trim()}
+                  onClick={async () => {
+                    if (!(await acceptWatchLink(pairText.trim()))) setPair('linkError');
+                    setPairText('');
+                  }}
                 >
-                  {transferCopied ? t.linkCopied : t.transferCopyLink}
+                  {t.watchPasteConfirm}
                 </button>
-              </>
+              </div>
             )}
           </div>
-        )}
-      </div>
+
+          {watched.length > 0 && (
+            <div className="parent-watch-list">
+              {watched.map((w) => (
+                <div key={w.code} className="parent-watch-row">
+                  <span className="parent-watch-name">{w.name}</span>
+                  <button
+                    className="parent-watch-remove"
+                    onClick={() => handleStopWatching(w.code)}
+                  >
+                    {t.watchStopFollowing}
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
 
       <div className="parent-section">
         <h3>{t.helpAndFeedback}</h3>
@@ -512,25 +551,20 @@ export default function ParentDashboard({
           >
             {t.userGuide}
           </a>
-          <button
-            className="parent-action-btn"
-            onClick={() => setShowFeedback(true)}
-          >
+          <button className="parent-action-btn" onClick={() => setShowFeedback(true)}>
             {t.sendFeedback}
           </button>
         </div>
       </div>
 
-      <NotificationSettings />
+      {localSelected && <NotificationSettings />}
 
       <div className="parent-section">
         <h3>{t.shareTablito}</h3>
-        <p className="parent-section-subtitle">
-          {t.shareSubtitle}
-        </p>
+        <p className="parent-section-subtitle">{t.shareSubtitle}</p>
         <div className="parent-actions">
-          <button className="parent-action-btn" onClick={handleShare}>
-            {shareCopied ? t.linkCopied : t.shareApp}
+          <button className="parent-action-btn" onClick={handleShareApp}>
+            {copied === 'app' ? t.linkCopied : t.shareApp}
           </button>
         </div>
       </div>
@@ -542,16 +576,10 @@ export default function ParentDashboard({
       <div className="parent-section">
         <h3>{t.about}</h3>
         <div className="parent-actions">
-          <button
-            className="parent-action-btn"
-            onClick={onShowChangelog}
-          >
+          <button className="parent-action-btn" onClick={onShowChangelog}>
             {t.whatsNew}
           </button>
-          <button
-            className="parent-action-btn"
-            onClick={onShowPrivacy}
-          >
+          <button className="parent-action-btn" onClick={onShowPrivacy}>
             {t.privacy}
           </button>
         </div>
@@ -560,18 +588,22 @@ export default function ParentDashboard({
       <div className="parent-section">
         <h3>{t.profiles}</h3>
         <p className="parent-section-subtitle">
-          {t.profilesSubtitle(profile.name)}
+          {localSelected && profile
+            ? t.profilesSubtitle(profile.name)
+            : t.profilesSubtitleWatcher}
         </p>
         <div className="parent-actions">
           <button className="parent-action-btn" onClick={onAddProfile}>
-            {t.addChild}
-          </button>
-          <button
-            className="parent-action-btn parent-action-btn--danger"
-            onClick={onDeleteProfile}
-          >
-            {t.deleteThisProfile}
+            {profile ? t.addChild : t.createLocalProfile}
           </button>
+          {localSelected && (
+            <button
+              className="parent-action-btn parent-action-btn--danger"
+              onClick={onDeleteProfile}
+            >
+              {t.deleteThisProfile}
+            </button>
+          )}
         </div>
       </div>
 
@@ -581,7 +613,7 @@ export default function ParentDashboard({
             className="parent-import-textarea"
             placeholder={t.pasteJsonHere}
             value={importJson}
-            onChange={(e) => setImportJson(e.target.value)}
+            onChange={(e) => setImportJson((e.target as HTMLTextAreaElement).value)}
           />
           <button
             className="parent-import-confirm"
@@ -597,7 +629,9 @@ export default function ParentDashboard({
         <FeedbackModal profile={profile} onClose={() => setShowFeedback(false)} />
       )}
 
-      <div className="parent-version" aria-label={t.appVersionLabel}>v{import.meta.env.VITE_APP_VERSION}</div>
+      <div className="parent-version" aria-label={t.appVersionLabel}>
+        v{import.meta.env.VITE_APP_VERSION}
+      </div>
     </div>
   );
 }
diff --git a/src/screens/PrivacyScreen.tsx b/src/screens/PrivacyScreen.tsx
index ce57f5d3..03b92b5c 100644
--- a/src/screens/PrivacyScreen.tsx
+++ b/src/screens/PrivacyScreen.tsx
@@ -49,6 +49,11 @@ export default function PrivacyScreen({ onBack }: PrivacyScreenProps) {
           <p>{t.transferBody}</p>
         </section>
 
+        <section className="privacy-section">
+          <h2>{t.watchTitle}</h2>
+          <p>{t.watchBody}</p>
+        </section>
+
         <section className="privacy-section">
           <h2>{t.notCollectedTitle}</h2>
           <ul>
diff --git a/src/screens/WelcomeScreen.css b/src/screens/WelcomeScreen.css
index c4caab39..b012cd9c 100644
--- a/src/screens/WelcomeScreen.css
+++ b/src/screens/WelcomeScreen.css
@@ -253,7 +253,11 @@
 }
 
 /* Scan du QR de transfert (caméra in-app) */
-.welcome-scan-video {
+/* Cadre de la caméra de scan — partagé par les deux appairages par QR
+   (transfert ici, suivi à distance dans l'espace parent). Le build concatène
+   tous les .css en un seul fichier, donc une règle groupée suffit. */
+.welcome-scan-video,
+.parent-scan-video {
   width: min(300px, 78vw);
   aspect-ratio: 1;
   object-fit: cover;
diff --git a/src/screens/WelcomeScreen.tsx b/src/screens/WelcomeScreen.tsx
index 8ca8f9db..5768aacd 100644
--- a/src/screens/WelcomeScreen.tsx
+++ b/src/screens/WelcomeScreen.tsx
@@ -1,8 +1,8 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
-import type QrScanner from 'qr-scanner';
 import type { UserProfile } from '../types';
 import Mascot from '../components/Mascot';
 import NumPad from '../components/NumPad';
+import { useQrScan } from '../hooks/useQrScan';
 import {
   PLACEMENT_FACTS,
   MAX_CONSECUTIVE_FAILURES,
@@ -48,48 +48,23 @@ export default function WelcomeScreen({
   // presse-papiers échoue (refus, navigateur non supporté) ou sur demande.
   const [manualPaste, setManualPaste] = useState(false);
   const [scan, setScan] = useState<ScanState>('off');
-  const scanVideoRef = useRef<HTMLVideoElement>(null);
 
-  // Scan du QR de transfert affiché par l'ancien appareil. La caméra tourne
-  // tant que `scan === 'on'` ; qr-scanner (vendoré) est chargé à la demande.
-  // On ignore les QR étrangers (l'utilisateur vise peut-être encore à côté)
-  // et on ne consomme le code — lecture unique côté serveur — qu'une fois le
-  // scanner arrêté.
-  useEffect(() => {
-    if (scan !== 'on') return;
-    let scanner: QrScanner | null = null;
-    let cancelled = false;
-    (async () => {
-      try {
-        const [{ default: QrScanner }, transfer] = await Promise.all([
-          import('qr-scanner'),
-          import('../lib/transfer'),
-        ]);
-        if (cancelled || !scanVideoRef.current) return;
-        const qr = new QrScanner(
-          scanVideoRef.current,
-          async ({ data }) => {
-            if (!transfer.parseTransferLink(data)) return;
-            qr.stop();
-            setScan('fetching');
-            const profile = await transfer.importTransferFromLink(data);
-            if (profile) onTransferImported(profile);
-            else setScan('transferError');
-          },
-          { returnDetailedScanResult: true },
-        );
-        scanner = qr;
-        await qr.start();
-      } catch {
-        // Caméra absente, refusée, ou lib introuvable → repli sur le collage.
-        if (!cancelled) setScan('cameraError');
-      }
-    })();
-    return () => {
-      cancelled = true;
-      scanner?.destroy(); // destroy() arrête aussi la caméra
-    };
-  }, [scan, onTransferImported]);
+  // Scan du QR de transfert affiché par l'ancien appareil. On ignore les QR
+  // étrangers, et on ne consomme le code — lecture unique côté serveur —
+  // qu'après avoir reconnu un lien de transfert.
+  const scanVideoRef = useQrScan({
+    active: scan === 'on',
+    onCode: async (data) => {
+      const transfer = await import('../lib/transfer');
+      if (!transfer.parseTransferLink(data)) return false;
+      setScan('fetching');
+      const profile = await transfer.importTransferFromLink(data);
+      if (profile) onTransferImported(profile);
+      else setScan('transferError');
+      return true;
+    },
+    onCameraError: () => setScan('cameraError'), // → repli sur le collage
+  });
 
   const { speak, stop: stopSpeech } = useTTS();
 
diff --git a/supabase/watches.sql b/supabase/watches.sql
new file mode 100644
index 00000000..5bd910c1
--- /dev/null
+++ b/supabase/watches.sql
@@ -0,0 +1,117 @@
+-- Schéma de référence de la table `watches` (suivi à distance d'un profil
+-- depuis l'appareil d'un parent).
+--
+-- ⚠ Ce projet n'a PAS de système de migrations : la DDL est appliquée à la main
+-- sur l'instance Supabase (comme `feedback`, `push_subscriptions` et
+-- `transfers`). Ce fichier documente l'état canonique pour la reproductibilité.
+--
+-- Application manuelle :
+--   psql "$SUPABASE_DB_URL" -f supabase/watches.sql
+-- (idempotent : create table if not exists + create or replace function)
+--
+-- Fonctionnement (cf. src/lib/watch.ts) :
+--   - L'appareil de l'enfant chiffre un instantané de son profil CÔTÉ CLIENT
+--     (AES-GCM, même primitive que `transfers`) et le dépose sous un code haute
+--     entropie, rafraîchi après chaque séance. Le serveur ne voit jamais ni la
+--     clé ni le contenu en clair.
+--   - L'appareil du parent a scanné une fois un QR `#watch=<code>.<clé>` : le
+--     code sert à relire le blob, la clé (restée dans le fragment d'URL, jamais
+--     envoyée au serveur) à le déchiffrer.
+--
+-- Différence essentielle avec `transfers`, qui justifie une table séparée :
+-- ici le dépôt est DURABLE et la lecture NON CONSOMMANTE (un transfert vit
+-- 15 minutes et s'efface en étant lu). Le code est donc une capacité
+-- permanente : qui l'obtient peut relire la progression de l'enfant jusqu'à
+-- révocation. Garde-fous retenus — 96 bits d'entropie (inénumérable), clé
+-- jamais exposée au serveur (un dump de la base ne donne rien de lisible),
+-- révocation explicite côté enfant (revoke_watch), purge des suivis morts.
+--
+-- Note d'intégrité assumée : `publish_watch` et `revoke_watch` n'exigent que le
+-- code, donc le parent qui suit peut techniquement écraser ou supprimer
+-- l'instantané qu'il lit. On ne sépare pas la capacité d'écriture de celle de
+-- lecture (ce qui demanderait un secret d'écriture supplémentaire dans le
+-- publieur) : l'impact se limite à un instantané corrompu ou absent, que la
+-- séance suivante de l'enfant réécrit. Aucune confidentialité en jeu.
+--
+-- Sécurité : RLS activée SANS policy → aucun accès direct PostgREST avec la
+-- clé publishable (ni SELECT, ni INSERT : pas d'énumération, pas de dump).
+-- Toute interaction passe par les fonctions SECURITY DEFINER ci-dessous.
+
+create table if not exists public.watches (
+  code       text primary key,            -- généré client, base64url ≥ 16 chars (96+ bits)
+  payload    text not null,               -- profil gzip → AES-GCM → base64 (opaque)
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+
+-- La purge ci-dessous filtre sur updated_at à chaque dépôt. Contrairement à
+-- `transfers` (vide par construction, TTL 15 min), cette table est durable et
+-- grandit avec le parc installé : sans index, chaque séance de chaque appareil
+-- déclencherait un seq scan.
+create index if not exists watches_updated_at_idx on public.watches (updated_at);
+
+alter table public.watches enable row level security;
+-- (pas de policy : la table n'est accessible que via les RPC ci-dessous)
+
+-- Dépose ou rafraîchit l'instantané d'un suivi. Bornes identiques à
+-- create_transfer : code non devinable, payload majoré (un profil gzip+base64
+-- réel pèse < 200 KB).
+create or replace function public.publish_watch(p_code text, p_payload text)
+returns void
+language plpgsql
+security definer
+set search_path = public
+as $$
+begin
+  if length(p_code) < 16 or length(p_code) > 64 then
+    raise exception 'invalid code';
+  end if;
+  if length(p_payload) < 1 or length(p_payload) > 1000000 then
+    raise exception 'invalid payload';
+  end if;
+  -- Purge des suivis morts : plus aucun dépôt depuis 6 mois = app désinstallée
+  -- ou profil supprimé sans passer par « Ne plus partager ». On ne conserve pas
+  -- de blob orphelin indéfiniment.
+  delete from public.watches where updated_at < now() - interval '180 days';
+  insert into public.watches (code, payload) values (p_code, p_payload)
+  on conflict (code) do update
+    set payload = excluded.payload,
+        updated_at = now();
+end;
+$$;
+
+revoke all on function public.publish_watch(text, text) from public;
+grant execute on function public.publish_watch(text, text) to anon, authenticated;
+
+-- Relit un instantané SANS le consommer (à l'inverse de read_transfer). Renvoie
+-- aussi la date du dernier dépôt, que l'espace parent affiche en fraîcheur
+-- (« synchronisé il y a 2 h ») : sans elle, un appareil enfant éteint depuis
+-- une semaine afficherait des stats périmées sans le dire. NULL si code inconnu.
+create or replace function public.read_watch(p_code text)
+returns jsonb
+language sql
+security definer
+set search_path = public
+as $$
+  select jsonb_build_object('payload', payload, 'updated_at', updated_at)
+    from public.watches
+   where code = p_code;
+$$;
+
+revoke all on function public.read_watch(text) from public;
+grant execute on function public.read_watch(text) to anon, authenticated;
+
+-- Révocation (« Ne plus partager » côté enfant) : supprime la ligne. Les
+-- appareils suiveurs verront la lecture renvoyer NULL et signaleront que le
+-- partage a été arrêté.
+create or replace function public.revoke_watch(p_code text)
+returns void
+language sql
+security definer
+set search_path = public
+as $$
+  delete from public.watches where code = p_code;
+$$;
+
+revoke all on function public.revoke_watch(text) from public;
+grant execute on function public.revoke_watch(text) to anon, authenticated;