---
stepsCompleted: [1, 2, 3]
inputDocuments: []
session_topic: 'Nouvelles fonctionnalités IA pour Keep (Memento) au-delà du roadmap existant'
session_goals: 'Générer des idées innovantes et différenciantes de fonctionnalités IA non couvertes par les phases 1-4 déjà planifiées'
selected_approach: 'ai-recommended'
techniques_used: ['Cross-Pollination', 'Reversal Inversion', 'SCAMPER Method']
ideas_generated: []
context_file: ''
mode: 'autonomous'
---

# Brainstorming Session Results

**Facilitator:** Ramez
**Date:** 2026-04-13

## Session Overview

**Topic:** Nouvelles fonctionnalités IA pour Keep (Memento)
**Goals:** Générer des idées innovantes et différenciantes de fonctionnalités IA non couvertes par les phases 1-4 déjà planifiées

### Context Guidance

_Projet Keep est une application de notes self-hosted, privacy-first, avec architecture multi-provider IA (OpenAI, Ollama, DeepSeek, OpenRouter, Custom). Phase 1 MVP AI déjà implémentée : suggestions de titre, recherche sémantique, reformulation, Memory Echo, fusion de notes, auto-tagging, organisation par lot (15 langues), détection de langue (62 langues). Roadmap Phase 2-4 couvre : OCR images, résumés URLs, Chat RAG, vue graphe, Voice-to-Note, Super AI mode, templates IA, organisation autonome._

### Session Setup

_Session axée sur la découverte de fonctionnalités IA totalement nouvelles, hors du roadmap existant, qui capitalisent sur l'architecture existante et le positionnement "Zero-Friction Intelligence" du produit._

## Technique Selection

**Approach:** AI-Recommended Techniques (Mode Autonome)
**Analysis Context:** Fonctionnalités IA nouvelles pour Keep avec focus sur innovation hors roadmap

**Recommended Techniques:**

- **Cross-Pollination:** Transférer des solutions d'industries différentes (santé, jeux, musique, éducation)
- **Reversal Inversion:** Retourner le problème pour révéler des angles cachés
- **SCAMPER Method:** Affiner les meilleures idées à travers 7 lentilles systématiques

---

## Phase 1: Cross-Pollination — Idées venues d'ailleurs

_Sources d'inspiration : santé mentale, jeux vidéo, musique, éducation, fitness wearables, reseaux sociaux, AI second brain_

### Idée 1 : Mood Weaving (inspiré des apps de journaling santé mentale)
L'IA analyse le sentiment et le ton émotionnel de chaque note au fil du temps. Un "tapis émotionnel" (mood tapestry) se tisse visuellement — un graphique de couleurs qui montre vos états émotionnels récurrents. L'IA détecte les cycles ("Tu es plus anxieux le dimanche soir", "Tes notes de voyages sont systématiquement plus positives"). **Différenciateur :** Aucune app de notes ne fait d'analyse émotionnelle longitudinale. Utilise le provider IA existant + TinyLD pour corréler langue et émotion.

### Idée 2 : Knowledge Podcast Generator (inspiré de Google NotebookLM)
Transformez un notebook ou un ensemble de notes en un **podcast audio généré par IA** — deux voix AI discutent de vos notes comme une émission radio. Idéal pour réviser ses notes de cours en marchant, ou consommer sa propre base de connaissance en mobilité. **Différenciateur :** Aucune app de notes self-hosted n'offre ça. Utilise les embeddings existants pour sélectionner le contenu pertinent.

### Idée 3 : Spaced Resurfacing (inspiré d'Anki et la répétition espacée)
Au lieu de simplement connecter des notes (Memory Echo), l'IA **resurface les notes que vous êtes sur le point d'oublier** basé sur la courbe d'oubli d'Ebbinghaus. Une note revient dans votre flux exactement au moment optimal pour la revoir. **Différenciateur :** Transforme Keep d'un simple outil de notes en un **système d'apprentissage actif**. Capitalise sur les embeddings existants pour mesurer la relatedness.

### Idée 4 : Thought Trajectory (inspiré des wearables fitness)
Comme une montre qui trace votre évolution physique, l'IA trace l'**évolution de votre pensée** sur un sujet. Vous avez écrit 15 notes sur "l'IA" en 6 mois ? L'IA vous montre comment votre position a évolué, quels concepts vous avez approfondis, lesquels vous avez abandonnés. **Différenciateur :** Visualisation temporelle de l'évolution intellectuelle. Utilise la recherche sémantique existante pour clusterer par sujet.

### Idée 5 : Note DNA (inspiré de Spotify DNA / musical fingerprinting)
Chaque note reçoit un "ADN" visuel unique basé sur ses caractéristiques IA : longueur, sentiment, langue, complexité, topics, connexions. Un petit badge visuel qui permet de **reconnaître instantanément** le type de note au coup d'oeil dans le masonry grid. **Différenciateur :** Approche visuelle/biomimétique unique. Les métadonnées IA existent déjà (embedding, langue, confidence).

### Idée 6 : Ghost Writer Mode (inspiré des "digital twins" comme Personal.ai)
L'IA apprend votre **style d'écriture** à partir de toutes vos notes existantes. Quand vous commencez à écrire, elle complète les phrases dans VOTRE voix, pas une voix générique. Plus vous écrivez, plus elle vous ressemble. **Différenciateur :** Privacy-first (modèle local via Ollama) — votre clone d'écriture ne quitte jamais votre serveur. Unique vs les apps cloud.

### Idée 7 : Contextual Nudge Engine (inspiré des wearables et nudge theory)
Au lieu de suggestions IA uniquement quand l'utilisateur le demande, l'IA **détecte le bon moment** pour intervenir. Exemple : vous écrivez 3 notes sur le même sujet en 2 jours → l'IA vous suggère doucement de les fusionner ou créer un notebook. Vous n'avez pas écrit depuis 5 jours → l'IA resurface une note ancienne pertinente. **Différenciateur :** "Zero-Friction Intelligence" poussé à son paroxysme — l'IA est proactive mais non-intrusive.

### Idée 8 : Knowledge Decay Indicator (inspiré de la physique radioactive)
Chaque note a un **indicateur de "demi-vie"** — un score qui diminue avec le temps si la note n'est ni consultée, ni connectée, ni mise à jour. Les notes "mortes" apparaissent différemment visuellement. L'IA vous alerte quand un concept important est en train de "se dégrader" dans votre base de connaissance. **Différenciateur :** Transforme la gestion de notes en gestion active de connaissance.

### Idée 9 : Daily Note Cocktail (inspiré de l'industrie du gaming — daily rewards)
Chaque jour, l'IA prépare un "cocktail" personnalisé de 3 notes : une revisitée (spaced resurfacing), une connexion inattendue (memory echo), et une "nouvelle perspective" (l'IA reformule une vieille note à la lumière de vos notes récentes). Un petit rituel quotidien qui encourage l'engagement. **Différenciateur :** Mécanique de rétention empruntée au gaming, adaptée à la connaissance.

### Idée 10 : Note-to-Timeline (inspiré des timelines de projets et GitHub)
L'IA reconstruit automatiquement une **timeline narrative** à partir de vos notes sur un sujet. Au lieu de voir des notes isolées, vous voyez une histoire : "Comment votre projet X a évolué de l'idée à la réalisation" avec les notes comme chapitres. **Différenciateur :** Narrative intelligence — transforme des fragments en récit cohérent.

---

## Phase 2: Reversal Inversion — Retourner le problème

_Et si on inversait les hypothèses fondamentales d'une app de notes ?_

### Idée 11 : Reverse Search (Et si c'était la note qui vous cherchait ?)
Au lieu de l'utilisateur qui cherche une note, les notes "postulent" pour être utiles. Quand vous ouvrez l'app, les notes les plus pertinentes compte tenu de l'heure, du jour, et de votre historique récent se placent en haut. **La note vient à vous.**

### Idée 12 : Strategic Forgetting (Et si l'IA oubliait délibérément ?)
L'IA marque certaines notes comme "archivées cognitivement" — elles restent accessibles mais sont retirées du flux actif pour réduire la surcharge informationnelle. L'inverse du "tout garder". L'IA décide ce que vous n'avez plus besoin de voir régulièrement, en se basant sur vos patterns de consultation.

### Idée 13 : Anti-Organization (Et si moins de structure = plus de valeur ?)
Un mode "Zen" où l'IA supprime toutes les étiquettes, notebooks et métadonnées visuelles. Vous voyez uniquement vos notes, nues. L'IA gère toute l'organisation en arrière-plan. L'utilisateur n'a qu'à écrire. **La désorganisation visible est un choix, pas un problème.**

### Idée 14 : Note Dissolve (Et si les notes pouvaient fusionner et disparaître ?)
Quand deux notes deviennent trop similaires (seuil de similarité élevé), l'IA propose de les "dissoudre" en une seule note enrichie, en supprimant les redondances. La note résultante est meilleure que chacune individuellement. **La réduction, pas l'accumulation, crée la valeur.**

### Idée 15 : Silent AI (Et si l'IA se taisait complètement ?)
Un mode où l'IA travaille entièrement en silence — elle organise, connecte, tag, resurface — mais l'utilisateur ne voit JAMAIS de suggestions, badges, ou prompts. L'effet se ressent indirectement : les bonnes notes sont toujours au bon endroit, les connexions se font seules. **L'IA parfaite est invisible.**

### Idée 16 : Note-as-Question (Et si chaque note générait des questions au lieu de réponses ?)
L'IA lit votre note et génère 3 questions que vous n'avez PAS posées. "Tu as écrit sur X, mais as-tu considéré Y ?" "C'est intéressant, mais qu'en est-il de Z ?" **La note ne clôt pas la pensée, elle l'ouvre.**

### Idée 17 : Reverse Onboarding (Et si l'app apprenait de vous au lieu de vous apprendre ?)
Pendant les 7 premiers jours, l'IA observe silencieusement COMMENT vous prenez des notes — style, longueur, fréquence, sujets. Ensuite, l'app s'adapte à VOTRE workflow au lieu de vous forcer dans un template prédéfini. **L'utilisateur ne remplit jamais un questionnaire de setup.**

### Idée 18 : Collaborative Silence (Et si le partage de notes n'avait pas de chat ?)
Au lieu d'un système de commentaires/discussion, les collaborateurs partagent des notes et l'IA détecte les **zones de friction ou désaccord** entre les notes de différentes personnes, et génère un "rapport de tensions" productif. **Pas de chat, pas de bruit — juste de l'intelligence.**

### Idée 19 : Time-Release Notes (Et si les notes avaient une date de sortie ?)
L'utilisateur peut écrire une note et la "sceller" avec une date future. La note n'apparaît dans le flux qu'à la date prévue. Comme une capsule temporelle. L'IA peut aussi suggérer des dates : "Cette réflexion pourrait te concerner dans 3 mois." **Le temps comme filtre actif.**

### Idée 20 : Emotion-First Organization (Et si l'organisation se faisait par émotion, pas par sujet ?)
L'IA classe vos notes non pas par notebook/tag mais par état émotionnel : "Notes écrites dans un moment d'enthousiasme", "Notes de doute", "Notes de découverte". Une dimension d'organisation totalement nouvelle. **Votre base de connaissance reflète qui vous étiez quand vous l'avez écrite.**

---

## Phase 3: SCAMPER — Affinage des meilleures idées

_7 lentilles appliquées aux concepts les plus prometteurs_

### S — Substitute (Remplacer)

**Idée 21 : Visual Note Identity (substitution de l'ADN note)**
Au lieu de badges de couleur simples, chaque note reçoit un **mini-glyph unique généré par IA** — un symbole abstrait qui encode sa signature sémantique. Comme les favicons mais pour les idées. Visuellement unique et mémorable.

### C — Combine (Combiner)

**Idée 22 : Daily Cocktail + Spaced Resurfacing = "Keep Daily"**
Combiner les idées 3 et 9 en une seule feature "Keep Daily" : chaque matin, une page personnalisée avec :
- 1 note à reviser (spaced repetition)
- 1 connexion inattendue (memory echo)
- 1 perspective nouvelle (reformulation IA d'une vieille note)
- 1 insight émotionnel (mood weaving)
- Le tout dans une interface éphémère qui change chaque jour.

**Idée 23 : Ghost Writer + Note DNA = "Your Voice Profile"**
Combiner l'apprentissage de style (idée 6) avec le fingerprinting de note (idée 5) pour créer un **profil vocal d'écriture** unique. L'UI montre votre "identité d'écrivain" : ton, longueur moyenne, vocabulaire préféré, patterns récurrents. Comme Spotify Wrapped, mais pour votre écriture.

### A — Adapt (Adapter)

**Idée 24 : Knowledge Podcast → Notebook Audiobook**
Adapter l'idée du podcast (idée 2) en quelque chose de plus simple techniquement : un **résumé audio lu par TTS** d'un notebook entier. Moins ambitieux qu'un podcast dialogué, plus facile à implémenter, et tout aussi utile pour consommer ses notes en marchant.

**Idée 25 : Thought Trajectory → "Thinking Map"**
Adapter l'idée 4 en une carte visuelle style "skill tree" de jeux vidéo. Chaque topic est un noeud, et l'arbre montre comment vos pensées ont branché, mergé, ou cul-de-sac. Utilise React Flow (déjà dans le roadmap Memory Echo V2).

### M — Modify (Modifier)

**Idée 26 : Contextual Nudge Engine → "AI Concierge"**
Modifier l'idée 7 en un personnage IA visible (un petit assistant dans un coin de l'écran) qui commente intelligemment votre activité. Pas intrusif, mais présent. Comme Clippy mais intelligent et optionnel. Utilise le provider IA pour générer des micro-commentaires contextuels.

**Idée 27 : Knowledge Decay → "Note Health Score"**
Modifier l'idée 8 en un système de **score de santé** pour chaque note (0-100) basé sur : fraîcheur (quand dernière mise à jour), connectivité (combien de liens vers elle), consultation (fréquence de lecture), richesse (longueur, médias). Un dashboard "Santé de votre base de connaissance".

### P — Put to Other Uses (Autres usages)

**Idée 28 : Keep comme outil de thérapie réflexive**
Utiliser le Mood Weaving (idée 1) + les Note-as-Question (idée 16) pour créer un mode **"Reflective Journal"** — Keep devient un outil de thérapie réflexive guidée par IA. L'IA pose des questions profondes, suit vos patterns émotionnels, et vous aide à prendre du recul. Positionnement unique : ni app de notes, ni app de thérapie, mais un hybride.

**Idée 29 : Keep comme outil d'enseignement**
Utiliser le Spaced Resurfacing (idée 3) + le Knowledge Podcast (idée 2) pour créer un mode **"Study Mode"** — Keep devient un outil d'apprentissage actif. L'étudiant prend des notes de cours, Keep gère la révision espacée, génère des quiz automatiques, et produit des résumés audio pour réviser en marchant.

### E — Eliminate (Éliminer)

**Idée 30 : Silent AI + Anti-Organization = "Zen Mode"**
Combiner les idées 13 et 15 en un mode radical : **aucune interface IA visible**. L'utilisateur voit uniquement ses notes brutes. Mais en arrière-plan, l'IA organise, connecte, et optimise tout. Quand l'utilisateur a besoin d'une note, elle est toujours exactement là où il s'attend à la trouver. L'IA est un **invisible concierge**.

### R — Reverse (Inverser)

**Idée 31 : Reverse Search → "Serendipity Engine"**
Pousser l'idée 11 plus loin : au lieu de chercher, vous recevez une **"feed de sérendipité"** — un flux continu de notes que vous ne cherchiez pas mais qui sont exactement ce dont vous avez besoin. Comme un fil Instagram, mais pour vos propres notes. Alimenté par le contexte temporel, l'historique récent, et les patterns comportementaux.

---

## Top 10 — Sélection finale

_Classement par combinaison : innovation, faisabilité technique (avec l'architecture existante), et différenciation marché_

| # | Nom | Description courte | Pourquoi c'est un pépites |
|---|-----|--------------------|---------------------------|
| 1 | **Keep Daily** | Page quotidienne personnalisée : révision, connexion, perspective, insight émotionnel | Combine 4 features en 1 rituel quotidien. Mécanique de rétention gaming. Réutilise Memory Echo, reformulation, embeddings existants. |
| 2 | **Spaced Resurfacing** | Les notes réapparaissent au moment optimal basé sur la courbe d'oubli | Transforme Keep en système d'apprentissage actif. Personne ne fait ça dans les apps de notes. Utilise les embeddings existants. |
| 3 | **Mood Tapestry** | Analyse émotionnelle longitudinale des notes avec visualisation | Positionnement unique santé mentale x notes. Privacy-first = avantage compétitif vs apps cloud. |
| 4 | **Ghost Writer** | Autocomplétion dans votre style personnel appris par IA | Clone d'écriture local (Ollama) = pitch marketing puissant. Plus vous écrivez, mieux c'est. |
| 5 | **Note Health Score** | Dashboard de santé de votre base de connaissance (0-100 par note) | Gamification subtile. Encourage l'entretien actif. Utilise les métadonnées IA existantes. |
| 6 | **Thought Trajectory** | Visualisation de l'évolution de votre pensée sur un sujet dans le temps | "Spotify Wrapped pour votre cerveau". Unique sur le marché. Utilise la recherche sémantique existante. |
| 7 | **Notebook Audiobook** | Résumé audio TTS d'un notebook entier | Consommer ses notes en marchant. Simple techniquement. Forte demande mobile. |
| 8 | **Note-as-Question** | L'IA génère 3 questions que vous n'avez PAS posées après chaque note | Transforme l'écriture passive en pensée active. Aligné avec "Zero-Friction Intelligence". |
| 9 | **Serendipity Engine** | Feed de notes pertinentes que vous ne cherchiez pas | Remplace le search par la découverte. "La note vient à vous." Utilise embeddings + contexte temporel. |
| 10 | **Reflective Journal Mode** | Mode thérapie réflexive guidée par IA avec suivi émotionnel | Nouveau segment de marché. Positionnement hybride unique. Privacy-first = confiance. |

---

## Features Sélectionnées — Spécifications Détaillées

_Les 3 features retenues après validation utilisateur, avec analyse d'intégration technique dans l'architecture existante_

---

### Feature A : Mood Tapestry (Tapis Émotionnel)

**Vision :** L'IA analyse le sentiment de chaque note au fil du temps et tisse un "tapis" visuel des états émotionnels de l'utilisateur. Détection de cycles, tendances, et patterns récurrents.

#### Expérience Utilisateur

**Vue principale :** Un ruban coloré horizontal dans le sidebar ou une page dédiée `/mood`. Chaque pixel représente une note, colorée par sentiment (rouge=anxieux, bleu=calme, vert=positif, jaune=enthousiaste, gris=neutre). Le tout forme un gradient continu chronologique.

**Insights IA :** Sous le ruban, 2-3 insights générés par IA :
- "Tes notes du dimanche soir sont 40% plus anxieuses que la moyenne"
- "Depuis mars, tes notes sur le travail sont devenues plus positives"
- "Cycle détecté : pics d'anxiété tous les 14 jours environ"

**Badge note :** Chaque note reçoit un petit indicateur coloré de son sentiment dominant.

**Notification proactive :** "Cette semaine, ton Mood Tapestry montre une tendance inhabituelle vers le négatif. Voici 3 notes positives de ton passé qui pourraient t'aider."

#### Architecture Technique

**Nouveau service :** `lib/ai/services/mood-tapestry.service.ts`

```
MoodTapestryService
├── analyzeSentiment(content: string, language: string) → SentimentResult
│   → Appelle provider.generateText() avec prompt structuré
│   → Retourne: { valence: number, arousal: number, emotions: string[], confidence: number }
│
├── analyzeNoteBatch(userId: string) → MoodSnapshot[]
│   → Lit toutes les notes de l'utilisateur (avec langue détectée)
│   → Batch processing avec rate limiting
│   → Stocke résultats dans NoteSentiment (nouveau modèle)
│
├── generateInsights(userId: string) → MoodInsight[]
│   → Analyse les patterns temporels des sentiments stockés
│   → Détecte cycles, tendances, anomalies
│   → Appelle provider.generateText() pour formuler les insights en langage naturel
│
├── getMoodTimeline(userId: string, period: 'week'|'month'|'year') → MoodDataPoint[]
│   → Agrège les sentiments par jour/semaine pour la visualisation
```

**Nouveau modèle Prisma :**
```prisma
model NoteSentiment {
  id              String   @id @default(cuid())
  noteId          String   @unique
  note            Note     @relation(fields: [noteId], references: [id], onDelete: Cascade)
  userId          String
  valence         Float    // -1.0 (négatif) à +1.0 (positif)
  arousal         Float    // 0.0 (calme) à 1.0 (intensif)
  dominantEmotion String   // "anxious", "joyful", "calm", "frustrated", "curious", "nostalgic", "neutral"
  emotions        String   // JSON array: ["curious", "hopeful", "anxious"]
  confidence      Float    // 0.0-1.0
  analyzedAt      DateTime @default(now())

  @@index([userId, analyzedAt])
  @@index([dominantEmotion])
}
```

**Extensions Prisma existantes :**
```prisma
model UserAISettings {
  // ... champs existants
  moodTapestry      Boolean  @default(true)    // ON/OFF toggle
  moodTapestryFrequency String @default('weekly') // 'daily'|'weekly'|'monthly'
}

model AiFeedback {
  // Réutiliser le modèle existant avec feature: 'mood_tapestry'
}
```

**Prompt IA (structure) :**
```
Analyze the emotional sentiment of this note. Return JSON:
{
  "valence": <float -1 to 1>,
  "arousal": <float 0 to 1>,
  "dominant_emotion": "<one of: anxious|joyful|calm|frustrated|curious|nostalgic|sad|excited|neutral>",
  "emotions": ["<emotion1>", "<emotion2>"],
  "confidence": <float 0 to 1>,
  "reasoning": "<brief explanation>"
}

Note content (in {language}):
"""
{content}
"""
```

**Points d'intégration :**
- **Trigger :** `analyzeSentiment()` appelé après la création/mise à jour d'une note (dans le même flow que `language-detection.service.ts`)
- **Batch :** Route admin ou cron pour analyser les notes existantes
- **UI :** Nouveau composant `components/ai/mood-tapestry.tsx` (ruban coloré + insights)
- **Settings :** Toggle dans `ai-settings-panel.tsx` + fréquence

**Faisabilité avec l'architecture existante :**
| Aspect | Compatible ? | Détail |
|--------|-------------|--------|
| Provider IA | ✅ | `provider.generateText()` — même pattern que paragraph-refactor |
| Embeddings existants | ✅ | Peut corréler sentiment avec similarité sémantique |
| Langue détectée | ✅ | `Note.language` déjà disponible pour adapter le prompt |
| Privacy-first | ✅ | Ollama local = analyse émotionnelle 100% locale |
| Feedback | ✅ | `AiFeedback` avec `feature: 'mood_tapestry'` |

**Risques :**
- L'analyse émotionnelle est subjective — le feedback utilisateur est critique pour ajuster
- Sur Ollama avec un petit modèle, la qualité sentiment peut être variable — prévoir un seuil de confiance minimum

---

### Feature B : Ghost Writer (Clone d'Écriture)

**Vision :** L'IA apprend votre style d'écriture à partir de toutes vos notes existantes. Quand vous écrivez, elle suggère des complétions dans VOTRE voix — pas une voix générique. Plus vous écrivez, plus elle vous ressemble.

#### Expérience Utilisateur

**Écriture assistée :** Dans l'éditeur de note, après chaque phrase, une suggestion fantôme (texte grisé) apparaît en inline — pas dans un panneau séparé. L'utilisateur appuie sur Tab pour accepter, Escape pour ignorer, ou continue à taper pour la remplacer.

**Voice Profile :** Dans les paramètres IA, un onglet "Mon Profil Vocal" montre :
- Votre ton dominant (formel, décontracté, technique, poétique)
- Longueur moyenne de phrases
- Vocabulaire préféré (top 20 mots distinctifs)
- Structures récurrentes (listes, questions, exclamations)
- Un bouton "Réanalyser mon style" pour recalibrer

**Apprentissage progressif :** Le profil s'améliore avec chaque note écrite. Un indicateur montre le "niveau de calibration" : "Profil basé sur 47 notes — Bonne calibration"

**Mode privacy :** Avec Ollama, le profil et les suggestions ne quittent jamais le serveur. Pitch marketing fort.

#### Architecture Technique

**Nouveau service :** `lib/ai/services/ghost-writer.service.ts`

```
GhostWriterService
├── buildVoiceProfile(userId: string) → VoiceProfile
│   → Lit les 50 dernières notes de l'utilisateur
│   → Analyse: longueur phrases, vocabulaire, structures, ton
│   → Appelle provider.generateText() pour extraire le profil stylistique
│   → Stocke dans VoiceProfile (nouveau modèle)
│
├── getSuggestion(userId: string, currentText: string, context: string) → string
│   → Charge le VoiceProfile de l'utilisateur
│   → Construit un prompt avec le profil + le texte en cours
│   → Appelle provider.generateText() avec maxTokens limité (50-100)
│   → Retourne la suggestion inline
│
├── updateProfileFromNote(userId: string, noteId: string) → void
│   → Après sauvegarde d'une note, met à jour incrémentalement le profil
│   → Recalcul: fréquence mots, patterns syntaxiques, ton
│
├── getVoiceProfileDisplay(userId: string) → VoiceProfileDisplay
│   → Retourne le profil formaté pour l'UI (ton, vocabulaire, stats)
```

**Nouveau modèle Prisma :**
```prisma
model VoiceProfile {
  id                  String   @id @default(cuid())
  userId              String   @unique
  user                User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  // Profil stylistique extrait par IA
  toneProfile         String   // JSON: { primary: "décontracté", secondary: "technique", formality: 0.3 }
  vocabularyProfile   String   // JSON: { topWords: [...], avgWordLength: 5.2, uniqueRatio: 0.7 }
  structureProfile    String   // JSON: { avgSentenceLength: 15, usesLists: true, usesQuestions: false, ... }
  writingPatterns     String   // JSON: { commonPhrases: [...], paragraphLength: "medium", ... }

  // Métadonnées
  notesAnalyzed       Int      @default(0)
  calibrationLevel    String   @default("low") // "low" | "medium" | "high" | "expert"
  lastAnalyzedAt      DateTime @default(now())
  createdAt           DateTime @default(now())
  updatedAt           DateTime @updatedAt

  @@index([userId])
}
```

**Extensions Prisma existantes :**
```prisma
model UserAISettings {
  // ... champs existants
  ghostWriter     Boolean  @default(true)    // ON/OFF toggle
}
```

**Prompt IA — Extraction de profil (buildVoiceProfile) :**
```
Analyze the writing style of these notes from the same author. Extract a writing profile as JSON:
{
  "tone": { "primary": "<tone>", "secondary": "<tone>", "formality": <0-1> },
  "vocabulary": { "top_words": ["<word>", ...], "avg_word_length": <number>, "unique_ratio": <0-1> },
  "structure": { "avg_sentence_length": <number>, "uses_lists": <bool>, "uses_questions": <bool>, "paragraph_style": "<short|medium|long>" },
  "patterns": { "common_phrases": ["<phrase>", ...], "punctuation_style": "<description>" }
}

Author's notes:
"""
{notes_concatenated}
"""
```

**Prompt IA — Suggestion inline (getSuggestion) :**
```
You are a ghost writer that perfectly mimics the author's writing style.

AUTHOR'S STYLE PROFILE:
- Tone: {toneProfile}
- Average sentence length: {avgSentenceLength} words
- Common phrases: {commonPhrases}
- The author writes in {language}

Continue this text in the author's EXACT voice. Write only the continuation (1-3 sentences), nothing else:

"""
{currentText}
"""
```

**Points d'intégration :**
- **Trigger :** `getSuggestion()` appelé après un délai d'inactivité de 1.5s dans l'éditeur (debounced)
- **Apprentissage :** `updateProfileFromNote()` appelé après sauvegarde d'une note
- **UI :** Nouveau composant `components/ai/ghost-writer-suggestion.tsx` (texte grisé inline dans l'éditeur)
- **Settings :** Toggle dans `ai-settings-panel.tsx` + page "Voice Profile"
- **API Route :** `app/api/ai/ghost-writer/route.ts` pour les suggestions en temps réel

**Faisabilité avec l'architecture existante :**
| Aspect | Compatible ? | Détail |
|--------|-------------|--------|
| Provider IA | ✅ | `provider.generateText()` — même pattern, mais nécessite low latency |
| Embeddings | ❌ pas nécessaire | Pas besoin d'embeddings pour cette feature |
| Notes existantes | ✅ | Source d'entraînement = toutes les notes de l'utilisateur |
| Privacy-first | ✅✅ | C'est LE cas d'usage parfait pour Ollama — votre style ne quitte pas le serveur |
| Feedback | ✅ | `AiFeedback` avec `feature: 'ghost_writer'` — accept/reject rate comme métrique |

**Risques :**
- **Latence critique :** Les suggestions inline doivent être < 500ms. Sur Ollama avec un petit modèle local, c'est jouable pour de courts textes. Sur OpenAI, c'est rapide mais moins privacy.
- **Qualité du profil :** Avec < 10 notes, le profil sera imprécis. Prévoir un minimum avant activation ou afficher un avertissement.
- **Sur-Ollama :** Les petits modèles (phi3-mini, etc.) peuvent avoir du mal à capturer un style subtil. Tester avec llama3.1+ pour de meilleurs résultats.

**Pitch marketing unique :**
> "Ghost Writer apprend votre voix. Votre clone d'écriture vit sur VOTRE serveur. Personne d'autre ne peut lire votre style — pas même nous. C'est le pouvoir de l'IA locale."

---

### Feature C : Thought Trajectory (Trajectoire de Pensée)

**Vision :** L'IA trace l'évolution de votre pensée sur un sujet au fil du temps. Vous visualisez comment vos idées ont branché, mergé, ou changé de direction. "Spotify Wrapped pour votre cerveau."

#### Expérience Utilisateur

**Vue Thinking Map :** Une page dédiée `/thinking-map` avec une visualisation interactive style "skill tree" ou constellation. Chaque noeud = un cluster de notes sur un sujet. Les liens montrent les connexions sémantiques. Le temps est représenté par la position ou la couleur (plus récent = plus lumineux).

**Timeline d'un sujet :** En cliquant sur un noeud, une vue détaillée montre l'évolution chronologique :
- "Mars 2025 : Première mention — curieux, exploratoire"
- "Juin 2025 : Approfondissement — 4 notes, ton plus technique"
- "Septembre 2025 : Changement — position plus critique"
- "Janvier 2026 : Consolidation — 2 notes de synthèse"

**Wrapped annuel/mensuel :** Une page "Mon Année en Pensées" style Spotify Wrapped :
- Top 5 sujets les plus explorés
- "Plus grande évolution" — sujet où votre pensée a le plus changé
- "Connexions surprises" — sujets éloignés que vous avez connectés
- Stats : nombre de notes, mots, langues utilisées, diversité émotionnelle

**Insight proactif :** "Ton opinion sur [X] a significativement changé ce mois-ci. Voir la trajectoire →"

#### Architecture Technique

**Nouveau service :** `lib/ai/services/thought-trajectory.service.ts`

```
ThoughtTrajectoryService
├── clusterNotesByTopic(userId: string) → TopicCluster[]
│   → Utilise les embeddings existants (Note.embedding)
│   → K-means ou clustering hiérarchique sur les vecteurs
│   → Identifie les topics/thèmes récurrents
│   → Appelle provider.generateText() pour nommer chaque cluster
│
├── buildTrajectory(userId: string, topicClusterId: string) → ThoughtTrajectory
│   → Trie les notes du cluster chronologiquement
│   → Analyse l'évolution sémantique entre les notes successives
│   → Détecte les "shifts" (changements de direction significatifs)
│   → Génère une narrative de l'évolution
│
├── detectEvolutionShifts(notes: Note[]) → EvolutionShift[]
│   → Compare les embeddings consécutifs dans un cluster
│   → Quand la distance cosinus dépasse un seuil → "shift" détecté
│   → provider.generateText() pour décrire le changement
│
├── generateWrapped(userId: string, period: 'month'|'year') → ThoughtWrapped
│   → Récapitulatif statistique + narratif
│   → Top topics, plus grande évolution, connexions surprises
│   → provider.generateText() pour la narration
│
├── getThinkingMap(userId: string) → ThinkingMapData
│   → Retourne les clusters + liens pour React Flow
│   → Positionnement basé sur similarité (t-SNE simplifié ou force-directed)
```

**Nouveau modèle Prisma :**
```prisma
model TopicCluster {
  id              String   @id @default(cuid())
  userId          String
  user            User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  name            String   // Nom généré par IA : "Intelligence Artificielle"
  description     String?  // Description IA du cluster
  centroidEmbedding String? // Embedding moyen du cluster (JSON number[])
  noteIds         String   // JSON array de note IDs

  // Stats
  noteCount       Int      @default(0)
  firstNoteAt     DateTime
  lastNoteAt      DateTime
  trajectorySummary String? // Résumé de l'évolution narrative

  createdAt       DateTime @default(now())
  updatedAt       DateTime @updatedAt

  @@index([userId])
  @@index([userId, lastNoteAt])
}

model ThoughtShift {
  id              String   @id @default(cuid())
  userId          String
  clusterId       String
  cluster         TopicCluster @relation(fields: [clusterId], references: [id], onDelete: Cascade)

  fromNoteId      String
  toNoteId        String
  semanticDistance Float    // Distance cosinus entre les deux notes
  description     String   // Description IA du shift : "Passage d'une position optimiste à critique"
  shiftType       String   // "deepening" | "reversal" | "branching" | "consolidation" | "abandonment"

  createdAt       DateTime @default(now())

  @@index([clusterId])
  @@index([userId])
}
```

**Extensions Prisma existantes :**
```prisma
model UserAISettings {
  // ... champs existants
  thoughtTrajectory    Boolean  @default(true)    // ON/OFF toggle
}
```

**Algorithme de clustering (simplifié) :**
```
1. Charger tous les embeddings de notes de l'utilisateur (déjà en DB)
2. Calculer la matrice de similarité cosinus (O(n²) — acceptable jusqu'à ~1000 notes)
3. Appliquer un clustering agglomératif :
   - Seuil de similarité > 0.65 → même cluster
   - Si un cluster dépasse 20 notes → sous-clustering
4. Pour chaque cluster, appeler provider.generateText() avec les titres/résumés pour nommer le topic
5. Stocker les résultats dans TopicCluster
```

**Algorithme de trajectoire :**
```
1. Trier les notes du cluster par date
2. Pour chaque paire de notes consécutives, calculer distance cosinus
3. Si distance > 0.3 → "shift" détecté → appeler IA pour décrire le changement
4. Classifier le shift : deepening (même direction), reversal (changement), branching (nouvel angle)
5. Générer un résumé narratif : "Vous avez commencé par X, puis évolué vers Y"
```

**Points d'intégration :**
- **Trigger :** Recalcul périodique (cron ou on-demand) — pas en temps réel
- **Embeddings :** Utilise les embeddings DÉJÀ stockés dans `Note.embedding` — zéro coût IA supplémentaire pour le clustering
- **IA générative :** Uniquement pour nommer les clusters, décrire les shifts, et générer les narrations
- **UI :** `app/thinking-map/page.tsx` avec React Flow (déjà prévu dans le roadmap Memory Echo V2)
- **Settings :** Toggle dans `ai-settings-panel.tsx`

**Faisabilité avec l'architecture existante :**
| Aspect | Compatible ? | Détail |
|--------|-------------|--------|
| Embeddings existants | ✅✅ | Cœur de la feature — `Note.embedding` déjà disponible |
| Recherche sémantique | ✅ | `cosineSimilarity()` déjà implémenté dans utils |
| Memory Echo | ✅ | Complémentaire — Echo trouve des connexions, Trajectory montre l'évolution |
| React Flow | ✅ | Déjà prévu dans le roadmap Memory Echo V2 |
| Provider IA | ✅ | Uniquement pour naming et narration — faible usage |
| Privacy-first | ✅ | Calculs de similarité entièrement locaux |

**Risques :**
- **Performance O(n²) :** La matrice de similarité sur 1000+ notes sera lente. Solution : pré-calculer et cacher les clusters, recalcul mensuel seulement.
- **Qualité du clustering :** Le seuil de similarité est empirique. Prévoir un mode "demo" avec seuil abaissé (comme Memory Echo).
- **Embeddings manquants :** Les notes sans embeddings seront invisibles. Nécessite un batch embedding préalable.

---

## Matrice de Dépendances entre Features

```
                  Mood    Ghost    Thought
                  Tapestry Writer   Trajectory
                  ─────── ──────── ──────────
Note.embedding      -       ❌       ✅✅
Note.language       ✅       -        -
provider.generate   ✅✅     ✅✅      ✅
provider.embeddings  -       ❌      ✅✅
cosineSimilarity     -       ❌      ✅✅
React Flow          ❌       ❌      ✅
Nouveau modèle DB   ✅       ✅       ✅✅
UserAISettings      ✅       ✅       ✅
AiFeedback          ✅       ✅       ✅
```

## Ordre d'Implémentation Recommandé

1. **Mood Tapestry** en premier — le plus autonome, pas de dépendance aux embeddings, feedback rapide
2. **Ghost Writer** en second — nécessite un volume minimum de notes, mais architecture simple
3. **Thought Trajectory** en dernier — le plus complexe (clustering + React Flow), mais capitalise sur Mood Tapestry (corrélation sentiment/évolution) et les embeddings existants

---

## Références et Sources d'Inspiration

- **Google NotebookLM** — AI podcast generation from notes
- **Mem.ai** — Self-organizing AI memory
- **Limitless (Rewind)** — Ambient capture
- **Anki / SuperMemo** — Spaced repetition algorithms
- **Personal.ai** — Digital twin / personal AI clone
- **Whoop / Oura Ring** — Recovery scores, nudge theory, JITAI
- **Spotify Wrapped / DNA** — Personalized data storytelling
- **Reflect** — Frictionless AI voice notes
- **Khoj** — Open-source AI personal assistant
- **Fabric** — AI-first second brain

