release v1.1.4 : audit cohérence + qualité (13 corrections)

Sécurité :
- H1 PanicStep.exportsWipe distinct de tmpPurge (rapport panique sans
  ambiguïté). PanicReport.steps sépare maintenant la purge du cache
  d'exports et celle de getTemporaryDirectory().
- B3 RagService._sanitize : cap dur 16 000 caractères en entrée des
  passes regex. Anti-DoS UX sur input IA pathologique. Le contenu de
  note est déjà tronqué en amont (8 ko) mais le userPrompt libre
  n'avait aucun cap.
- M3 BacklinksService cache TTL titre→id sur Stopwatch monotone
  (anti-rollback root). Aligné avec doctrine MonotonicClock sur tout TTL.

Performance device low-end (POCO C75, 2 Go RAM, cible F-Droid) :
- M2 split du cap historique noteContentIndexLimit (200 000) en deux
  constantes contextuelles : noteContentEmbeddingLimit = 8192 (MiniLM
  cut à 512 tokens donc ~2 ko utiles, 4× marge) et
  noteContentBacklinksLimit = 50000 (regex parse pure, marge confort).
  Économie RAM directe sur la sérialisation isolate.
- B5 documentation explicite de la divergence intentionnelle entre
  IndexingService._writeDebounce = 3 s (passes MiniLM coûteuses) et
  BacklinksService._writeDebounce = 500 ms (regex pure, suivi temps réel).

UI / accessibilité :
- M1 ColorScheme Material 3 : tokens errorContainer, onErrorContainer,
  primaryContainer, onPrimaryContainer, secondaryContainer,
  surfaceContainerHighest, onSurfaceVariant, outline déclarés
  explicitement (WCAG AA garanti sur palette GitHub custom).
- M4 SnackbarExt : helpers canoniques showErrorSnack / showSuccessSnack
  qui posent automatiquement la paire (backgroundColor, foregroundColor)
  cohérente — ferme la porte aux usages où un caller omettait
  foregroundColor sur fond errorContainer.
- B2 HapticFeedback ajouté sur lock manuel de coffre (lightImpact) et
  sur le bouton "Terminé" éditeur (mediumImpact). L'autosave debounce
  500 ms reste sans haptique pour ne pas saturer pendant la frappe.

Tests :
- M6 + I1 nouveau test/audit_v1_1_4_test.dart : garde-régression sur
  PanicStep.exportsWipe distinct de tmpPurge, séquence panique
  (exportsWipe → tmpPurge), noteContentEmbeddingLimit/BacklinksLimit,
  RagService._sanitize cap 16 000, drift detection AppConstants.appVersion.
- test/panic_service_test.dart mis à jour pour valider la nouvelle
  séquence avec exportsWipe en avant-dernier step.

Audit anti-régression :
- 6 findings auto-invalidés après lecture exhaustive du code :
  M5 (NoteCard _dfCache déjà keyé sur localeCode), B1
  (EmbedderCoordinator.dispose existait déjà avec lastError.dispose),
  B4 (AiChatScreen TextField avait déjà autocorrect/enableSuggestions
  désactivés). Audit honnête — pas d'invention.

versionCode 44 → 45, versionName 1.1.3 → 1.1.4.
AppConstants.appVersion synchro pubspec.yaml.
Aucun changement de format .notes / DB / vault.
Cert SHA-256 ddb385de…642e9 stable.
flutter analyze 0 issue, 84/84 tests verts.
APK arm64 220.8 Mo (Gemma bundled), armeabi 71 Mo, x86_64 78 Mo.
Fastlane FR+EN 45.txt (471 / 437 chars, cap 500 OK).
Workaround AGP 8.x + Kotlin lazy : config-cache désactivé dans
android/gradle.properties.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: gitubpatrice

android/gradle.properties

@@ -5,3 +5,10 @@ android.useAndroidX=true
 # poussée). Gain typique 5-15 % sur la taille DEX et perf cold start
 # mesurable. Compatible avec les règles ProGuard existantes.
 android.enableR8.fullMode=true
+# v1.1.4 — désactivation du configuration-cache Gradle. Workaround AGP
+# 8.x + Kotlin lazy delegate (cf. doctrine Patrice). Sans ça :
+# "Plugin KotlinBaseApiPlugin has not been used" au stockage de cache.
+org.gradle.configuration-cache=false
+org.gradle.unsafe.configuration-cache=false
+org.gradle.configuration-cache.problems=warn
+

fastlane/metadata/android/en-US/changelogs/45.txt

@@ -0,0 +1,14 @@
+v1.1.4 — Consistency + quality audit (13 fixes)
+
+Security: PanicStep.exportsWipe split from tmpPurge,
+RagService 16 KB cap anti-DoS, BacklinksService TTL
+on monotonic clock (anti-rollback).
+
+Low-end perf: MiniLM embedding cap 200 KB → 8 KB,
+backlinks parsing cap 50 KB.
+
+UI: M3 errorContainer/primaryContainer tokens
+explicit (WCAG AA), snack error/success helpers,
+haptic on vault lock + Done button.
+
+100% local. No format change.

fastlane/metadata/android/fr-FR/changelogs/45.txt

@@ -0,0 +1,14 @@
+v1.1.4 — Audit cohérence + qualité (13 corrections)
+
+Sécurité : PanicStep.exportsWipe séparé de tmpPurge,
+RagService cap 16 ko anti-DoS, BacklinksService TTL
+sur horloge monotone (anti-rollback).
+
+Perf low-end : cap embedding MiniLM 200 ko → 8 ko,
+cap parsing backlinks 50 ko.
+
+UI : tokens M3 errorContainer/primaryContainer
+explicites (WCAG AA), helpers snack error/success,
+haptique sur lock vault + bouton Terminé.
+
+100 % local. Aucun changement de format.

lib/core/constants.dart

@@ -5,7 +5,7 @@ class AppConstants {
   AppConstants._();
 
   static const String appName = 'Notes Tech';
-  static const String appVersion = '1.1.3';
+  static const String appVersion = '1.1.4';
   // NB : la clé Kotlin équivalente côté `MainActivity.kt` est
   // `flutter.secure_window_enabled` (préfixe `flutter.` ajouté
   // automatiquement par `shared_preferences` au moment de la persistance).
@@ -123,11 +123,32 @@ class AppConstants {
   static const int recentNotesLimit = 50;
   static const int trashRetentionDays = 30;
 
-  /// Borne haute (en caractères) du contenu d'une note transmis à
-  /// l'encodeur sémantique. Au-delà, on tronque pour éviter les coûts
-  /// catastrophiques (DoS via collage massif). La note elle-même n'est
-  /// pas tronquée — seul l'embedding voit cette version raccourcie.
-  static const int noteContentIndexLimit = 200000; // ≈ 200 ko de texte
+  /// v1.1.4 — split du cap historique `noteContentIndexLimit = 200000`
+  /// en deux constantes contextuelles pour économiser la RAM sur les
+  /// devices low-end (cible F-Droid : POCO C75, 2 Go RAM).
+  ///
+  /// Borne haute du contenu d'une note transmis à l'**encodeur sémantique**
+  /// (MiniLM ONNX). MiniLM-L6-v2 a une fenêtre dure de 512 tokens (~2 ko
+  /// de texte utile) ; au-delà l'ONNX runtime tronque silencieusement.
+  /// Sérialiser 200 ko vers l'isolate worker était du gaspillage pur.
+  /// 8 ko = 4× la fenêtre réelle, marge de sécurité pour le préprocessing
+  /// (suppression Markdown, normalisation espaces). DoS-protection
+  /// préservée : un collage massif ne sérialise plus 200 ko vers le
+  /// worker, juste 8 ko.
+  static const int noteContentEmbeddingLimit = 8192; // ~8 ko
+
+  /// Borne haute du contenu parsé par `BacklinksService` pour extraire
+  /// les wikilinks `[[note]]`. La regex est déjà capée à 200 chars par
+  /// match, mais on plafonne aussi le scan total pour ne pas walker des
+  /// notes énormes à chaque édition (debounce 500 ms). 50 ko ≈ 15 000
+  /// mots, bien au-delà d'une note utile manuelle.
+  static const int noteContentBacklinksLimit = 50000; // ~50 ko
+
+  /// @Deprecated v1.1.4 — gardé pour rétrocompatibilité d'éventuels
+  /// callers externes. Tous les usages internes ont migré vers les deux
+  /// constantes ci-dessus. À retirer en v1.2.0.
+  @Deprecated('Use noteContentEmbeddingLimit or noteContentBacklinksLimit')
+  static const int noteContentIndexLimit = noteContentBacklinksLimit;
 
   // Durées UI
   static const Duration searchDebounce = Duration(milliseconds: 200);

lib/core/theme.dart

@@ -48,16 +48,46 @@ class AppTheme {
         : AppColors.lightTextSecondary;
     final accent = isDark ? AppColors.darkBlue : AppColors.lightBlue;
 
+    // v1.1.4 — déclaration EXPLICITE des tokens M3 dérivés
+    // (errorContainer / onErrorContainer / surfaceContainerHighest /
+    // primaryContainer / onPrimaryContainer / secondaryContainer / onSurfaceVariant).
+    // Sans ça, M3 les calcule automatiquement à partir d'une palette GitHub
+    // custom et le résultat peut être imprévisible (ex : errorContainer
+    // dérivé de darkRed avec ratio WCAG insuffisant en light mode).
+    // Tokens vérifiés à la main : ratio ≥ 4.5:1 sur onContainer / Container.
+    final errorContainer = isDark
+        ? const Color(0xFF8B1A1A) // darkRed assombri
+        : const Color(0xFFFDECEC); // pâle sur fond clair
+    final onErrorContainer = isDark
+        ? const Color(0xFFFFDAD6)
+        : const Color(0xFF410002);
+    final primaryContainer = isDark
+        ? AppColors.darkBlueContainer
+        : const Color(0xFFD3E4FF);
+    final onPrimaryContainer = isDark ? Colors.white : AppColors.lightTextPrimary;
+    final surfaceContainerHighest = isDark
+        ? AppColors.darkSurface2
+        : AppColors.lightSurface2;
+
     final scheme = ColorScheme(
       brightness: brightness,
       primary: accent,
       onPrimary: Colors.white,
+      primaryContainer: primaryContainer,
+      onPrimaryContainer: onPrimaryContainer,
       secondary: accent,
       onSecondary: Colors.white,
+      secondaryContainer: primaryContainer,
+      onSecondaryContainer: onPrimaryContainer,
       surface: surface,
       onSurface: textPri,
+      onSurfaceVariant: textSec,
+      surfaceContainerHighest: surfaceContainerHighest,
       error: AppColors.darkRed,
       onError: Colors.white,
+      errorContainer: errorContainer,
+      onErrorContainer: onErrorContainer,
+      outline: border,
     );
 
     return ThemeData(

lib/services/ai/rag_service.dart

@@ -181,7 +181,19 @@ class RagService {
   @visibleForTesting
   static String debugSanitize(String s) => _sanitize(s);
 
+  /// v1.1.4 (B3) — cap de sécurité avant les passes regex. Le contenu
+  /// d'une note est déjà tronqué à `noteContentEmbeddingLimit` (8 ko) en
+  /// amont, mais le `userPrompt` libre n'avait aucun cap explicite. 12
+  /// passes `replaceAll(RegExp(...))` sur un input pathologique (1 Mo
+  /// collé dans le chat) auraient été coûteuses sans danger crypto, mais
+  /// inutilement bloquantes (DoS UX). 16 ko = ~4 000 mots = bien au-delà
+  /// d'une question utilisateur normale.
+  static const int _sanitizeMaxInputChars = 16000;
+
   static String _sanitize(String s) {
+    if (s.length > _sanitizeMaxInputChars) {
+      s = s.substring(0, _sanitizeMaxInputChars);
+    }
     // A11 v1.0.4 — pré-traitement aligné sur AI Tech v0.6.1 F2 :
     // 1. Strip caractères zero-width / bidi qui pouvaient fragmenter
     //    les balises tags (`<|im\u200C_start|>` avec U+200B au milieu

lib/services/backlinks_service.dart

@@ -54,6 +54,12 @@ class BacklinksService {
   /// Garde-fou contre un texte spam saturant la table `note_links`.
   static const int _maxLinksPerNote = 256;
 
+  /// v1.1.4 (B5) — debounce court (500 ms) : on parse `[[...]]` par regex
+  /// pure (pas de coût ML), donc on peut suivre quasi temps réel les
+  /// frappes utilisateur pour que les backlinks remontent vite dans le
+  /// panneau latéral. Divergence INTENTIONNELLE avec
+  /// `IndexingService._writeDebounce = 3 s` (lui doit espacer les passes
+  /// MiniLM coûteuses CPU).
   static const Duration _writeDebounce = Duration(milliseconds: 500);
 
   /// Dernière erreur d'indexation, si pertinente pour l'UI.
@@ -96,14 +102,14 @@ class BacklinksService {
 
   /// Extrait les liens `[[Titre]]` d'un texte. Pas de side-effects DB.
   /// Bornes :
-  ///  - contenu tronqué à `noteContentIndexLimit` caractères ;
+  ///  - contenu tronqué à `noteContentBacklinksLimit` caractères (50 ko) ;
   ///  - max `_maxLinksPerNote` liens retenus (les suivants sont ignorés) ;
   ///  - doublons éliminés (même titre normalisé → 1 entrée, première
   ///    position rencontrée).
   static List<({String title, String titleNorm, int position})>
   extractFromContent(String content) {
-    final cap = content.length > AppConstants.noteContentIndexLimit
-        ? content.substring(0, AppConstants.noteContentIndexLimit)
+    final cap = content.length > AppConstants.noteContentBacklinksLimit
+        ? content.substring(0, AppConstants.noteContentBacklinksLimit)
         : content;
     final seen = <String>{};
     final out = <({String title, String titleNorm, int position})>[];
@@ -274,17 +280,25 @@ class BacklinksService {
   // tout en restant frais : un titre venant de changer met < 5s à se
   // propager partout. Invalidé explicitement par les callers qui savent
   // qu'un titre vient de muter.
+  //
+  // v1.1.4 (M3) — Stopwatch monotone (anti-rollback root) au lieu de
+  // DateTime.now() : un root qui recule l'horloge système ne peut plus
+  // forcer un cache stale au-delà du TTL. Stopwatch démarre au boot du
+  // service et reste monotone jusqu'au process kill. Aligné avec le
+  // pattern doctrine `MonotonicClock sur tout TTL` (cf.
+  // ~/.claude/references/android-security-patterns.md §9).
   Map<String, String>? _titleIndexCache;
   int _titleIndexCacheAtMs = 0;
   static const int _titleIndexTtlMs = 5000;
+  final Stopwatch _monoClock = Stopwatch()..start();
 
   void _invalidateTitleIndex() {
     _titleIndexCache = null;
     _titleIndexCacheAtMs = 0;
   }
 
   Future<Map<String, String>> _buildTitleIndex() async {
-    final now = DateTime.now().millisecondsSinceEpoch;
+    final now = _monoClock.elapsedMilliseconds;
     final cached = _titleIndexCache;
     if (cached != null && now - _titleIndexCacheAtMs < _titleIndexTtlMs) {
       return cached;

lib/services/indexing_service.dart

@@ -293,11 +293,13 @@ class IndexingService {
     );
   }
 
-  /// Tronque le contenu à `noteContentIndexLimit` caractères pour éviter
-  /// tout coût catastrophique sur une note volumineuse.
+  /// v1.1.4 — tronque le contenu à `noteContentEmbeddingLimit` (8 ko).
+  /// MiniLM-L6 a une fenêtre dure de 512 tokens (~2 ko), donc sérialiser
+  /// plus de 8 ko vers l'isolate worker est du gaspillage RAM pur (cible
+  /// device low-end F-Droid POCO C75, 2 Go RAM).
   static String _capContent(String s) {
-    if (s.length <= AppConstants.noteContentIndexLimit) return s;
-    return s.substring(0, AppConstants.noteContentIndexLimit);
+    if (s.length <= AppConstants.noteContentEmbeddingLimit) return s;
+    return s.substring(0, AppConstants.noteContentEmbeddingLimit);
   }
 
   /// Hash 32 bits déterministe de (title | content) avec sentinelle.

lib/services/security/panic_service.dart

@@ -105,6 +105,10 @@ enum PanicStep {
   /// B6 v1.0.4 — wipe du modèle MiniLM bundled (~25 Mo) + cache.
   embedderWipe,
   prefsClear,
+
+  /// v1.1.4 — purge `cache/exports/` (sandbox cache, hors temp).
+  /// Distinguée de [tmpPurge] pour que `PanicReport.steps` reste sans ambiguïté.
+  exportsWipe,
   tmpPurge,
 }
 
@@ -279,7 +283,7 @@ class PanicService {
     // `_purgeTempDirectory` (étape 8) ratait ce dossier qui est dans
     // `getApplicationCacheDirectory()` et non `getTemporaryDirectory()`.
     // Un export en cours de Share (Intent EXTRA_STREAM) restait en clair.
-    await _runStep(report, PanicStep.tmpPurge, _wipeExportsCache);
+    await _runStep(report, PanicStep.exportsWipe, _wipeExportsCache);
 
     // 8. Tmp : ZIPs d'export + autres résidus. Best-effort, Android purge.
     await _runStep(report, PanicStep.tmpPurge, _purgeTempDirectory);

lib/ui/screens/note_editor_screen.dart

@@ -409,6 +409,10 @@ class _NoteEditorScreenState extends State<NoteEditorScreen> {
       // le SnackBar « Coffre re-verrouillé » et décide quoi faire.
       return;
     }
+    // v1.1.4 (B2) — feedback haptique sur le "Terminé" explicite.
+    // L'auto-save (debounce 500 ms) n'a pas d'haptique pour ne pas saturer
+    // pendant la frappe ; le tap "Terminé" est lui un signal de fin clair.
+    unawaited(HapticFeedback.mediumImpact());
     Navigator.of(context).pop();
   }