Add the plant expert: reference base, diagnosis and questions

- Reference base of 170 common plants (houseplants, balcony, herbs): names
  checked against Wikidata, toxicity from the ASPCA lists. Known species get
  their figures from the base and Gemma only writes the advice.
- One shared expert for scan, sheet, diagnosis and chat, given the plant's
  context (species, sheet, recent care, room, season).
- Health diagnosis from a close-up photo, kept with its photo in a Health
  section, with a one-tap watering interval change.
- "Demande à Plantule": per-plant conversation, streamed as it is written.
- Migration 3: diagnoses and chat_messages tables.

Claude-Session: https://claude.ai/code/session_01Jg25nsPfSVmrDW93LK1Wby

Author: lxwiq

README.md

@@ -14,13 +14,16 @@ Tout reste sur le téléphone : pas de compte, pas de serveur. Les données sont
 - **Journal** : tout ce qui a été fait ou reporté, par plante.
 - **Résumé quotidien** : une notification locale par jour, à l'heure choisie.
 - **Scan** : on photographie une plante, Gemma 4 E2B propose l'espèce, puis rédige sa fiche d'entretien et les soins à programmer. Le modèle tourne sur le téléphone : il se télécharge une fois (2,6 Go, en Wi-Fi) et aucune photo ne sort du téléphone. Il faut un téléphone Android avec 6 Go de RAM. Voir [docs/ai-engine.md](docs/ai-engine.md).
+- **Base de référence** : 170 plantes courantes (intérieur, balcon, aromatiques) embarquées dans l’app : noms vérifiés sur Wikidata, toxicité d’après l’ASPCA, et des chiffres d’entretien fixés à l’avance. Pour une espèce connue, la fiche prend ses chiffres dans la base et Gemma n’écrit que les conseils : elle est plus rapide et plus juste. La fiche l’indique par « Données vérifiées ».
+- **Diagnostic** : une photo de près de ce qui inquiète, et Gemma donne l’état de la plante (saine, à surveiller, à soigner), jusqu’à 3 pistes avec quoi faire, en tenant compte des derniers arrosages, de la pièce et de la saison. Si l’arrosage est en cause, l’app propose de changer l’intervalle en un clic. Les diagnostics sont gardés avec leur photo dans la section Santé de la plante.
+- **Demande à Plantule** : poser ses questions sur une plante, avec la réponse qui s’écrit au fil de l’eau. La conversation est gardée pour chaque plante.
 
 ## Développer
 
 ```bash
 npm install
 npx expo start      # puis « a » pour Android (Expo Go ou émulateur)
-npm test            # tests unitaires (règles de récurrence, dates, résumé)
+npm test            # tests unitaires (règles, dates, fiche, diagnostic, base de référence)
 npx tsc --noEmit    # typecheck
 npx expo lint       # lint
 ```
@@ -31,10 +34,11 @@ Structure :
 
 ```
 src/app/            écrans (Expo Router)
-src/ai/             modèle sur le téléphone (téléchargement, exécution) et questions du scan
+src/ai/             modèle sur le téléphone (téléchargement, exécution) et questions posées à l’expert (scan, fiche, diagnostic, conversation)
 src/components/     composants, dont le design system dans components/ui
+src/data/           base de référence des plantes (chiffres d’entretien, toxicité)
 src/db/             base SQLite : schéma et migrations, requêtes, hooks réactifs
-src/lib/            règles de récurrence, dates, libellés, fiche espèce et sa validation
+src/lib/            règles de récurrence, dates, libellés, fiche espèce, diagnostic et leur validation
 src/notifications/  résumé quotidien
 src/theme/          couleurs, typographie, espacements (clair et sombre)
 ```

docs/ROADMAP.md

@@ -1,6 +1,6 @@
 # Moteur IA sur le téléphone
 
-Décision du 23/09/2026 pour la phase 2 (scan). Code : `src/ai/engine.ts` et `src/ai/model-*.ts`, derrière le contrat `src/ai/types.ts`.
+Décision du 23/09/2026 pour la phase 2 (scan). Code : `src/ai/engine.ts` et `src/ai/model-*.ts`, derrière le contrat `src/ai/types.ts`. Ce qu’on demande au modèle (scan, fiche, diagnostic, questions) est dans `src/ai/plant-ai.ts` ; la base de référence dans `src/data/plants.ts` (voir plus bas).
 
 ## Choix
 
@@ -49,8 +49,48 @@ L'app exige **6 Go de RAM** (seuil technique : `Device.totalMemory` ≥ 5 Go, un
 - Température 0,3 par défaut, topK 64, topP 0,95, « thinking » désactivé.
 - Photo redimensionnée à 1024 px de côté au plus, en JPEG.
 - `jsonSchema` passé à LLGuidance. Si le moteur refuse le schéma, la demande est relancée sans contrainte (la réponse est de toute façon validée par l'appelant).
+- Réponse au fil de l’eau : avec `onText`, le moteur écrit la réponse morceau par morceau (`execute(parts, onToken, options)`) et `onText` reçoit tout le texte déjà écrit, au plus toutes les 100 ms, puis le texte final (`src/ai/text-stream.ts`). Plus rien n’est envoyé après une annulation.
 - Téléchargement : `DownloadTask` d'expo-file-system (SDK 57) avec progression, annulation et reprise (en-tête `Range`), même après un redémarrage de l'app. Écrit en `.part`, vérifié (taille et en-tête `LITERTLM`) puis renommé. Espace disque vérifié avant (+300 Mo de marge). Refus hors Wi-Fi sauf accord explicite (expo-network).
 
+## L’expert Plantule
+
+Toutes les demandes partagent les mêmes instructions, `EXPERT_SYSTEM` (`src/ai/plant-context.ts`) : un jardinier prudent qui conseille des particuliers en France, en phrases courtes et en tutoyant ; il dit quand il ne sait pas, s’appuie sur les données vérifiées sans inventer d’autres chiffres, et conseille le vétérinaire si un animal a mangé une plante toxique. Les tâches en JSON (identification, fiche, diagnostic) y ajoutent « réponds uniquement avec un objet JSON » ; les questions répondent en texte libre.
+
+Pour le diagnostic et les questions, le modèle reçoit ce que l’app sait de la plante (`buildPlantContext`, `contextText`) : espèce, chiffres de la base (ou de la fiche), problèmes fréquents de la fiche, pièce (nom, intérieur ou dehors, lumière), pot et substrat, mois et saison, rappel d’arrosage (intervalle, retard, « terreau encore humide » de suite), les 8 derniers soins (l’arrosage d’abord) et les notes. Le tout tient en 2 000 caractères au plus, environ 600 jetons : les textes libres sont raccourcis et les soins les plus anciens sautent d’abord.
+
+| Demande | Instructions + contexte | Image | Réponse (max) |
+|---|---|---|---|
+| Identification | ~650 jetons | ~280 | 600 |
+| Fiche d’une espèce de la base | ~650 | — | 1 000 |
+| Fiche complète (espèce inconnue) | ~850 | — | 1 400 |
+| Diagnostic | ~1 350 | ~280 | 900 |
+| Question | ~1 700 (dont 6 messages) | — | 400 |
+
+Une nouvelle tentative ajoute la réponse précédente (1 500 caractères au plus) et les erreurs : le diagnostic reste vers 3 000 jetons sur 4 096.
+
+## Base de référence
+
+`src/data/plants.ts` : **170 plantes** (109 d’intérieur, 42 de balcon et de terrasse, 19 aromatiques), avec noms latins et français, lumière, arrosage (intervalle et facteur d’hiver), humidité, températures supportées, toxicité pour les chats et les chiens, engrais, brumisation et rempotage. Recherche (`findReference`) sans tenir compte de la casse, des accents, du signe d’hybride, d’un cultivar entre guillemets, de « spp. », d’un article ou d’un pluriel ; jamais sur un genre seul (« Ficus alii » n’est pas le Ficus benjamina).
+
+Utilisation :
+
+- **Identification** : chaque candidat est relié à la base (`reference_id`), par son nom latin, ou par son nom commun si le genre concorde. Il prend alors le nom latin de la base, et son premier nom commun si celui du modèle n’y figure pas.
+- **Fiche** : pour une espèce de la base, les chiffres viennent de la base et Gemma n’écrit que les textes (conseils d’arrosage et de rempotage, substrat, pot, bouturage, problèmes, astuces), avec les faits de la base dans la demande et la consigne de ne pas écrire d’autres chiffres. La fiche a `reference_id` et est enregistrée avec la source `reference`. Sinon, Gemma écrit toute la fiche, comme avant.
+- **Diagnostic et questions** : les chiffres de la base font partie du contexte de la plante.
+
+D’où viennent les données, et sous quelle licence :
+
+- **Noms** : chaque nom latin vérifié sur **Wikidata** (licence CC0, domaine public), dont l’identifiant est dans `sources`. Wikidata a aussi fourni une partie des noms français. Pour quelques plantes vendues sous un ancien nom (Echinocactus grusonii, Osteospermum, Schefflera, Dracaena marginata), c’est ce nom qui est gardé et le nom accepté va dans les synonymes.
+- **Toxicité** : les listes de l’**ASPCA** (Animal Poison Control Center) pour les chats et les chiens, vérifiées par script pour chaque plante (espèce, ou genre quand l’espèce n’y est pas), avec le lien dans `sources`. On n’en garde que le fait (toxique ou non), pas le texte. Une plante absente des listes est « inconnue », sauf quatre plantes irritantes gardées « toxiques » par prudence (Rhaphidophora, Zamioculcas, croton, agave), commentées dans le fichier.
+- **Chiffres d’entretien** (lumière, arrosage, humidité, températures, engrais, brumisation, rempotage) : écrits par nous pour la culture en pot en France, à partir des conseils horticoles courants, et marqués `Plantule` dans `sources`. Aucune source ouverte trouvée pour ces chiffres : FloraDB (échantillon en CC BY-NC), Open Plantbook (compte obligatoire, plages de capteurs plutôt que des rythmes), OpenPlantDB (CC0 mais cultures potagères des États-Unis). Ce sont des repères de départ : chaque plante les ajuste ensuite (« terreau encore humide », diagnostic).
+
+Les tests (`src/lib/plant-reference.test.ts`) vérifient au moins 150 plantes, des identifiants et des noms uniques, qu’aucun nom ne désigne deux plantes, des intervalles entre 1 et 730 jours, un facteur d’hiver parmi 1, 1,5, 2 et 3, un minimum de température inférieur au maximum, et une source pour chaque toxicité connue.
+
+## Diagnostic et questions
+
+- **Diagnostic** (`diagnosePlant`) : la photo et le contexte de la plante dans le même appel. Le modèle liste d’abord jusqu’à 3 problèmes (nom, type, confiance, signes, actions), puis l’état, le résumé et les changements d’arrosage et de lumière. La demande insiste sur trop d’eau ou pas assez, d’après les derniers arrosages et les « terreau encore humide », et sur ce que la photo ne montre pas (racines, petits parasites). Validation stricte (`validateDiagnosis`) avec 2 nouvelles tentatives ; à la relecture d’un diagnostic enregistré, la validation est indulgente. `suggestedWateringInterval` propose ×1,3 pour « moins d’eau » et ×0,75 pour « plus », d’au moins un jour, entre 1 et 730.
+- **Questions** (`askPlant`) : contexte de la plante, les 6 derniers messages raccourcis à 400 caractères, puis la question. Réponse courte en texte libre, envoyée au fil de l’eau par `onText`, sans nouvelle tentative.
+
 ## Limites connues
 
 - **Pas d'arrêt en cours de génération** : la 0.7.0 n'expose pas `cancelProcess()` (corrigé sur la branche principale de la lib, pas encore publié). `signal` rejette tout de suite, mais le calcul continue en arrière-plan jusqu'à la fin de la réponse et la demande suivante attend.
@@ -64,4 +104,4 @@ L'app exige **6 Go de RAM** (seuil technique : `Device.totalMemory` ≥ 5 Go, un
 
 ## À mesurer sur un vrai téléphone
 
-Temps de chargement, temps d'une identification avec photo, RAM, repli CPU/GPU, justesse sur nos plantes (et comparaison avec Pl@ntNet).
+Temps de chargement, temps d'une identification avec photo, RAM, repli CPU/GPU, justesse sur nos plantes (et comparaison avec Pl@ntNet). Et depuis la phase 3 : le temps d’un diagnostic, le rythme de la réponse au fil de l’eau, la justesse du diagnostic sur des plantes vraiment malades, et le temps d’une fiche d’espèce connue (texte seul) comparé à une fiche complète.

docs/ai-engine.md

@@ -1,19 +1,30 @@
 /**
  * A pretend model for development (browser, Expo Go), turned on with
  * EXPO_PUBLIC_FAKE_AI=1. It answers like the real one would, after a short
- * delay: a Monstera with two look-alikes for any photo (in a terracotta pot
- * that needs repotting), and a care sheet for the species named in the
- * prompt. Deleting it from the model card and downloading it again shows the
- * "not ready" states.
+ * delay:
+ * - a scan photo: a Monstera with two look-alikes (in a terracotta pot that
+ *   needs repotting);
+ * - a diagnosis photo: in turn a plant to treat (too much water, with a
+ *   longer watering interval), one to watch (not enough light) and a healthy
+ *   one;
+ * - a sheet: the whole sheet for the species named in the prompt, or its
+ *   texts only for a species of the reference base (the app adds the base's
+ *   figures);
+ * - a question: a short answer written word by word through `onText`.
+ * Deleting it from the model card and downloading it again shows the "not
+ * ready" states.
  */
 
 import type { CareSheet } from '@/lib/care-sheet';
+import type { Diagnosis } from '@/lib/diagnosis';
 import type { Identification } from '@/lib/identification';
 
 import type { AiEngine, GenerateRequest, ModelStatus } from './types';
 
 const SIZE_BYTES = 2_600_000_000;
 const ANSWER_DELAY_MS = 1500;
+/** A chat answer is written a word at a time, about ten words a second. */
+const WORD_DELAY_MS = 90;
 
 let status: ModelStatus = { state: 'ready', sizeBytes: SIZE_BYTES };
 const listeners = new Set<() => void>();
@@ -99,6 +110,7 @@ const SHEETS: CareSheet[] = [
       'Dépoussière ses grandes feuilles avec un chiffon humide.',
       'Évite le soleil direct de l’après-midi, qui brûle les feuilles.',
     ],
+    reference_id: null,
   },
   {
     common_name: 'Philodendron selloum',
@@ -137,6 +149,7 @@ const SHEETS: CareSheet[] = [
       'Il prend vite de la place : prévois-lui un coin spacieux.',
       'Tourne le pot d’un quart de tour chaque mois pour qu’il pousse droit.',
     ],
+    reference_id: null,
   },
   {
     common_name: 'Mini monstera',
@@ -180,6 +193,7 @@ const SHEETS: CareSheet[] = [
       'Grimpante : donne-lui un tuteur ou laisse-la retomber d’une étagère.',
       'Une salle de bain lumineuse lui convient très bien.',
     ],
+    reference_id: null,
   },
 ];
 
@@ -223,11 +237,122 @@ function genericSheet(name: string): CareSheet {
       'Place-la près d’une fenêtre, sans soleil brûlant.',
       'Réduis les arrosages en hiver, quand elle pousse moins.',
     ],
+    reference_id: null,
   };
 }
 
-function answer(request: GenerateRequest): string {
-  if (request.imageUri) return JSON.stringify(IDENTIFICATION);
+const DIAGNOSES: Diagnosis[] = [
+  {
+    status: 'treat',
+    summary:
+      'Les feuilles jaunes et molles, avec un terreau souvent encore humide, font penser à trop d’eau. Ce sont des pistes à vérifier.',
+    problems: [
+      {
+        name: 'Excès d’arrosage',
+        kind: 'care',
+        confidence: 0.7,
+        signs: 'Feuilles du bas jaunes et molles, terreau encore humide plusieurs fois de suite.',
+        actions: [
+          'Laisse sécher le terreau sur 3 cm avant d’arroser.',
+          'Vide la soucoupe après chaque arrosage.',
+          'Vérifie que le pot est bien percé.',
+        ],
+      },
+      {
+        name: 'Pourriture des racines',
+        kind: 'disease',
+        confidence: 0.3,
+        signs: 'La base des tiges paraît sombre.',
+        actions: ['Dépote-la et coupe les racines brunes et molles.', 'Rempote dans un terreau sec et drainant.'],
+      },
+    ],
+    watering_change: 'less',
+    light_change: 'none',
+  },
+  {
+    status: 'watch',
+    summary: 'Elle s’étire vers la lumière : rien de grave, mais elle serait mieux plus près d’une fenêtre.',
+    problems: [
+      {
+        name: 'Manque de lumière',
+        kind: 'environment',
+        confidence: 0.6,
+        signs: 'Tiges longues et nouvelles feuilles plus petites.',
+        actions: ['Rapproche-la d’une fenêtre lumineuse, sans soleil brûlant.'],
+      },
+      {
+        name: 'Araignées rouges',
+        kind: 'pest',
+        confidence: 0.2,
+        signs: 'Feuilles un peu ternes.',
+        actions: ['Regarde le dessous des feuilles à la loupe.', 'Douche le feuillage à l’eau tiède.'],
+      },
+    ],
+    watering_change: 'none',
+    light_change: 'more',
+  },
+  {
+    status: 'healthy',
+    summary: 'Elle a l’air en forme : feuilles fermes et bien vertes. Continue comme ça.',
+    problems: [],
+    watering_change: 'none',
+    light_change: 'none',
+  },
+];
+let diagnoses = 0;
+
+const CHAT_ANSWERS: { words: RegExp; answer: string }[] = [
+  {
+    words: /jaun/i,
+    answer:
+      'Des feuilles qui jaunissent viennent le plus souvent d’un excès d’eau. Touche le terreau : s’il est encore humide à deux doigts de profondeur, attends avant d’arroser et vide la soucoupe. Si seules les vieilles feuilles du bas jaunissent, c’est souvent normal.',
+  },
+  {
+    words: /rempot/i,
+    answer:
+      'Le meilleur moment pour la rempoter, c’est au printemps, de mars à mai. Fais-le quand les racines sortent par le trou du pot. Prends un pot 2 à 3 cm plus large, percé, avec un terreau frais, puis arrose bien.',
+  },
+  {
+    words: /plac|où|lumi|soleil|fenêtre/i,
+    answer:
+      'Mets-la près d’une fenêtre lumineuse, mais sans soleil direct l’après-midi, qui brûle les feuilles. Évite les radiateurs et les courants d’air. Si ses tiges s’étirent, c’est qu’elle manque de lumière.',
+  },
+];
+const CHAT_FALLBACK =
+  'Je ne peux pas te répondre avec certitude sans en savoir plus. Décris-moi ce que tu vois sur la plante, ou fais un diagnostic avec une photo prise de près.';
+
+/** The texts of a sheet, as asked for a species of the reference base. */
+function sheetTexts(sheet: CareSheet) {
+  return {
+    watering_advice: sheet.watering.advice,
+    repotting_advice: sheet.repotting.advice,
+    substrate: sheet.substrate,
+    pot: sheet.pot,
+    propagation: sheet.propagation,
+    problems: sheet.problems,
+    tips: sheet.tips,
+  };
+}
+
+/** Field names the request's JSON Schema asks for. */
+function schemaFields(request: GenerateRequest): readonly string[] {
+  return (request.jsonSchema as { required?: readonly string[] } | undefined)?.required ?? [];
+}
+
+/** The answer, and whether it is free text written word by word. */
+function answer(request: GenerateRequest): { text: string; words: boolean } {
+  const fields = schemaFields(request);
+  if (request.imageUri && fields.includes('status')) {
+    const diagnosis = DIAGNOSES[diagnoses++ % DIAGNOSES.length];
+    return { text: JSON.stringify(diagnosis), words: false };
+  }
+  if (request.imageUri) return { text: JSON.stringify(IDENTIFICATION), words: false };
+  // Questions end the prompt with "Question : …", after the plant's context.
+  const question = request.prompt.match(/^Question : (.+)$/m)?.[1];
+  if (question) {
+    const text = CHAT_ANSWERS.find(({ words }) => words.test(question))?.answer ?? CHAT_FALLBACK;
+    return { text, words: true };
+  }
   // The sheet prompt names the species between « ».
   const name = request.prompt.match(/«\s*([^»]+?)\s*»/)?.[1] ?? 'Plante inconnue';
   const sheet =
@@ -236,10 +361,22 @@ function answer(request: GenerateRequest): string {
         s.scientific_name.toLowerCase() === name.toLowerCase() ||
         s.common_name.toLowerCase() === name.toLowerCase(),
     ) ?? genericSheet(name);
+  if (fields.includes('watering_advice')) return { text: JSON.stringify(sheetTexts(sheet)), words: false };
   // Written as the schema asks (misting 0 for none), wrapped in a code fence
   // as small models like to do.
   const json = JSON.stringify({ ...sheet, misting: sheet.misting ?? { interval_days: 0 } }, null, 2);
-  return `Voici la fiche :\n\`\`\`json\n${json}\n\`\`\``;
+  return { text: `Voici la fiche :\n\`\`\`json\n${json}\n\`\`\``, words: false };
+}
+
+/** Writes `text` a word at a time through `onText`, like the real model streams it. */
+async function writeWords(text: string, { onText, signal }: GenerateRequest): Promise<string> {
+  let written = '';
+  for (const word of text.split(' ')) {
+    await wait(WORD_DELAY_MS, signal);
+    written = written ? `${written} ${word}` : word;
+    onText?.(written);
+  }
+  return written;
 }
 
 export const fakeEngine: AiEngine = {
@@ -283,6 +420,7 @@ export const fakeEngine: AiEngine = {
   async generate(request) {
     if (status.state !== 'ready') throw new Error('Le modèle n’est pas encore téléchargé.');
     await wait(ANSWER_DELAY_MS, request.signal);
-    return answer(request);
+    const reply = answer(request);
+    return reply.words ? writeWords(reply.text, request) : reply.text;
   },
 };