feat(chatbot-pensees): attente progressive, timeout front 95 s et bouton Réessayer

États « Je fouille le corpus… » (0-6 s), « Je rédige… » (6-30 s), « Le corpus est vaste,
encore un instant… » (30 s+), annoncés via une région aria-live persistante ; points
fixes si prefers-reduced-motion. Timeout front 95 s (> 90 s serveur), message d'excuse
et bouton « Réessayer » qui reposte la même question sans dupliquer le message ;
messages humains distincts pour 429 (quota / saturé), 503, 504, réseau. États d'attente
et erreurs non persistés (M2 inchangé), contrat de la route inchangé.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015vcVGz8i4WpZm2dixKUiSD

components/ChatModeBadge.vue

@@ -0,0 +1,21 @@
+<template>
+  <span v-if="profondeur === 'approfondi'" class="chat-mode-badge">{{ CHAT_PROFONDEUR_LIBELLES.approfondi }}</span>
+</template>
+
+<script setup lang="ts">
+// Étiquette sobre sur une réponse donnée en mode approfondi (rien en mode rapide).
+defineProps<{ profondeur?: string }>()
+</script>
+
+<style scoped>
+.chat-mode-badge {
+  display: inline-block;
+  margin-bottom: 6px;
+  padding: 1px 8px;
+  border-radius: 9999px;
+  border: 1px solid var(--nav-bg-alt);
+  font-size: 0.66rem;
+  font-family: var(--nav-font);
+  color: var(--nav-text-muted);
+}
+</style>

components/ChatModeToggle.vue

@@ -0,0 +1,80 @@
+<template>
+  <div class="chat-mode" role="radiogroup" aria-label="Mode de réponse">
+    <button
+      v-for="(p, i) in CHAT_PROFONDEURS"
+      :key="p"
+      :ref="(el) => (boutons[i] = el as HTMLButtonElement | null)"
+      type="button"
+      role="radio"
+      class="chat-mode-option"
+      :class="{ active: modelValue === p }"
+      :aria-checked="modelValue === p"
+      :tabindex="modelValue === p ? 0 : -1"
+      :title="CHAT_PROFONDEUR_AIDES[p]"
+      :disabled="disabled"
+      @click="choisir(p)"
+      @keydown="onKey($event, i)"
+    >{{ CHAT_PROFONDEUR_LIBELLES[p] }}</button>
+  </div>
+</template>
+
+<script setup lang="ts">
+// Toggle 2 options partagé par les 5 chatbots. Libellés : utils/chatProfondeur.ts.
+// radiogroup : flèches déplacent la sélection, Tab entre/sort du groupe (roving tabindex).
+const props = defineProps<{ modelValue: 'rapide' | 'approfondi'; disabled?: boolean }>()
+const emit = defineEmits<{ 'update:modelValue': [value: 'rapide' | 'approfondi'] }>()
+
+const boutons = ref<(HTMLButtonElement | null)[]>([])
+
+function choisir(p: ChatProfondeur) {
+  if (!props.disabled) emit('update:modelValue', p)
+}
+
+function onKey(e: KeyboardEvent, i: number) {
+  const n = CHAT_PROFONDEURS.length
+  let j = -1
+  if (e.key === 'ArrowRight' || e.key === 'ArrowDown') j = (i + 1) % n
+  else if (e.key === 'ArrowLeft' || e.key === 'ArrowUp') j = (i - 1 + n) % n
+  else if (e.key === 'Home') j = 0
+  else if (e.key === 'End') j = n - 1
+  if (j < 0) return
+  e.preventDefault()
+  choisir(CHAT_PROFONDEURS[j])
+  nextTick(() => boutons.value[j]?.focus())
+}
+</script>
+
+<style scoped>
+.chat-mode {
+  display: inline-flex;
+  gap: 2px;
+  padding: 2px;
+  border-radius: 9999px;
+  background: var(--nav-bg-alt);
+  align-self: flex-start;
+}
+.chat-mode-option {
+  border: none;
+  background: transparent;
+  color: var(--nav-text-muted);
+  font-family: var(--nav-font);
+  font-size: 0.72rem;
+  line-height: 1.2;
+  padding: 4px 10px;
+  border-radius: 9999px;
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+.chat-mode-option:hover:not(.active):not(:disabled) { color: var(--nav-text); }
+.chat-mode-option.active {
+  background: var(--nav-primary);
+  color: var(--nav-text-on-primary);
+  font-weight: 600;
+}
+.chat-mode-option:focus-visible { outline: 2px solid var(--nav-primary); outline-offset: 2px; }
+.chat-mode-option:disabled { opacity: 0.5; cursor: not-allowed; }
+
+@media (prefers-reduced-motion: reduce) {
+  .chat-mode-option { transition: none; }
+}
+</style>

components/ChatNewConversation.vue

@@ -0,0 +1,30 @@
+<template>
+  <button type="button" class="chat-new-conversation" @click="emit('reset')">
+    Nouvelle conversation
+  </button>
+</template>
+
+<script setup lang="ts">
+// Bouton sobre « Nouvelle conversation », partagé par les chatbots.
+// Le parent le rend seulement s'il y a un historique et gère la purge.
+const emit = defineEmits<{ reset: [] }>()
+</script>
+
+<style scoped>
+.chat-new-conversation {
+  align-self: flex-end;
+  flex-shrink: 0;
+  background: transparent;
+  border: none;
+  padding: 4px 6px;
+  border-radius: 6px;
+  font-size: 0.72rem;
+  font-family: var(--nav-font);
+  color: var(--nav-text-muted);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+  cursor: pointer;
+}
+.chat-new-conversation:hover { color: var(--nav-text); background: var(--nav-bg-alt); }
+.chat-new-conversation:focus-visible { outline: 2px solid var(--nav-primary); outline-offset: 2px; }
+</style>

components/ChatbotPensees.vue

@@ -16,16 +16,6 @@
         <span v-else class="chatbot-corpus-badge">FRACAS</span>
       </div>
       <div class="chatbot-header-right">
-        <button
-          v-if="messages.length > 0"
-          class="chatbot-clear-btn"
-          title="Effacer la conversation"
-          @click="clearMessages"
-        >
-          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" aria-hidden="true">
-            <polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/>
-          </svg>
-        </button>
         <select v-model="corpusMode" class="chatbot-corpus-select" title="Corpus interrogé">
           <option value="pensees">Pensées éco.</option>
           <option value="both">Pensées + Projets</option>
@@ -52,6 +42,7 @@
       <template v-for="(msg, i) in messages" :key="i">
         <div v-if="msg.role === 'user'" class="chatbot-bubble user">{{ msg.content }}</div>
         <div v-else class="chatbot-bubble assistant">
+          <ChatModeBadge :profondeur="msg.profondeur" />
           <div class="chatbot-md" v-html="renderMd(msg.content)" />
           <div v-if="msg.auteur" class="chatbot-auteur-tag">
             <span>{{ msg.auteur.nom }}</span>
@@ -59,13 +50,26 @@
         </div>
       </template>
 
-      <!-- Chargement -->
+      <!-- Chargement : texte d'attente progressif. L'annonce aux lecteurs d'écran passe par la région
-      <div v-if="loading" class="chatbot-bubble assistant loading">
+           live persistante ci-dessous (une région insérée à chaud n'est pas fiablement annoncée). -->
+      <div v-if="loading" class="chatbot-bubble assistant loading" aria-hidden="true">
         <span class="dot" /><span class="dot" /><span class="dot" />
+        <span class="attente-texte">{{ attenteTexte }}</span>
       </div>
+      <div class="sr-only" role="status" aria-live="polite" aria-atomic="true">{{ loading ? attenteTexte : '' }}</div>
 
       <!-- Erreur -->
-      <div v-if="errorMsg" class="chatbot-error">{{ errorMsg }}</div>
+      <div v-if="errorMsg" class="chatbot-error" role="alert">
+        <span>{{ errorMsg }}</span>
+        <button v-if="peutReessayer" type="button" class="chatbot-retry-btn" @click="reessayer">Réessayer</button>
+      </div>
+
+      <ChatNewConversation v-if="hasHistory && !loading" @reset="clearMessages" />
+    </div>
+
+    <!-- Mode de réponse -->
+    <div class="chatbot-mode-row">
+      <ChatModeToggle v-model="profondeur" :disabled="loading" />
     </div>
 
     <!-- Input -->
@@ -102,6 +106,7 @@ interface ChatMessage {
   role: 'user' | 'assistant'
   content: string
   auteur?: { slug: string; nom: string } | null
+  profondeur?: string
 }
 
 const props = defineProps<{
@@ -109,21 +114,78 @@ const props = defineProps<{
   inline?: boolean
 }>()
 
-const messages = ref<ChatMessage[]>([])
+// Une conversation par contexte (corpus général ou un auteur) : changer d'auteur
+// ne mélange pas les historiques, et un rechargement restaure le bon.
+const sessionKey = computed(() => props.auteurContext ? `pensees-${slugify(props.auteurContext)}` : 'pensees')
+const { messages, hasHistory, clear } = useChatSession<ChatMessage>(sessionKey)
+// `profondeur` (et non `mode`, réservé au mode de recherche LightRAG côté serveur)
+const profondeur = useChatProfondeur('pensees')
 const inputText = ref('')
 const loading = ref(false)
 const errorMsg = ref('')
 const corpusMode = ref<'pensees' | 'projets' | 'both'>('pensees')
 const messagesContainer = ref<HTMLElement | null>(null)
 
-watch(() => props.auteurContext, () => {
+// --- Attente et erreurs : état d'interface uniquement, jamais persisté (hors useChatSession) ---
-  messages.value = []
+// Mesuré le 09/10 : récupération 2-5 s, génération 10-18 s, 19-29 s bout en bout. Les seuils suivent ces
+// phases ; le texte est une minuterie (le serveur renvoie tout d'un bloc : il faut la réponse complète
+// pour vérifier les citations, donc pas de flux de texte).
+const SEUIL_REDIGE_S = 6
+const SEUIL_LONG_S = 30
+// Au-delà du timeout serveur (90 s) : le front ne lâche jamais avant la route, et ne tourne jamais sans fin.
+const TIMEOUT_FRONT_MS = 95000
+
+const attenteS = ref(0)
+const attenteTexte = computed(() => {
+  if (attenteS.value >= SEUIL_LONG_S) return 'Le corpus est vaste, encore un instant…'
+  if (attenteS.value >= SEUIL_REDIGE_S) return 'Je rédige…'
+  return 'Je fouille le corpus…'
+})
+let attenteTimer: ReturnType<typeof setInterval> | null = null
+
+function demarrerAttente() {
+  arreterAttente()
+  attenteS.value = 0
+  const t0 = Date.now()
+  attenteTimer = setInterval(() => { attenteS.value = Math.floor((Date.now() - t0) / 1000) }, 1000)
+}
+function arreterAttente() {
+  if (attenteTimer) { clearInterval(attenteTimer); attenteTimer = null }
+}
+onBeforeUnmount(arreterAttente)
+
+interface Envoi { query: string; profondeur: string; corpus: string; auteurSlug?: string }
+const dernierEnvoi = ref<Envoi | null>(null)
+const peutReessayer = ref(false)
+
+watch(sessionKey, () => {
   errorMsg.value = ''
+  peutReessayer.value = false
+  dernierEnvoi.value = null
 })
 
 function clearMessages() {
-  messages.value = []
+  clear()
   errorMsg.value = ''
+  peutReessayer.value = false
+  dernierEnvoi.value = null
+}
+
+function messageErreur(e: any): { texte: string; reessayer: boolean } {
+  const status = e?.statusCode ?? e?.status ?? e?.response?.status
+  const detail = String(e?.data?.message ?? e?.statusMessage ?? e?.message ?? '')
+  if (status === 429) {
+    // 429 de la route : quota du jour (pas de réessai utile) ou RAG saturé (réessai possible)
+    if (/satur/i.test(detail)) return { texte: 'Le corpus est très sollicité en ce moment. Patiente quelques secondes, puis réessaie.', reessayer: true }
+    return { texte: 'Tu as atteint la limite de 20 questions par jour. Reviens demain, ou explore les fiches auteurs en attendant.', reessayer: false }
+  }
+  if (status === 503) return { texte: 'La bibliothèque est indisponible pour l\'instant. Réessaie dans quelques minutes.', reessayer: true }
+  if (status === 504) return { texte: 'La bibliothèque met trop de temps à répondre : la question est peut-être trop large. Réessaie, ou reformule-la plus précisément.', reessayer: true }
+  if (!status && /timeout|timed out|abort/i.test(`${detail} ${e?.name ?? ''} ${e?.cause?.name ?? ''}`)) {
+    return { texte: 'Désolé, la réponse met plus de temps que prévu et n\'a pas abouti. Tu peux relancer la même question.', reessayer: true }
+  }
+  if (!status) return { texte: 'La connexion semble coupée : la question n\'est pas partie. Vérifie ton réseau puis réessaie.', reessayer: true }
+  return { texte: 'Une erreur est survenue. Réessaie dans quelques instants.', reessayer: true }
 }
 
 function scrollToBottom() {
@@ -137,9 +199,27 @@ async function sendMessage() {
   if (!query || loading.value) return
 
   inputText.value = ''
-  errorMsg.value = ''
   messages.value.push({ role: 'user', content: query })
+  await envoyer({
+    query,
+    profondeur: profondeur.value,
+    corpus: corpusMode.value,
+    auteurSlug: props.auteurContext ? slugify(props.auteurContext) : undefined,
+  })
+}
+
+// Reposte la même question (même mode, même corpus) sans dupliquer le message de l'usager.
+async function reessayer() {
+  if (!dernierEnvoi.value || loading.value) return
+  await envoyer(dernierEnvoi.value)
+}
+
+async function envoyer(envoi: Envoi) {
+  errorMsg.value = ''
+  peutReessayer.value = false
+  dernierEnvoi.value = envoi
   loading.value = true
+  demarrerAttente()
 
   await nextTick()
   scrollToBottom()
@@ -150,29 +230,27 @@ async function sendMessage() {
       auteur: { slug: string; nom: string } | null
     }>('/api/chatbot-pensees', {
       method: 'POST',
+      timeout: TIMEOUT_FRONT_MS,
       body: {
-        query,
+        query: envoi.query,
-        corpus: corpusMode.value,
+        corpus: envoi.corpus,
-        auteur_slug: props.auteurContext ? slugify(props.auteurContext) : undefined,
+        profondeur: envoi.profondeur,
+        auteur_slug: envoi.auteurSlug,
       },
     })
     messages.value.push({
       role: 'assistant',
       content: res.response,
       auteur: res.auteur ?? null,
+      profondeur: envoi.profondeur,
     })
+    dernierEnvoi.value = null
   } catch (e: any) {
-    const status = e?.statusCode ?? e?.status
+    const { texte, reessayer: ok } = messageErreur(e)
-    if (status === 429) {
+    errorMsg.value = texte
-      errorMsg.value = 'Limite de 20 questions par jour atteinte.'
+    peutReessayer.value = ok
-    } else if (status === 503) {
-      errorMsg.value = 'Le RAG est indisponible pour l\'instant — réessaie dans quelques minutes.'
-    } else if (status === 504) {
-      errorMsg.value = 'Le RAG met du temps à répondre — réessaie dans quelques secondes.'
-    } else {
-      errorMsg.value = 'Une erreur est survenue. Réessaie dans quelques instants.'
-    }
   } finally {
+    arreterAttente()
     loading.value = false
     await nextTick()
     scrollToBottom()
@@ -361,6 +439,25 @@ function slugify(str: string): string {
   padding: 10px 12px;
 }
 
+.attente-texte {
+  margin-left: 6px;
+  font-size: 0.775rem;
+  color: var(--nav-text-muted);
+  font-style: italic;
+}
+
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
 .dot {
   width: 6px;
   height: 6px;
@@ -377,6 +474,11 @@ function slugify(str: string): string {
   40% { opacity: 1; }
 }
 
+/* Pas d'animation si l'usager la réduit : points fixes, le texte d'attente porte l'information */
+@media (prefers-reduced-motion: reduce) {
+  .dot { animation: none; opacity: 0.6; }
+}
+
 /* Erreur */
 .chatbot-error {
   align-self: flex-start;
@@ -386,8 +488,36 @@ function slugify(str: string): string {
   border-radius: 8px;
   padding: 7px 10px;
   max-width: 90%;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 6px;
 }
 
+.chatbot-retry-btn {
+  font: inherit;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: var(--nav-text-on-primary);
+  background: var(--nav-primary);
+  border: none;
+  border-radius: 6px;
+  padding: 4px 12px;
+  cursor: pointer;
+}
+.chatbot-retry-btn:hover { opacity: 0.85; }
+.chatbot-retry-btn:focus-visible { outline: 2px solid var(--nav-primary); outline-offset: 2px; }
+
+/* Mode de réponse */
+.chatbot-mode-row {
+  flex-shrink: 0;
+  display: flex;
+  padding: 6px 10px 0;
+  border-top: 1px solid rgba(180, 170, 160, 0.22);
+  background: var(--nav-surface);
+}
+.chatbot-mode-row + .chatbot-input-row { border-top: none; }
+
 /* Input */
 .chatbot-input-row {
   flex-shrink: 0;

components/ChatbotPlaceholder.vue

@@ -12,7 +12,7 @@
       role="button"
       tabindex="0"
       :aria-expanded="isExpanded"
-      aria-label="Ouvrir l'assistant chatbot"
+      :aria-label="`Ouvrir l'assistant : ${titre}`"
       @keydown.enter="toggleExpand"
       @keydown.space.prevent="toggleExpand"
     >
@@ -27,7 +27,7 @@
       </div>
 
       <span class="flex-1 text-sm" style="color: var(--nav-text-muted);">
-        {{ isExpanded ? 'Chatbot AEP' : 'Pose une question sur le réseau…' }}
+        {{ isExpanded ? titre : placeholderReplie }}
       </span>
 
       <!-- Chevron -->
@@ -52,21 +52,23 @@
       <div class="chatbot-body-inner" ref="messagesContainer">
         <!-- Onboarding -->
         <div v-if="messages.length === 0" class="onboarding-bubble">
-          <p>Explore les 120 structures de la carte par la conversation. Je peux t'aider à trouver des collectifs, agences ou réseaux selon ta situation, ta pratique ou tes inspirations du moment.</p>
+          <p>{{ intro }}</p>
-          <p class="example">Exemple : "Je cherche des acteurs de la rénovation de maisons individuelles en France, plutôt en milieu rural, avec des approches biosourcées ou low-tech."</p>
+          <p v-if="exemple" class="example">{{ exemple }}</p>
         </div>
 
         <!-- Messages -->
         <template v-for="(msg, i) in messages" :key="i">
           <div v-if="msg.role === 'user'" class="user-bubble">{{ msg.content }}</div>
           <div v-else class="assistant-bubble">
-            <p>{{ msg.content }}</p>
+            <ChatModeBadge :profondeur="msg.profondeur" />
+            <div v-if="rendreMarkdown" v-html="renderMd(msg.content)" />
+            <p v-else>{{ msg.content }}</p>
             <div v-if="msg.fiches && msg.fiches.length > 0" class="fiches-list">
-              <p class="fiches-title">Fiches recommandees :</p>
+              <p class="fiches-title">{{ fichesTitre }}</p>
               <a
                 v-for="fiche in msg.fiches"
                 :key="fiche.id"
-                :href="`/fiche/${fiche.id}`"
+                :href="ficheLienModele.replace('{id}', String(fiche.id))"
                 class="fiche-card"
               >
                 <span class="fiche-nom">{{ fiche.nom }}</span>
@@ -98,15 +100,22 @@
 
         <!-- Erreur -->
         <div v-if="errorMsg" class="error-bubble">{{ errorMsg }}</div>
+
+        <ChatNewConversation v-if="hasHistory && !loading" @reset="nouvelleConversation" />
+      </div>
+
+      <!-- Mode de réponse -->
+      <div class="chatbot-mode-row" style="border-top: 1px solid var(--nav-bg-alt);">
+        <ChatModeToggle v-model="profondeur" :disabled="loading" />
       </div>
 
       <!-- Input -->
-      <div class="chatbot-input-row" style="border-top: 1px solid var(--nav-bg-alt);">
+      <div class="chatbot-input-row">
         <input
           v-model="inputText"
           type="text"
           :disabled="loading"
-          placeholder="Pose ta question…"
+          :placeholder="placeholderSaisie"
           class="chatbot-input"
           @keydown.enter.prevent="sendMessage"
         />
@@ -127,6 +136,9 @@
 </template>
 
 <script setup lang="ts">
+import { useMarkdown } from '~/composables/useMarkdown'
+const { render: renderMd } = useMarkdown()
+
 interface FicheReco {
   id: number | string
   nom: string
@@ -138,15 +150,58 @@ interface ChatMessage {
   content: string
   fiches?: FicheReco[]
   suggestedHashtags?: string[]
+  profondeur?: string
 }
 
+// Composant unique pour les deux chatbots desktop. Les défauts reproduisent
+// exactement le comportement de l'accueil (/api/chatbot, backend Entraide).
+// Les deux backends renvoient { reponse_texte, fiches_recommandees } ; seul
+// le rendu diffère (texte brut vs markdown, lien de fiche).
+const props = withDefaults(defineProps<{
+  /** Route serveur appelée (body { question }) */
+  endpoint?: string
+  /** Titre affiché dans l'en-tête déplié */
+  titre?: string
+  /** Texte de l'en-tête replié */
+  placeholderReplie?: string
+  /** Placeholder du champ de saisie */
+  placeholderSaisie?: string
+  /** Texte d'accueil (première bulle) */
+  intro?: string
+  /** Exemple de question, affiché sous l'accueil */
+  exemple?: string
+  /** Intitulé de la liste de fiches/structures citées */
+  fichesTitre?: string
+  /** Modèle de lien vers une fiche, {id} est remplacé */
+  ficheLienModele?: string
+  /** Rendre la réponse en markdown (backend réseaux) plutôt qu'en texte brut */
+  rendreMarkdown?: boolean
+  /** Message affiché quand la limite quotidienne (429) est atteinte */
+  messageLimite?: string
+  /** Clé de persistance (sessionStorage). Même clé = même conversation (ex. mobile + desktop) */
+  chatKey?: string
+}>(), {
+  chatKey: 'accueil',
+  endpoint: '/api/chatbot',
+  titre: 'Chatbot AEP',
+  placeholderReplie: 'Pose une question sur le réseau…',
+  placeholderSaisie: 'Pose ta question…',
+  intro: "Explore les 120 structures de la carte par la conversation. Je peux t'aider à trouver des collectifs, agences ou réseaux selon ta situation, ta pratique ou tes inspirations du moment.",
+  exemple: 'Exemple : "Je cherche des acteurs de la rénovation de maisons individuelles en France, plutôt en milieu rural, avec des approches biosourcées ou low-tech."',
+  fichesTitre: 'Fiches recommandees :',
+  ficheLienModele: '/fiche/{id}',
+  rendreMarkdown: false,
+  messageLimite: 'Limite de 10 questions par jour atteinte. Reviens demain.',
+})
+
 const emit = defineEmits<{
   'highlightOrgs': [ids: (number | string)[]]
   'applyHashtag': [tag: string]
 }>()
 
 const isExpanded = ref(false)
-const messages = ref<ChatMessage[]>([])
+const { messages, hasHistory, clear } = useChatSession<ChatMessage>(() => props.chatKey)
+const profondeur = useChatProfondeur(() => props.chatKey)
 const inputText = ref('')
 const loading = ref(false)
 const errorMsg = ref('')
@@ -183,6 +238,11 @@ function detectHashtagsFromQuery(query: string): string[] {
   return detected.slice(0, 3)
 }
 
+function nouvelleConversation() {
+  clear()
+  errorMsg.value = ''
+}
+
 function toggleExpand() {
   isExpanded.value = !isExpanded.value
 }
@@ -195,6 +255,7 @@ async function sendMessage() {
   errorMsg.value = ''
   messages.value.push({ role: 'user', content: question })
   loading.value = true
+  const mode = profondeur.value
 
   await nextTick()
   scrollToBottom()
@@ -203,9 +264,9 @@ async function sendMessage() {
     const res = await $fetch<{
       reponse_texte: string
       fiches_recommandees: { id: number | string; nom: string; explication: string }[]
-    }>('/api/chatbot', {
+    }>(props.endpoint, {
       method: 'POST',
-      body: { question },
+      body: { question, profondeur: mode },
     })
 
     const suggestedHashtags = detectHashtagsFromQuery(question)
@@ -214,6 +275,7 @@ async function sendMessage() {
       content: res.reponse_texte,
       fiches: res.fiches_recommandees || [],
       suggestedHashtags: suggestedHashtags.length ? suggestedHashtags : undefined,
+      profondeur: mode,
     }
     messages.value.push(assistantMsg)
 
@@ -223,7 +285,7 @@ async function sendMessage() {
   } catch (e: any) {
     const status = e?.statusCode ?? e?.status
     if (status === 429) {
-      errorMsg.value = 'Limite de 10 questions par jour atteinte. Reviens demain.'
+      errorMsg.value = props.messageLimite
     } else if (status === 503) {
       errorMsg.value = 'Le budget IA mensuel est épuisé. Soutiens NAV sur Liberapay pour continuer.'
     } else {
@@ -305,6 +367,11 @@ function scrollToBottom() {
   gap: 8px;
 }
 
+.chatbot-mode-row {
+  display: flex;
+  padding: 8px 12px 0;
+  flex-shrink: 0;
+}
 .chatbot-input-row {
   display: flex;
   align-items: center;

components/ChatbotReseaux.vue

@@ -54,6 +54,7 @@
           <template v-for="(msg, i) in messages" :key="i">
             <div v-if="msg.role === 'user'" class="user-bubble">{{ msg.content }}</div>
             <div v-else class="assistant-bubble">
+              <ChatModeBadge :profondeur="msg.profondeur" />
               <div v-html="renderMd(msg.content)" />
               <div v-if="msg.fiches && msg.fiches.length > 0" class="fiches-list" style="margin-top:12px;">
                 <p class="fiches-title">Structures recommandées :</p>
@@ -74,9 +75,11 @@
             <span class="dot" /><span class="dot" /><span class="dot" />
           </div>
           <div v-if="errorMsg" class="error-bubble">{{ errorMsg }}</div>
+          <ChatNewConversation v-if="hasHistory && !loading" @reset="nouvelleConversation" />
         </div>
 
         <div class="shrink-0 px-4 pt-3 border-t" style="border-color: var(--nav-bg-alt); padding-bottom: max(1rem, env(safe-area-inset-bottom));">
+          <ChatModeToggle v-model="profondeur" :disabled="loading" class="mb-2" />
           <div class="flex items-center gap-2">
             <input
               v-model="inputText"
@@ -112,12 +115,13 @@ import { useMarkdown } from '~/composables/useMarkdown'
 const { render: renderMd } = useMarkdown()
 
 interface FicheReco { id: number | string; nom: string; explication?: string }
-interface ChatMessage { role: 'user' | 'assistant'; content: string; fiches?: FicheReco[] }
+interface ChatMessage { role: 'user' | 'assistant'; content: string; fiches?: FicheReco[]; profondeur?: string }
 
 const props = defineProps<{ modelValue: boolean }>()
 const emit = defineEmits<{ 'update:modelValue': [value: boolean] }>()
 
-const messages = ref<ChatMessage[]>([])
+const { messages, hasHistory, clear } = useChatSession<ChatMessage>('agences')
+const profondeur = useChatProfondeur('agences')
 const inputText = ref('')
 const loading = ref(false)
 const errorMsg = ref('')
@@ -136,6 +140,11 @@ onUnmounted(() => {
   }
 })
 
+function nouvelleConversation() {
+  clear()
+  errorMsg.value = ''
+}
+
 async function sendMessage() {
   const question = inputText.value.trim()
   if (!question || loading.value) return
@@ -147,11 +156,12 @@ async function sendMessage() {
   if (messagesContainer.value) messagesContainer.value.scrollTop = messagesContainer.value.scrollHeight
 
   try {
+    const mode = profondeur.value
     const res = await $fetch<{ reponse_texte: string; fiches_recommandees: FicheReco[] }>(
       '/api/chatbot-reseaux',
-      { method: 'POST', body: { question } }
+      { method: 'POST', body: { question, profondeur: mode } }
     )
-    messages.value.push({ role: 'assistant', content: res.reponse_texte, fiches: res.fiches_recommandees || [] })
+    messages.value.push({ role: 'assistant', content: res.reponse_texte, fiches: res.fiches_recommandees || [], profondeur: mode })
   } catch (e: any) {
     const s = e?.statusCode ?? e?.status
     errorMsg.value = s === 429

components/ChatbotSheet.vue

@@ -87,6 +87,7 @@
 
             <!-- Message assistant -->
             <div v-else class="assistant-bubble">
+              <ChatModeBadge :profondeur="msg.profondeur" />
               <div class="md-content" v-html="renderMd(msg.content)" />
 
               <!-- Fiches recommandées -->
@@ -114,6 +115,8 @@
           <div v-if="errorMsg" class="error-bubble">
             {{ errorMsg }}
           </div>
+
+          <ChatNewConversation v-if="hasHistory && !loading" @reset="nouvelleConversation" />
         </div>
 
         <!-- Input -->
@@ -121,6 +124,7 @@
           class="shrink-0 px-4 pt-3 border-t"
           style="border-color: var(--nav-bg-alt); padding-bottom: max(1rem, env(safe-area-inset-bottom));"
         >
+          <ChatModeToggle v-model="profondeur" :disabled="loading" class="mb-2" />
           <div class="flex items-center gap-2">
             <input
               v-model="inputText"
@@ -172,6 +176,7 @@ interface ChatMessage {
   role: 'user' | 'assistant'
   content: string
   fiches?: FicheReco[]
+  profondeur?: string
 }
 
 const props = defineProps<{
@@ -183,7 +188,8 @@ const emit = defineEmits<{
   'highlightOrgs': [ids: (number | string)[]]
 }>()
 
-const messages = ref<ChatMessage[]>([])
+const { messages, hasHistory, clear } = useChatSession<ChatMessage>('accueil')
+const profondeur = useChatProfondeur('accueil')
 const inputText = ref('')
 const loading = ref(false)
 const errorMsg = ref('')
@@ -207,6 +213,11 @@ onUnmounted(() => {
   }
 })
 
+function nouvelleConversation() {
+  clear()
+  errorMsg.value = ''
+}
+
 async function sendMessage() {
   const question = inputText.value.trim()
   if (!question || loading.value) return
@@ -215,6 +226,7 @@ async function sendMessage() {
   errorMsg.value = ''
   messages.value.push({ role: 'user', content: question })
   loading.value = true
+  const mode = profondeur.value
 
   await nextTick()
   scrollToBottom()
@@ -225,13 +237,14 @@ async function sendMessage() {
       fiches_recommandees: { id: number | string; nom: string; explication: string }[]
     }>('/api/chatbot', {
       method: 'POST',
-      body: { question },
+      body: { question, profondeur: mode },
     })
 
     const assistantMsg: ChatMessage = {
       role: 'assistant',
       content: res.reponse_texte,
       fiches: res.fiches_recommandees || [],
+      profondeur: mode,
     }
     messages.value.push(assistantMsg)
 

composables/useChatProfondeur.ts

@@ -0,0 +1,13 @@
+/**
+ * Mode de profondeur courant d'un chatbot (M3). État partagé par clé via useState :
+ * desktop et mobile d'un même chatbot (clés 'accueil', 'agences'…) restent synchronisés.
+ * Volontairement non persisté : le mode est un choix par question, 'rapide' à chaque visite.
+ */
+export function useChatProfondeur(key: string | (() => string) = 'defaut') {
+  const k = typeof key === 'function' ? key : () => key
+  const store = useState<Record<string, ChatProfondeur>>('aep-chat-profondeur', () => ({}))
+  return computed<ChatProfondeur>({
+    get: () => store.value[k()] ?? CHAT_PROFONDEUR_DEFAUT,
+    set: (v) => { store.value = { ...store.value, [k()]: normaliserProfondeur(v) } },
+  })
+}

composables/useChatSession.ts

@@ -0,0 +1,103 @@
+import type { MaybeRefOrGetter } from 'vue'
+
+/**
+ * Persistance de l'historique d'un chatbot dans sessionStorage.
+ *
+ * - Clé de stockage : `aep-chat-<pageKey>`, valeur `{ v: 1, messages: [...] }`
+ *   (une valeur d'une autre version est ignorée).
+ * - SSR-safe : aucun accès au stockage hors de onMounted. Côté serveur et à
+ *   l'hydratation l'historique est vide, il est restauré juste après le mount.
+ * - Partagé : deux composants (desktop + mobile) qui déclarent la même clé
+ *   lisent et écrivent le même tableau (useState), donc un redimensionnement
+ *   ne perd rien et un composant n'écrase pas l'autre.
+ * - Tolérant : toute lecture/écriture est dans un try/catch (navigation
+ *   privée, stockage bloqué, quota). En cas d'échec le chatbot fonctionne
+ *   comme avant, sans persistance.
+ * - Les messages marqués `transient: true` (erreurs) restent affichés mais ne
+ *   sont jamais écrits. Chargement et erreurs vivent hors de l'historique.
+ * - La forme des messages est libre (fiches, auteur, mode...) : tout champ
+ *   sérialisable est conservé.
+ */
+export interface ChatSessionMessage {
+  role: string
+  content: string
+  transient?: boolean
+}
+
+const STORAGE_PREFIX = 'aep-chat-'
+const SCHEMA_VERSION = 1
+const DEFAULT_MAX = 40
+
+export function useChatSession<T extends ChatSessionMessage>(
+  pageKey: MaybeRefOrGetter<string>,
+  options: { max?: number } = {},
+) {
+  const max = options.max ?? DEFAULT_MAX
+  const store = useState<Record<string, T[]>>('aep-chat-store', () => ({}))
+  const restored = useState<Record<string, boolean>>('aep-chat-restored', () => ({}))
+  const key = computed(() => toValue(pageKey))
+  const mounted = ref(false)
+
+  function ensure(k: string) {
+    if (!store.value[k]) store.value[k] = []
+  }
+
+  const messages = computed<T[]>({
+    get: () => store.value[key.value] ?? [],
+    set: (list) => { store.value[key.value] = list },
+  })
+  const hasHistory = computed(() => messages.value.length > 0)
+
+  function isValid(m: any): m is T {
+    return !!m && typeof m === 'object' && typeof m.role === 'string' && typeof m.content === 'string'
+  }
+
+  function restore() {
+    const k = key.value
+    if (restored.value[k]) return
+    restored.value[k] = true
+    ensure(k)
+    try {
+      const raw = sessionStorage.getItem(STORAGE_PREFIX + k)
+      if (!raw) return
+      const data = JSON.parse(raw)
+      if (!data || data.v !== SCHEMA_VERSION || !Array.isArray(data.messages)) return
+      const valid = (data.messages as unknown[]).filter(isValid).slice(-max)
+      if (valid.length && store.value[k].length === 0) store.value[k] = valid
+    } catch {
+      /* stockage indisponible ou valeur corrompue : on repart de zéro */
+    }
+  }
+
+  function save() {
+    if (!mounted.value) return
+    try {
+      const list = messages.value.filter(m => !m.transient).slice(-max)
+      const sk = STORAGE_PREFIX + key.value
+      if (list.length === 0) sessionStorage.removeItem(sk)
+      else sessionStorage.setItem(sk, JSON.stringify({ v: SCHEMA_VERSION, messages: list }))
+    } catch {
+      /* quota, navigation privée : pas de persistance, pas d'erreur */
+    }
+  }
+
+  /** Efface l'historique affiché et la clé de stockage. */
+  function clear() {
+    store.value[key.value] = []
+    try { sessionStorage.removeItem(STORAGE_PREFIX + key.value) } catch { /* ignoré */ }
+  }
+
+  watch(key, (k) => {
+    ensure(k)
+    if (mounted.value) restore()
+  }, { immediate: true })
+
+  watch(messages, save, { deep: true })
+
+  onMounted(() => {
+    restore()
+    mounted.value = true
+  })
+
+  return { messages, hasHistory, clear }
+}

pages/agences.vue

@@ -58,6 +58,17 @@
         <!-- Chatbot sous la carte (ordinateur) -->
         <div v-if="vf.etat.sousVue !== 'outremer'" class="hidden lg:block shrink-0">
           <ChatbotPlaceholder
+            endpoint="/api/chatbot-reseaux"
+            chat-key="agences"
+            titre="Assistant Réseaux AEP"
+            placeholder-replie="Pose une question sur les structures et agences du réseau…"
+            placeholder-saisie="Décris ta situation…"
+            intro="Je connais les 120 réseaux, collectifs et agences cartographiés dans AEP — ceux qui portent une vision écologique et politique de l'architecture. Décris ta situation : tu cherches un collectif, une agence inspirante, un partenaire sur un projet ?"
+            exemple="Exemple : « Quelles agences travaillent sur le réemploi ? »"
+            fiches-titre="Structures recommandées :"
+            fiche-lien-modele="/agences#{id}"
+            rendre-markdown
+            message-limite="Limite de 20 questions par jour atteinte."
             @highlightOrgs="() => {}"
             @applyHashtag="(tag) => vf.ajouterFiltre('tags', sansDiese(tag))"
           />

pages/trouver-du-taf.vue

@@ -254,8 +254,11 @@
             <!-- Messages de la conversation -->
             <template v-for="(msg, i) in chatMessages" :key="i">
               <div :class="['taff-msg', msg.role === 'user' ? 'taff-msg--user' : 'taff-msg--bot']">
-                <div v-if="msg.role === 'bot'" class="md-content" v-html="renderMd(msg.content)" />
+                <template v-if="msg.role === 'bot'">
-                <span v-else>{{ msg.content }}</span>
+                  <ChatModeBadge :profondeur="msg.profondeur" />
+                  <div class="md-content" v-html="renderMd(msg.content)" />
+                </template>
+                <span v-if="msg.role !== 'bot'">{{ msg.content }}</span>
               </div>
               <!-- Plateformes recommandées -->
               <div v-if="msg.role === 'bot' && msg.recommandations?.length" class="taff-chat-recos">
@@ -275,6 +278,13 @@
             <div v-if="chatLoading" class="taff-msg taff-msg--bot">
               <span class="taff-typing"><span/><span/><span/></span>
             </div>
+
+            <ChatNewConversation v-if="chatHasHistory && !chatLoading" @reset="clearChat" />
+          </div>
+
+          <!-- Mode de réponse -->
+          <div class="taff-chat-mode">
+            <ChatModeToggle v-model="chatProfondeur" :disabled="chatLoading" />
           </div>
 
           <!-- Input -->
@@ -581,6 +591,9 @@ interface ChatMessage {
   role: 'user' | 'bot'
   content: string
   recommandations?: { id: string; nom: string; raison: string }[]
+  profondeur?: string
+  /** Message d'erreur : affiché mais jamais persisté */
+  transient?: boolean
 }
 
 const { render: renderMd } = useMarkdown()
@@ -588,7 +601,8 @@ const { render: renderMd } = useMarkdown()
 const chatOpen    = ref(false)
 const chatInput   = ref('')
 const chatLoading = ref(false)
-const chatMessages = ref<ChatMessage[]>([])
+const { messages: chatMessages, hasHistory: chatHasHistory, clear: clearChat } = useChatSession<ChatMessage>('taff')
+const chatProfondeur = useChatProfondeur('taff')
 const chatMessagesEl = ref<HTMLElement | null>(null)
 
 async function sendChat() {
@@ -597,20 +611,22 @@ async function sendChat() {
   chatMessages.value.push({ role: 'user', content: q })
   chatInput.value = ''
   chatLoading.value = true
+  const mode = chatProfondeur.value
   await nextTick()
   chatMessagesEl.value?.scrollTo({ top: chatMessagesEl.value.scrollHeight, behavior: 'smooth' })
   try {
     const res = await $fetch<{ reponse_texte: string; plateformes_recommandees: { id: string; nom: string; raison: string }[] }>(
       '/api/chatbot-taff',
-      { method: 'POST', body: { question: q } }
+      { method: 'POST', body: { question: q, profondeur: mode } }
     )
     chatMessages.value.push({
       role: 'bot',
       content: res.reponse_texte,
       recommandations: res.plateformes_recommandees ?? [],
+      profondeur: mode,
     })
   } catch (e: any) {
-    chatMessages.value.push({ role: 'bot', content: e?.data?.statusMessage ?? 'Erreur — réessaie dans un instant.' })
+    chatMessages.value.push({ role: 'bot', content: e?.data?.statusMessage ?? 'Erreur — réessaie dans un instant.', transient: true })
   } finally {
     chatLoading.value = false
     await nextTick()
@@ -968,6 +984,8 @@ const parsedDescription = computed(() => {
   40% { transform: translateY(-5px); opacity: 1; }
 }
 
+.taff-chat-mode { padding: 0.5rem 1rem 0; }
+
 .taff-chat-input-wrap {
   display: flex;
   align-items: flex-end;

scripts/test-citations.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Test du garde-fou des citations (server/utils/citations.ts). Usage : node scripts/test-citations.mjs
+import assert from 'node:assert/strict'
+import { verifierCitations, contenusChunks } from '../server/utils/citations.ts'
+
+const ctx = ["La technique est devenue autonome, et forme un monde dévorant.\r\nIl n’y a plus de liberté de choix. Plus on parle d’une valeur, plus c'est le signe de son absence."]
+const t = (rep, c = ctx) => verifierCitations(rep, c)
+
+// retrouvée (apostrophes, casse, ponctuation de bord, retours chariot) : gardée
+let r = t('Ellul écrit : « Il n\'y a plus de liberté de choix ! » donc.')
+assert.equal(r.gardees, 1); assert.equal(r.retirees, 0); assert.ok(r.texte.includes('«'))
+// introuvable : guillemets retirés, texte conservé
+r = t('Il dit : « La technique est une machine à fabriquer du pouvoir social inévitable ». Fin.')
+assert.equal(r.retirees, 1); assert.equal(r.texte, 'Il dit : La technique est une machine à fabriquer du pouvoir social inévitable. Fin.')
+// guillemets droits et anglais
+r = t('"Une phrase inventée qui ne figure nulle part dans le texte" et “Une autre phrase inventée qui ne figure nulle part ici”')
+assert.equal(r.retirees, 2); assert.ok(!/["“”]/.test(r.texte))
+// court (< 6 mots) : intact, non compté
+r = t('Le « rift métabolique » et la « ville intelligente ».')
+assert.equal(r.gardees + r.retirees, 0); assert.ok(r.texte.includes('« rift métabolique »'))
+// élision [...] : chaque morceau doit exister
+r = t('« Plus on parle d\'une valeur [...] le signe de son absence »')
+assert.equal(r.gardees, 1)
+r = t('« Plus on parle d\'une valeur [...] le signe de sa présence éclatante »')
+assert.equal(r.retirees, 1)
+// pas de correspondance en milieu de mot
+r = t('« ormation autonome, et forme un monde dévorant »')
+assert.equal(r.retirees, 1)
+// aucun contexte : rien de long n'est gardé
+r = t('« Il n\'y a plus de liberté de choix »', [])
+assert.equal(r.retirees, 1)
+// contenusChunks : tableau de chaînes ou chaîne
+assert.deepEqual(contenusChunks([{ content: ['a', 'b'] }, { content: 'c' }, {}, null]), ['a', 'b', 'c'])
+assert.deepEqual(contenusChunks(undefined), [])
+console.log('citations : tous les cas passent')

scripts/verif-citations.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * Contrôle des citations d'un chatbot LightRAG : chaque segment entre guillemets
+ * de la réponse doit figurer mot pour mot dans le contexte réellement récupéré.
+ *
+ * Usage :
+ *   node scripts/verif-citations.mjs --rag http://HOTE:9621 --query "Cite ..." \
+ *     [--route http://localhost:3334/api/chatbot-pensees] [--mode hybrid] [--auteur slug] \
+ *     [--response-file reponse.txt] [--ctx-query-file autre-query.txt] [--min-mots 6] [--max-total-tokens 40000 (mode approfondi)] [--json]
+ *
+ * - Sans --response-file : la réponse est demandée à --route (POST {query, mode, auteur_slug}).
+ * - Contexte : POST {rag}/query {query, mode, only_need_context:true}. --ctx-query-file ajoute
+ *   un second contexte (ex. la requête telle qu'envoyée avant amendement, préambule inclus) ;
+ *   un segment est « trouvé » s'il figure dans l'un ou l'autre.
+ * - Segment >= min-mots (6) absent du contexte = inventé (algorithme : server/utils/citations.ts, partagé avec la route). Plus court : signalé, non compté.
+ * Lecture seule côté LightRAG. Réutilisable pour l'instance 9623 (--rag http://HOTE:9623).
+ */
+import { readFileSync } from 'node:fs'
+// Node >= 22.18 charge le .ts directement (syntaxe effaçable uniquement dans citations.ts).
+import { verifierCitations } from '../server/utils/citations.ts'
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((a, x, i, arr) => {
+  if (x.startsWith('--')) a.push([x.slice(2), arr[i + 1] && !arr[i + 1].startsWith('--') ? arr[i + 1] : true])
+  return a
+}, []))
+if (!args.rag || !args.query) { console.error('--rag et --query requis'); process.exit(2) }
+const mode = args.mode || 'hybrid'
+const minMots = Number(args['min-mots'] || 6)
+
+async function post(url, body, timeout = 120000) {
+  const r = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(timeout) })
+  if (!r.ok) throw new Error(`${url} -> HTTP ${r.status}`)
+  return r.json()
+}
+async function contexte(q) {
+  const j = await post(`${args.rag}/query`, { query: q, mode, only_need_context: true, ...(args['max-total-tokens'] ? { max_total_tokens: Number(args['max-total-tokens']) } : {}) })
+  return typeof j.response === 'string' ? j.response : JSON.stringify(j)
+}
+
+let reponse
+if (args['response-file']) reponse = readFileSync(args['response-file'], 'utf8')
+else {
+  if (!args.route) { console.error('--route ou --response-file requis'); process.exit(2) }
+  const b = { query: args.query, mode }
+  if (args.auteur) b.auteur_slug = args.auteur
+  reponse = (await post(args.route, b)).response
+}
+
+const ctxs = [await contexte(args.query)]
+if (args['ctx-query-file']) ctxs.push(await contexte(readFileSync(args['ctx-query-file'], 'utf8')))
+// Même fonction pure que la route (server/utils/citations.ts) : un seul algorithme, deux usages.
+const v = verifierCitations(reponse, ctxs, minMots)
+const lignes = v.segments.map(l => ({ segment: l.segment, mots: l.mots, trouve: l.trouve }))
+const longs = lignes.filter(l => l.mots >= minMots)
+const res = {
+  query: args.query, mode,
+  segments: lignes.length, longs: longs.length,
+  longs_trouves: longs.filter(l => l.trouve).length,
+  inventes: longs.filter(l => !l.trouve).length,
+  courts_non_comptes: lignes.length - longs.length,
+  contexte_chars: ctxs.map(c => c.length),
+  detail: lignes, reponse,
+}
+if (args.json) console.log(JSON.stringify(res, null, 2))
+else {
+  console.log(`Q: ${res.query}\nsegments=${res.segments} longs(>=${minMots} mots)=${res.longs} trouvés=${res.longs_trouves} INVENTÉS=${res.inventes} courts=${res.courts_non_comptes}`)
+  for (const l of lignes) console.log(`  [${l.mots >= minMots ? (l.trouve ? 'OK ' : 'INV') : 'crt'}] (${l.mots}) ${l.segment.slice(0, 160)}`)
+}

server/api/chatbot-pensees.post.ts

@@ -6,6 +6,18 @@
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { checkRateLimitJson } from '~/server/utils/rateLimitJson'
+import { profondeurDuBody, REGLE_GUILLEMETS } from '~/server/utils/bifrost'
+import { verifierCitations, contenusChunks } from '~/server/utils/citations'
+
+/**
+ * Règle citations — commune aux 4 préambules (mesure M7 du 05/10 : le modèle invente des
+ * citations entre guillemets quand l'extrait n'est pas dans le contexte récupéré).
+ */
+const REGLE_CITATIONS = `RÈGLE DES CITATIONS (prioritaire sur toute autre consigne) :
+- Ne mets entre guillemets (« ») que ce qui figure MOT POUR MOT dans le contexte fourni ci-dessus. Jamais de citation reconstituée de mémoire, de paraphrase ou de résumé entre guillemets. Même si la question demande des phrases « exactes » ou « mot pour mot », ne cède jamais : mieux vaut peu de citations, ou aucune, qu'une citation approximative.
+- Avant d'écrire un guillemet, repère dans le contexte le passage exact : si tu ne le retrouves pas à l'identique, ne le cite pas. Au plus 3 citations, les plus courtes et les plus sûres ; recopie-les sans les raccourcir, sans les enchaîner, sans les compléter.
+- Si aucun passage correspondant n'est disponible dans le contexte, dis explicitement « je ne cite pas : aucun passage exact n'est disponible dans les extraits » et reformule sans guillemets, en indiquant qu'il s'agit d'une synthèse.
+- Nomme l'œuvre dont provient le passage dans le contexte, pas une autre.`
 
 const SYSTEM_PREFACE_PENSEES = `Tu es un agent du RAG Pensées Écologiques, infrastructure militante du collectif trans-former.fr.
 Tu réponds en t'appuyant STRICTEMENT sur le corpus ingéré (auteurs FRACAS Bonpote : écosocialisme, éco-anarchisme, écoféminismes, écologies décoloniales, technocritique, pensées du vivant, décroissance...).
@@ -40,6 +52,28 @@ Règles :
 - Ton praticien militant : direct, pas neutre, ancré dans la pratique architecturale.
 - Réponse en français, dense, sans délayage.`
 
+/**
+ * Posture « réflexion » (mode approfondi, v1 — prompts définitifs par onglet : B7/B9).
+ * Ajoutée APRÈS le préambule du corpus et AVANT REGLE_CITATIONS (qui reste prioritaire).
+ * Pensées n'est pas servi par Bifrost : le LLM de génération est réglé côté LightRAG, donc
+ * ce mode change la consigne et les paramètres de récupération, pas le modèle.
+ */
+const POSTURE_REFLEXION = `MODE RÉFLEXION : l'usager veut penser, pas seulement s'informer.
+- Mets les idées en relation : reformule d'abord ce que la question engage, puis fais dialoguer les auteurs et les écoles présents dans le contexte.
+- Nomme les tensions et les désaccords entre écoles (ce qu'elles partagent, là où elles divergent, ce que chacune ne voit pas), sans trancher à la place de l'usager.
+- Reste strictement dans le corpus fourni : si une idée n'y est pas, dis-le au lieu de la compléter de mémoire.
+- Termine par 2 questions ouvertes qui aident l'usager à situer sa propre position.
+- Réponse structurée en paragraphes courts, 450 mots maximum.
+- ${REGLE_GUILLEMETS}`
+
+/**
+ * Paramètres de récupération LightRAG du mode réflexion. Mesuré le 09/10 (contexte seul, hybrid) :
+ * top_k 60 / chunk_top_k 30 ne changent rien (115,7 → 115,9 Ko, le budget de tokens plafonne) ;
+ * max_total_tokens 50000 monte le contexte à 153 Ko. On prend 40000 : plus de matière pour croiser
+ * les écoles sans approcher la fenêtre du LLM de génération (réglé côté serveur).
+ */
+const PARAMS_RAG_REFLEXION = { max_total_tokens: 40000 }
+
 function buildPrefaceAuteur(nomAuteur: string, slug: string): string {
   return `Tu réponds EXCLUSIVEMENT depuis les livres de ${nomAuteur} présents dans le RAG (fichiers commençant par "${slug}__").
 Si la question sort du périmètre de cet auteur, indique-le et propose de l'aborder sans le hashtag pour interroger la carte entière. Reste fidèle au style et à la pensée de ${nomAuteur}. Cite toujours le livre.
@@ -88,6 +122,8 @@ export default defineEventHandler(async (event) => {
   }
 
   const query: string = body.query.trim()
+  // jamais body.mode ici : réservé au mode de recherche LightRAG (hybrid…)
+  const profondeur = profondeurDuBody({ profondeur: body.profondeur })
   const mode: string = body.mode || 'hybrid'
   const corpus: string = body.corpus || 'pensees'
   const ragUrl: string = (config.ragPeUrl as string) || 'http://localhost:9621'
@@ -117,8 +153,20 @@ export default defineEventHandler(async (event) => {
     throw createError({ statusCode: 503, message: 'RAG indisponible pour l\'instant — réessaie dans quelques minutes.' })
   }
 
-  const ragQuery = `${systemPreface}\n\nQuestion : ${query}`
+  // user_prompt (LightRAG) : instructions ajoutées au prompt de génération, sans polluer la recherche
-  const ragBody: Record<string, any> = { query: ragQuery, mode }
+  // (vérifié sur 9621 le 09/10 : une consigne de fin de réponse est appliquée). La requête de
+  // recherche est la question seule.
+  const ragBody: Record<string, any> = {
+    query,
+    mode,
+    // textes des chunks utilisés : sert au garde-fou des citations (server/utils/citations.ts)
+    include_references: true,
+    include_chunk_content: true,
+    user_prompt: profondeur === 'approfondi'
+      ? `${systemPreface}\n\n${POSTURE_REFLEXION}\n\n${REGLE_CITATIONS}`
+      : `${systemPreface}\n\n${REGLE_CITATIONS}`,
+  }
+  if (profondeur === 'approfondi') Object.assign(ragBody, PARAMS_RAG_REFLEXION)
   if (auteurSlug && nomAuteurMatch) {
     ragBody.hl_keywords = [nomAuteurMatch, auteurSlug]
     ragBody.ll_keywords = [auteurSlug]
@@ -149,8 +197,15 @@ export default defineEventHandler(async (event) => {
     }
   }
 
+  // Garde-fou : un segment long entre guillemets absent des chunks récupérés perd ses guillemets.
+  const verif = verifierCitations(String(ragResponse.response ?? ''), contenusChunks(ragResponse.references))
+  if (verif.retirees > 0) {
+    console.warn(`[chatbot-pensees] ${verif.retirees} citation(s) non retrouvée(s) dans le contexte, guillemets retirés (${verif.gardees} gardée(s))`)
+  }
+
   return {
-    response: ragResponse.response ?? '',
+    response: verif.texte,
+    citations: { gardees: verif.gardees, retirees: verif.retirees },
     mode,
     corpus,
     auteur: auteurSlug && nomAuteurMatch ? { slug: auteurSlug, nom: nomAuteurMatch } : null,
@@ -158,5 +213,8 @@ export default defineEventHandler(async (event) => {
     auteur_chunks: auteurSlug && nomAuteurMatch ? { on_target: chunksOnTarget, off_target: chunksOffTarget } : null,
     filter: { couche: body.filter_couche ?? null, ecole: body.filter_ecole ?? null },
     timestamp: new Date().toISOString(),
+    ...(import.meta.dev
+      ? { debug: { profondeur, user_prompt_chars: ragBody.user_prompt.length, rag_params: profondeur === 'approfondi' ? PARAMS_RAG_REFLEXION : null } }
+      : {}),
   }
 })

server/api/chatbot-reseaux.post.ts

@@ -6,7 +6,7 @@
 // @ts-ignore — JSON import résolu par Rollup
 import reseauxData from '../../public/data/reseaux-bifurcation.json'
 import { checkRateLimitJson } from '~/server/utils/rateLimitJson'
-import { pickBifrostTier, bifrostContent, REASONING_MARGIN_TOKENS, type BifrostChatResponse } from '~/server/utils/bifrost'
+import { pickBifrostTier, profondeurDuBody, bifrostMaxTokens, bifrostDebug, bifrostContent, REGLE_GUILLEMETS, type BifrostChatResponse } from '~/server/utils/bifrost'
 
 interface Structure {
   id: string
@@ -41,6 +41,29 @@ FORMAT :
 STRUCTURES DISPONIBLES :
 {{STRUCTURES_JSON}}`
 
+// Prompt « réflexion » (mode approfondi, v1 — prompts définitifs par onglet : B7/B9). Même format JSON.
+const SYSTEM_PROMPT_REFLEXION = `Tu es un conseiller archi, au service des architectes engagés dans la transition écologique. Tu connais le réseau AEP (Architecture d'Écologie Politique) — une cartographie des collectifs, agences, initiatives et réseaux qui portent une vision alternative de l'architecture en France et en Europe.
+
+POSTURE : avant de recommander des structures, tu questionnes le projet de l'usager. Tu reformules ce que tu comprends de son projet, tu nommes ce qui reste flou ou en tension (échelle, maîtrise d'ouvrage, filière de matériaux, rapport au territoire, posture professionnelle, moyens), tu poses 2 ou 3 questions précises qui l'aident à se situer, PUIS tu orientes vers les structures du contexte qui correspondent à ce qu'il a dit, en expliquant ce que chacune lui apporterait ou lui ferait choisir.
+
+RÈGLES :
+1. Ne cite QUE des structures présentes dans le contexte ci-dessous.
+2. ${REGLE_GUILLEMETS}
+3. Sois direct et engagé — c'est l'esprit AEP — mais n'affirme pas ce que tu ne sais pas de son projet : demande.
+4. Réponse de 300 mots maximum, en français, en prose, tutoiement.
+5. Retourne UNIQUEMENT un JSON valide, sans texte avant ou après.
+
+FORMAT :
+{
+  "reponse_texte": "Ta réponse en prose, max 300 mots : reformulation, tension, questions, puis structures",
+  "fiches_recommandees": [
+    { "id": "slug-id", "nom": "Nom structure", "explication": "Pourquoi en 1 phrase" }
+  ]
+}
+
+STRUCTURES DISPONIBLES :
+{{STRUCTURES_JSON}}`
+
 function scoreStructure(s: Structure, keywords: string[]): number {
   if (keywords.length === 0) return 1
   const haystack = [s.nom, s.famille_principale, s.description_courte, s.description_longue, (s.hashtags ?? []).join(' '), s.ville, s.pays]
@@ -62,7 +85,8 @@ export default defineEventHandler(async (event) => {
   const body = await readBody(event)
   const question: string = (body?.question ?? '').trim()
   if (!question || question.length < 5) throw createError({ statusCode: 400, message: 'Question trop courte.' })
-  const tier = pickBifrostTier(body?.mode)
+  const profondeur = profondeurDuBody(body)
+  const tier = pickBifrostTier(profondeur)
 
   const structures: Structure[] = ((reseauxData as any).structures ?? [])
   const keywords = extractKeywords(question)
@@ -82,13 +106,14 @@ export default defineEventHandler(async (event) => {
     description: (s.description_courte ?? s.description_longue ?? '').slice(0, 200),
   }))
 
-  const systemPrompt = SYSTEM_PROMPT.replace('{{STRUCTURES_JSON}}', JSON.stringify(context, null, 0))
+  const systemPrompt = (profondeur === 'approfondi' ? SYSTEM_PROMPT_REFLEXION : SYSTEM_PROMPT).replace('{{STRUCTURES_JSON}}', JSON.stringify(context, null, 0))
 
   const bifrostUrl = config.bifrostUrl as string
   const bifrostVk = config.bifrostVk as string
   if (!bifrostVk) throw createError({ statusCode: 500, message: 'Clé Bifrost manquante.' })
 
   let mistralRaw: string
+  let debugExtra: Record<string, unknown> = {}
   try {
     const res = await $fetch<BifrostChatResponse>(
       `${bifrostUrl}/v1/chat/completions`,
@@ -99,7 +124,7 @@ export default defineEventHandler(async (event) => {
           model: tier.model,
           fallbacks: tier.fallbacks,
           temperature: 0.3,
-          max_tokens: 700 + REASONING_MARGIN_TOKENS,
+          max_tokens: bifrostMaxTokens(700, profondeur),
           response_format: { type: 'json_object' },
           messages: [
             { role: 'system', content: systemPrompt },
@@ -109,6 +134,7 @@ export default defineEventHandler(async (event) => {
       }
     )
     mistralRaw = bifrostContent(res, 'chatbot-reseaux')
+    debugExtra = bifrostDebug(res, 'chatbot-reseaux', profondeur)
   } catch {
     throw createError({ statusCode: 502, message: 'Erreur IA — réessaie dans quelques instants.' })
   }
@@ -122,6 +148,7 @@ export default defineEventHandler(async (event) => {
         nom: r.nom ?? structures.find(s => s.id === r.id)?.nom ?? r.id,
         explication: r.explication ?? '',
       })),
+      ...debugExtra,
     }
   } catch {
     return { reponse_texte: "Je n'ai pas pu analyser ta demande.", fiches_recommandees: [] }

server/api/chatbot-taff.post.ts

@@ -7,7 +7,7 @@
 // @ts-ignore — JSON import résolu par Vite/Rollup
 import taffData from '../../public/data/plateformes-taff.json'
 import { checkRateLimitJson } from '~/server/utils/rateLimitJson'
-import { pickBifrostTier, bifrostContent, REASONING_MARGIN_TOKENS, type BifrostChatResponse } from '~/server/utils/bifrost'
+import { pickBifrostTier, profondeurDuBody, bifrostMaxTokens, bifrostDebug, bifrostContent, REGLE_GUILLEMETS, type BifrostChatResponse } from '~/server/utils/bifrost'
 
 interface PlateformeMinimal {
   id: string
@@ -49,6 +49,29 @@ FORMAT :
 PLATEFORMES DISPONIBLES :
 {{PLATEFORMES_JSON}}`
 
+// Prompt « réflexion » (mode approfondi, v1 — prompts définitifs par onglet : B7/B9). Même format JSON.
+const SYSTEM_PROMPT_REFLEXION = `Tu es un conseiller pour les architectes indépendants français qui cherchent des missions. Tu connais toutes les plateformes de mise en relation architecte↔particulier et les agrégateurs d'appels d'offres publics référencés par AEP (Architecture d'Écologie Politique).
+
+POSTURE : avant de recommander une plateforme, tu aides l'architecte à clarifier ce qu'il cherche et qui il est : type de missions visées (particuliers, public, réno, neuf), volume et rythme, statut et assurances, ce qu'il accepte de céder (commission, abonnement, temps de réponse), ses valeurs. Tu reformules son profil tel que tu le comprends, tu nommes un arbitrage que sa demande laisse ouvert, tu poses 2 ou 3 questions qui l'aident à se situer, PUIS tu orientes vers LA ou LES plateformes du contexte qui correspondent, avec leurs limites.
+
+RÈGLES :
+1. Ne recommande QUE des plateformes présentes dans le contexte ci-dessous. Si l'une est « À éviter », signale-le clairement.
+2. ${REGLE_GUILLEMETS}
+3. Sois direct et opinionné — c'est la valeur d'AEP — mais ne présume pas de ce que tu ignores de son profil : demande.
+4. Réponse de 300 mots maximum, en français, en prose, ton conseiller pair, tutoiement.
+5. Retourne UNIQUEMENT un JSON valide, sans texte avant ou après.
+
+FORMAT :
+{
+  "reponse_texte": "Ta réponse en prose, max 300 mots : reformulation, arbitrage, questions, puis plateformes",
+  "plateformes_recommandees": [
+    { "id": "slug-kebab", "nom": "Nom plateforme", "raison": "Pourquoi cette plateforme en 1 phrase" }
+  ]
+}
+
+PLATEFORMES DISPONIBLES :
+{{PLATEFORMES_JSON}}`
+
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig()
 
@@ -67,7 +90,8 @@ export default defineEventHandler(async (event) => {
   if (!question || question.length < 5) {
     throw createError({ statusCode: 400, statusMessage: 'Question trop courte.' })
   }
-  const tier = pickBifrostTier(body?.mode)
+  const profondeur = profondeurDuBody(body)
+  const tier = pickBifrostTier(profondeur)
 
   // Données bundlées statiquement à la compilation (import JSON)
   const plateformes: PlateformeMinimal[] = ((taffData as any).plateformes ?? []).map((p: any) => ({
@@ -91,7 +115,7 @@ export default defineEventHandler(async (event) => {
     justification: p.scoring.justification_tag,
   }))
 
-  const systemPrompt = SYSTEM_PROMPT.replace('{{PLATEFORMES_JSON}}', JSON.stringify(context, null, 0))
+  const systemPrompt = (profondeur === 'approfondi' ? SYSTEM_PROMPT_REFLEXION : SYSTEM_PROMPT).replace('{{PLATEFORMES_JSON}}', JSON.stringify(context, null, 0))
 
   const bifrostUrl = config.bifrostUrl as string
   const bifrostVk = config.bifrostVk as string
@@ -100,6 +124,7 @@ export default defineEventHandler(async (event) => {
   }
 
   let mistralRaw: string
+  let debugExtra: Record<string, unknown> = {}
   try {
     const res = await $fetch<BifrostChatResponse>(
       `${bifrostUrl}/v1/chat/completions`,
@@ -110,7 +135,7 @@ export default defineEventHandler(async (event) => {
           model: tier.model,
           fallbacks: tier.fallbacks,
           temperature: 0.3,
-          max_tokens: 700 + REASONING_MARGIN_TOKENS,
+          max_tokens: bifrostMaxTokens(700, profondeur),
           response_format: { type: 'json_object' },
           messages: [
             { role: 'system', content: systemPrompt },
@@ -120,6 +145,7 @@ export default defineEventHandler(async (event) => {
       }
     )
     mistralRaw = bifrostContent(res, 'chatbot-taff')
+    debugExtra = bifrostDebug(res, 'chatbot-taff', profondeur)
   } catch {
     throw createError({ statusCode: 502, statusMessage: 'Erreur IA — réessaie dans quelques instants.' })
   }
@@ -133,6 +159,7 @@ export default defineEventHandler(async (event) => {
         nom: r.nom ?? plateformes.find(p => p.id === r.id)?.nom ?? r.id,
         raison: r.raison ?? '',
       })),
+      ...debugExtra,
     }
   } catch {
     return { reponse_texte: "Je n'ai pas pu analyser ta demande.", plateformes_recommandees: [] }

server/api/chatbot-v2.post.ts

@@ -1,194 +0,0 @@
-/**
- * POST /api/chatbot-v2
- *
- * Chatbot V2 - Embedding-based search sur structures bifurcation
- * Coexiste avec /api/chatbot (keyword NocoDB) pendant la transition.
- *
- * SETUP AVANT DEPLOY :
- * cd nav-carte && MISTRAL_API_KEY=xxx node scripts/vectorize-v2.js
- * Coût estimé : ~0.10 EUR pour 120 fiches
- *
- * Flow :
- *   1. Rate limit (réutilise checkRateLimitJson, 10 req/IP/jour)
- *   2. Embed la query via Mistral Embed (mistral-embed)
- *   3. Top-5 cosine similarity sur embeddings-v2.json
- *   4. Si embeddings absents : réponse graceful (v2_ready: false)
- *   5. Construit contexte RAG depuis les fiches candidates
- *   6. Génère réponse Mistral Small (json_object)
- *   7. Retourne { reponse_texte, fiches_recommandees, sources, v2_ready }
- *
- * Variables d'env :
- *   MISTRAL_API_KEY       - Clé Mistral (partagée avec chatbot v1)
- *   RAG_V1_ENABLED        - true/false (défaut: true) - coexistence pendant transition
- *   RAG_V1_DEPRECATION_DATE - Date prévue deprecation v1 (ex: 2026-05-18)
- */
-
-import { checkRateLimitJson } from '~/server/utils/rateLimitJson'
-import { loadEmbeddingsV2, topKSearch } from '~/server/utils/vectorSearch'
-
-// ── System prompt V2 ───────────────────────────────────────────────────────────
-
-const SYSTEM_PROMPT_V2 = `Tu es un assistant pour la carte des réseaux de bifurcation en architecture (projet AEP).
-Tu réponds aux questions sur les structures, les pratiques, les pensées écologiques.
-
-Règles :
-- Cite chaque structure par son nom exact et son fiche_id
-- Indique la famille (1-5) entre parenthèses après chaque nom
-- Reste sobre et descriptif - pas militant agressif
-- Tirets longs interdits : utilise des - ou des ;
-- Max 200 mots par réponse
-- Si hors-scope (pas archi/habiter/écologie), redirige poliment vers la carte
-- Retourne UNIQUEMENT un JSON valide, sans texte avant ou après
-
-Familles :
-1 - Réemploi et filières
-2 - Frugalité et low-tech
-3 - Architecture sociale et précarités
-4 - Collectifs, écolieux et AMO
-5 - Urbanisme de transition et territoires
-
-FORMAT DE SORTIE :
-{
-  "reponse_texte": "Ta réponse en prose (max 200 mots)",
-  "fiches_recommandees": [
-    { "fiche_id": "f1-rotor", "nom": "Rotor", "explication": "1-2 phrases pourquoi cette fiche" }
-  ]
-}
-
-CONTEXTE - Structures disponibles :
-{{CONTEXTE_RAG}}`
-
-// ── Handler ────────────────────────────────────────────────────────────────────
-
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-
-  // 1. Rate limit
-  const ip =
-    getHeader(event, 'x-forwarded-for')?.split(',')[0].trim() ||
-    event.node.req.socket?.remoteAddress ||
-    '0.0.0.0'
-
-  const allowed = checkRateLimitJson(ip, 'chatbot-v2', 10)
-  if (!allowed) {
-    throw createError({
-      statusCode: 429,
-      statusMessage: 'Limite de 10 questions par jour atteinte.'
-    })
-  }
-
-  // 2. Validation body
-  const body = await readBody(event)
-  const question: string = (body?.question ?? '').trim()
-
-  if (!question || question.length < 3) {
-    throw createError({ statusCode: 400, statusMessage: 'Question trop courte.' })
-  }
-
-  const mistralApiKey = config.mistralApiKey as string
-  if (!mistralApiKey) {
-    throw createError({ statusCode: 500, statusMessage: 'Clé API Mistral manquante.' })
-  }
-
-  // 3. Charger embeddings V2 (lazy, cachés en mémoire)
-  const embeddingsV2 = loadEmbeddingsV2()
-
-  // Graceful fallback si le script vectorize-v2.js n'a pas encore été lancé
-  if (embeddingsV2.length === 0) {
-    return {
-      reponse_texte: "La base vectorielle V2 est en cours de préparation. Merci d'utiliser le chatbot classique en attendant.",
-      fiches_recommandees: [],
-      sources: [],
-      v2_ready: false
-    }
-  }
-
-  // 4. Embed la query via Mistral Embed
-  let queryEmbedding: number[]
-  try {
-    const embedRes = await $fetch<{ data: { embedding: number[] }[] }>(
-      'https://api.mistral.ai/v1/embeddings',
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${mistralApiKey}`,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          model: 'mistral-embed',
-          inputs: [question]
-        })
-      }
-    )
-    queryEmbedding = embedRes.data[0].embedding
-  } catch (e: any) {
-    console.error('[chatbot-v2] Erreur embedding Mistral :', e?.message ?? e)
-    throw createError({ statusCode: 502, statusMessage: 'Erreur embedding Mistral.' })
-  }
-
-  // 5. Top-5 cosine similarity
-  const v2Results = topKSearch(embeddingsV2, queryEmbedding, 5)
-
-  // 6. Contexte RAG
-  const candidatesContext = v2Results.map(r => ({
-    fiche_id: r.fiche_id,
-    nom: r.nom,
-    famille: r.famille,
-    hashtags: r.hashtags,
-    score: r.score,
-    preview: r.text_preview
-  }))
-
-  const contextStr = candidatesContext
-    .map(c => `[${c.fiche_id}] ${c.nom} (famille ${c.famille}, score: ${c.score.toFixed(2)})\n${c.preview}`)
-    .join('\n\n---\n\n')
-
-  const systemPrompt = SYSTEM_PROMPT_V2.replace('{{CONTEXTE_RAG}}', contextStr)
-
-  // 7. Mistral Small - génération réponse
-  let mistralRaw: string
-  try {
-    const mistralRes = await $fetch<{
-      choices: { message: { content: string } }[]
-    }>('https://api.mistral.ai/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${mistralApiKey}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        model: 'mistral-small-latest',
-        temperature: 0.3,
-        max_tokens: 600,
-        response_format: { type: 'json_object' },
-        messages: [
-          { role: 'system', content: systemPrompt },
-          { role: 'user', content: question }
-        ]
-      })
-    })
-    mistralRaw = mistralRes.choices?.[0]?.message?.content ?? '{}'
-  } catch (e: any) {
-    console.error('[chatbot-v2] Erreur Mistral Small :', e?.message ?? e)
-    throw createError({ statusCode: 502, statusMessage: 'Erreur appel Mistral Small.' })
-  }
-
-  // 8. Parse JSON
-  let parsed: { reponse_texte: string; fiches_recommandees: any[] }
-  try {
-    parsed = JSON.parse(mistralRaw)
-    if (!parsed.reponse_texte) throw new Error('reponse_texte absent')
-  } catch {
-    parsed = {
-      reponse_texte: "Impossible d'analyser la réponse.",
-      fiches_recommandees: []
-    }
-  }
-
-  return {
-    reponse_texte: parsed.reponse_texte,
-    fiches_recommandees: parsed.fiches_recommandees ?? [],
-    sources: candidatesContext,
-    v2_ready: true
-  }
-})

server/api/chatbot.post.ts

@@ -19,7 +19,7 @@
 
 import { checkRateLimitJson } from '~/server/utils/rateLimitJson'
 import { checkBudget, calcCoutMistralSmall } from '~/server/utils/circuitBreaker'
-import { pickBifrostTier, bifrostContent, REASONING_MARGIN_TOKENS, type BifrostChatResponse } from '~/server/utils/bifrost'
+import { pickBifrostTier, profondeurDuBody, bifrostMaxTokens, bifrostDebug, bifrostContent, REGLE_GUILLEMETS, type BifrostChatResponse } from '~/server/utils/bifrost'
 
 // ── Types ──────────────────────────────────────────────────────────────────────
 
@@ -70,6 +70,32 @@ FORMAT DE SORTIE :
 CONTEXTE — Organisations disponibles dans la base NAV :
 {{FICHES_JSON}}`
 
+// ── Prompt « réflexion » (mode approfondi, v1 — prompts définitifs par onglet : B7/B9) ──────
+// Même format de sortie JSON que SYSTEM_PROMPT (le front en dépend) ; seule la posture change.
+
+const SYSTEM_PROMPT_REFLEXION = `Tu es un conseiller-ressources au service de la transition écologique des pratiques architecturales, sur AEP (Architecture d'Écologie Politique) — Écosystème Entraide, une base collaborative qui référence les acteurs de l'écologie politique appliquée à l'architecture et au territoire (organisations, outils, ressources) pour les architectes en France.
+
+POSTURE : l'usager pose rarement le bon problème du premier coup. Tu l'aides d'abord à formuler son besoin, puis tu l'orientes vers les ressources et fiches du contexte. Tu es dialectique : tu reformules ce que tu comprends, tu nommes une tension ou un choix que la question laisse ouvert, tu poses 2 ou 3 questions qui l'aident à se situer (où en est son projet, avec qui, à quelle échelle, quelle contrainte pèse le plus), PUIS tu proposes des pistes.
+
+RÈGLES ABSOLUES :
+1. Tu ne peux recommander QUE des organisations présentes dans le contexte ci-dessous. Ne jamais inventer d'organisation absente.
+2. Cite chaque organisation recommandée par son nom exact et son identifiant id. Si aucune n'est pertinente, dis-le honnêtement.
+3. ${REGLE_GUILLEMETS}
+4. Réponse de 300 mots maximum, en français, en prose (pas de liste à puces), ton de pair, tutoiement.
+5. Si la question est hors du champ architecture / écologie / territoire / transition, recadre poliment vers le périmètre de la carte.
+6. Retourne UNIQUEMENT un objet JSON valide, sans texte avant ou après.
+
+FORMAT DE SORTIE :
+{
+  "reponse_texte": "Ta réponse en prose (max 300 mots) : reformulation, tension, questions, puis pistes",
+  "fiches_recommandees": [
+    { "id": 123, "explication": "Pourquoi cette fiche répond à la question (1-2 phrases max)" }
+  ]
+}
+
+CONTEXTE — Organisations disponibles dans la base NAV :
+{{FICHES_JSON}}`
+
 // ── Recherche par mots-clés ────────────────────────────────────────────────────
 
 function scoreOrg(org: OrgRow, keywords: string[]): number {
@@ -182,7 +208,8 @@ export default defineEventHandler(async (event) => {
   const body = await readBody(event)
   const question: string = (body?.question ?? '').trim()
   const filters: { fonction?: string; echelle?: string } = body?.filters ?? {}
-  const tier = pickBifrostTier(body?.mode)
+  const profondeur = profondeurDuBody(body)
+  const tier = pickBifrostTier(profondeur)
 
   if (!question || question.length < 3) {
     throw createError({
@@ -245,7 +272,7 @@ export default defineEventHandler(async (event) => {
     ville: o.localisation_ville ?? '',
   }))
 
-  const systemPrompt = SYSTEM_PROMPT.replace(
+  const systemPrompt = (profondeur === 'approfondi' ? SYSTEM_PROMPT_REFLEXION : SYSTEM_PROMPT).replace(
     '{{FICHES_JSON}}',
     JSON.stringify(fichesContext, null, 0),
   )
@@ -265,6 +292,7 @@ export default defineEventHandler(async (event) => {
   let tokensIn = 0
   let tokensOut = 0
   let realModel = tier.model
+  let debugExtra: Record<string, unknown> = {}
 
   try {
     const bifrostRes = await $fetch<BifrostChatResponse>(`${bifrostUrl}/v1/chat/completions`, {
@@ -277,7 +305,7 @@ export default defineEventHandler(async (event) => {
         model: tier.model,
         fallbacks: tier.fallbacks,
         temperature: 0.3,
-        max_tokens: 600 + REASONING_MARGIN_TOKENS,
+        max_tokens: bifrostMaxTokens(600, profondeur),
         response_format: { type: 'json_object' },
         messages: [
           { role: 'system', content: systemPrompt },
@@ -287,6 +315,7 @@ export default defineEventHandler(async (event) => {
     })
 
     mistralRaw = bifrostContent(bifrostRes, 'chatbot')
+    debugExtra = bifrostDebug(bifrostRes, 'chatbot', profondeur)
     tokensIn = bifrostRes.usage?.prompt_tokens ?? 0
     tokensOut = bifrostRes.usage?.completion_tokens ?? 0
     realModel =
@@ -340,5 +369,5 @@ export default defineEventHandler(async (event) => {
     coutEur,
   })
 
-  return parsed
+  return { ...parsed, ...debugExtra }
 })

server/utils/bifrost.ts

@@ -4,8 +4,9 @@
  * Auth : header x-bf-vk
  *
  * 2 tiers (Mission M3 du build Bifrost ; modèles primaires changés le 28/09, session AEP front 4) :
- *   RAPIDE     — défaut, pas de toggle UI mode rapide/approfondi sur le site actuellement
+ *   RAPIDE     — défaut (mode « Question » du toggle front)
- *   APPROFONDI — activable via body.mode === 'approfondi' (prêt pour un futur toggle front)
+ *   APPROFONDI — body.profondeur === 'approfondi' (mode « Réflexion plus profonde », B1-M3 ;
+ *                body.mode reste lu en compat ascendante). Contrat : utils/chatProfondeur.ts
  *
  * ⚠ 28/09 : Groq a retiré groq/llama-3.1-8b-instant (RAPIDE) et groq/llama-3.3-70b-versatile
  *   (APPROFONDI) — 404 model_not_found via Bifrost. Depuis le 23/09 environ, chaque appel
@@ -32,6 +33,8 @@
  *   juste plus dans cette chaîne tant que ce n'est pas fiabilisé.
  */
 
+import { normaliserProfondeur, type ChatProfondeur } from '~/utils/chatProfondeur'
+
 export const BIFROST_TIER_RAPIDE = {
   model: 'groq/openai/gpt-oss-20b',
   fallbacks: [
@@ -57,11 +60,34 @@ export const BIFROST_TIER_APPROFONDI = {
  */
 export const REASONING_MARGIN_TOKENS = 800
 
-/** Sélectionne le tier selon le param optionnel body.mode. */
+/** Sélectionne le tier selon la profondeur ('approfondi' → APPROFONDI, tout le reste → RAPIDE). */
-export function pickBifrostTier(mode?: string) {
+export function pickBifrostTier(profondeur?: string) {
-  return mode === 'approfondi' ? BIFROST_TIER_APPROFONDI : BIFROST_TIER_RAPIDE
+  return profondeur === 'approfondi' ? BIFROST_TIER_APPROFONDI : BIFROST_TIER_RAPIDE
 }
 
+/**
+ * Profondeur demandée par le body : `profondeur`, sinon `mode` (compat ascendante des
+ * routes Bifrost avant B1-M3). Valeur inconnue → 'rapide'.
+ */
+export function profondeurDuBody(body: any): ChatProfondeur {
+  return normaliserProfondeur(body?.profondeur ?? body?.mode)
+}
+
+/**
+ * Budget max_tokens = contenu + marge de raisonnement. Le mode approfondi autorise une
+ * réponse un peu plus longue (+200) et une marge plus large (+400) : le 120b raisonne plus.
+ * Reste sous les limites par minute d'une clé Groq (prompt ~3-4 k + 2,2 k max).
+ */
+export function bifrostMaxTokens(contenu: number, profondeur: ChatProfondeur): number {
+  return profondeur === 'approfondi'
+    ? contenu + 200 + REASONING_MARGIN_TOKENS + 400
+    : contenu + REASONING_MARGIN_TOKENS
+}
+
+/** Règle guillemets, commune à tous les prompts « réflexion » (cf. REGLE_CITATIONS de Pensées). */
+export const REGLE_GUILLEMETS =
+  'Ne mets entre guillemets que ce qui figure mot pour mot dans le contexte fourni ; sinon reformule sans guillemets.'
+
 export interface BifrostChatResponse {
   /** reasoning : présent avec gpt-oss, jamais lu (la réponse utile est dans content). */
   choices: { message: { content: string; reasoning?: string }; finish_reason?: string }[]
@@ -69,6 +95,18 @@ export interface BifrostChatResponse {
   extra_fields?: { provider?: string; resolved_model_used?: string }
 }
 
+/**
+ * Preuve du tier réellement servi : journal serveur toujours (modèle dans le log seulement),
+ * et champ `debug` dans la réponse UNIQUEMENT en dev (import.meta.dev, éliminé du build de
+ * production). Aucun nom de modèle n'est exposé publiquement.
+ */
+export function bifrostDebug(res: BifrostChatResponse, route: string, profondeur: ChatProfondeur) {
+  const modele = res.extra_fields?.resolved_model_used ?? null
+  const fournisseur = res.extra_fields?.provider ?? null
+  console.log(`[${route}] profondeur=${profondeur} fournisseur=${fournisseur} modèle=${modele}`)
+  return import.meta.dev ? { debug: { profondeur, fournisseur, modele } } : {}
+}
+
 /**
  * Contenu JSON de la réponse. Une troncature (finish_reason 'length') ne lève aucune erreur
  * et finit en message générique côté usager : on la signale au journal pour la voir.

server/utils/citations.ts

@@ -0,0 +1,99 @@
+/**
+ * Garde-fou des citations (B1-M4) — fonctions pures, sans dépendance (réutilisables par les scripts Node).
+ *
+ * Problème : une consigne de prompt (REGLE_CITATIONS) ne suffit pas, le modèle met entre guillemets des
+ * phrases qui ne figurent pas dans le contexte récupéré (mesuré le 09/10 : 7/7 introuvables sur une
+ * question ouverte). Une fausse citation attribuée à un auteur réel engage le site : on la vérifie dans
+ * le code. Tout segment long entre guillemets absent des textes de chunks réellement récupérés perd ses
+ * guillemets (le texte reste, sans valeur de citation).
+ */
+
+export const MIN_MOTS_CITATION = 6
+
+/** Sans accents, minuscules, tout ce qui n'est ni lettre ni chiffre devient un espace (apostrophes, \r\n, markdown). */
+export function normaliserTexte(s: string): string {
+  return s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .trim()
+}
+
+export interface SegmentCitation {
+  /** texte tel qu'il apparaît entre les guillemets */
+  segment: string
+  mots: number
+  /** true si segment court (< minMots) : jamais vérifié, jamais retiré */
+  court: boolean
+  /** true si retrouvé dans le contexte (toujours true pour un segment court) */
+  trouve: boolean
+}
+
+export interface ResultatCitations {
+  /** réponse dont les citations longues introuvables ont perdu leurs guillemets */
+  texte: string
+  gardees: number
+  retirees: number
+  segments: SegmentCitation[]
+}
+
+// « … » (espaces fines ou insécables tolérés), “ … ”, " … ". Les « » sont traités en premier :
+// un "…" imbriqué ne doit pas casser l'appariement.
+const MOTIFS: RegExp[] = [
+  /«[\s  ]*([^»]+?)[\s  ]*»/g,
+  /“([^”]+?)”/g,
+  /"([^"\n]+?)"/g,
+]
+
+// Élision dans une citation : [...], […], … ou ... — chaque morceau doit être retrouvé séparément.
+const ELISION = /\[\s*(?:\.{3}|…)\s*\]|…|\.{3}/
+
+function mots(n: string): number {
+  return n ? n.split(' ').length : 0
+}
+
+/**
+ * Vérifie les citations de `reponse` contre `contextes` (textes des chunks récupérés).
+ * - segment >= minMots mots : cherché (normalisé, borné aux mots entiers) ; absent => guillemets retirés.
+ * - segment < minMots mots (titres, expressions) : laissé tel quel.
+ * Aucun contexte exploitable => aucune citation longue ne peut être vérifiée, donc aucune n'est gardée.
+ */
+export function verifierCitations(reponse: string, contextes: string[], minMots: number = MIN_MOTS_CITATION): ResultatCitations {
+  const ctx = ` ${normaliserTexte(contextes.join('\n'))} `
+  const segments: SegmentCitation[] = []
+  let gardees = 0
+  let retirees = 0
+
+  const trouve = (seg: string): boolean => {
+    const parts = seg.split(ELISION).map(normaliserTexte).filter(Boolean)
+    return parts.length > 0 && parts.every(p => ctx.includes(` ${p} `))
+  }
+
+  let texte = reponse
+  for (const motif of MOTIFS) {
+    texte = texte.replace(motif, (entier: string, seg: string) => {
+      const n = normaliserTexte(seg.split(ELISION).join(' '))
+      const nb = mots(n)
+      if (nb < minMots) {
+        segments.push({ segment: seg, mots: nb, court: true, trouve: true })
+        return entier
+      }
+      const ok = trouve(seg)
+      segments.push({ segment: seg, mots: nb, court: false, trouve: ok })
+      if (ok) { gardees++; return entier }
+      retirees++
+      return seg
+    })
+  }
+  return { texte, gardees, retirees, segments }
+}
+
+/** Concatène les textes de chunks d'une réponse LightRAG (`references[].content`, tableau de chaînes ou chaîne). */
+export function contenusChunks(references: unknown): string[] {
+  if (!Array.isArray(references)) return []
+  const out: string[] = []
+  for (const r of references) {
+    const c = (r as { content?: unknown })?.content
+    if (Array.isArray(c)) for (const x of c) { if (typeof x === 'string') out.push(x) }
+    else if (typeof c === 'string') out.push(c)
+  }
+  return out
+}

server/utils/vectorSearch.ts

@@ -1,96 +0,0 @@
-/**
- * Recherche vectorielle sur les embeddings V2
- * Cosine similarity + top-K
- *
- * Utilisé par : server/api/chatbot-v2.post.ts
- * Données     : server/data/embeddings-v2.json (généré par scripts/vectorize-v2.js)
- */
-
-import { readFileSync, existsSync } from 'fs'
-import { fileURLToPath } from 'url'
-import { resolve, dirname } from 'path'
-
-// ── Types ──────────────────────────────────────────────────────────────────────
-
-export interface EmbeddingEntry {
-  fiche_id: string
-  nom: string
-  famille: number
-  hashtags: string[]
-  embedding: number[]
-  text_preview: string
-}
-
-export interface SearchResult {
-  fiche_id: string
-  nom: string
-  famille: number
-  hashtags: string[]
-  score: number
-  text_preview: string
-}
-
-// ── Cosine similarity ──────────────────────────────────────────────────────────
-
-export function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) return 0
-  let dot = 0, normA = 0, normB = 0
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i]
-    normA += a[i] * a[i]
-    normB += b[i] * b[i]
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB)
-  return denom === 0 ? 0 : dot / denom
-}
-
-// ── Top-K search ───────────────────────────────────────────────────────────────
-
-export function topKSearch(
-  embeddings: EmbeddingEntry[],
-  queryEmbedding: number[],
-  k: number = 5
-): SearchResult[] {
-  return embeddings
-    .map(e => ({
-      fiche_id: e.fiche_id,
-      nom: e.nom,
-      famille: e.famille,
-      hashtags: e.hashtags,
-      score: cosineSimilarity(e.embedding, queryEmbedding),
-      text_preview: e.text_preview
-    }))
-    .sort((a, b) => b.score - a.score)
-    .slice(0, k)
-}
-
-// ── Chargement lazy des embeddings (cache module-level) ────────────────────────
-
-let _embeddingsV2: EmbeddingEntry[] | null = null
-
-export function loadEmbeddingsV2(): EmbeddingEntry[] {
-  if (_embeddingsV2 !== null) return _embeddingsV2
-
-  try {
-    // Résolution du chemin depuis server/utils/ vers server/data/
-    const currentDir = dirname(fileURLToPath(import.meta.url))
-    const embPath = resolve(currentDir, '..', 'data', 'embeddings-v2.json')
-
-    if (!existsSync(embPath)) {
-      console.warn('[vectorSearch] embeddings-v2.json absent - V2 vector search désactivé')
-      console.warn('[vectorSearch] Lancer : MISTRAL_API_KEY=xxx node scripts/vectorize-v2.js')
-      _embeddingsV2 = []
-      return []
-    }
-
-    const raw = readFileSync(embPath, 'utf-8')
-    const data = JSON.parse(raw)
-    _embeddingsV2 = data.embeddings ?? []
-    console.log(`[vectorSearch] ${_embeddingsV2!.length} embeddings V2 chargés (${data.meta?.model ?? 'unknown'})`)
-    return _embeddingsV2!
-  } catch (e: any) {
-    console.warn('[vectorSearch] Erreur chargement embeddings-v2.json :', e?.message ?? e)
-    _embeddingsV2 = []
-    return []
-  }
-}

utils/chatProfondeur.ts

@@ -0,0 +1,27 @@
+/**
+ * Mode de profondeur des chatbots (M3) — contrat partagé front/serveur.
+ * Champ de body : `profondeur` = 'rapide' | 'approfondi' (défaut 'rapide').
+ * Les libellés affichés vivent ICI, à un seul endroit : les changer ne touche ni
+ * le composant ni le serveur.
+ */
+export type ChatProfondeur = 'rapide' | 'approfondi'
+
+export const CHAT_PROFONDEUR_DEFAUT: ChatProfondeur = 'rapide'
+
+export const CHAT_PROFONDEUR_LIBELLES: Record<ChatProfondeur, string> = {
+  rapide: 'Question',
+  approfondi: 'Réflexion plus profonde',
+}
+
+/** Sous-texte (title/aria) de chaque option. */
+export const CHAT_PROFONDEUR_AIDES: Record<ChatProfondeur, string> = {
+  rapide: 'Réponse directe et concise',
+  approfondi: 'Une réponse plus longue, qui questionne ton besoin avant de répondre',
+}
+
+export const CHAT_PROFONDEURS = Object.keys(CHAT_PROFONDEUR_LIBELLES) as ChatProfondeur[]
+
+/** Normalise une valeur inconnue (body, stockage) vers un mode valide. */
+export function normaliserProfondeur(v: unknown): ChatProfondeur {
+  return v === 'approfondi' ? 'approfondi' : 'rapide'
+}