Version 1.6.2 - Retry on errors and section error tracking

New features:
- Add --retry-on-errors option to automatically retry failed pages
- Track export errors per section (HasExportErrors flag in manifest)
- Sections with errors are forced to [LOAD] on next incremental export

Bug fixes:
- Fix pages in error disappearing when section is [SKIP]
- Failed pages are now properly retried on subsequent exports

Configuration:
- RetryOnErrors: Enable automatic retry loop (default: false)
- MaxRetryIterations: Max retry attempts (default: 10)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: OlivierSala

ClaudeDocs/faq.md

@@ -47,10 +47,149 @@ error NETSDK1045: le SDK .NET actuel ne prend pas en charge le ciblage .NET 10.0
 
 ---
 
+### Application plante au démarrage - appSettings.json introuvable (SingleFile publish)
+
+**Problème**: L'application compilée en Release (SingleFile) plante avec l'erreur:
+```
+System.IO.FileNotFoundException: The configuration file 'appSettings.json' was not found
+```
+
+**Cause**: Les fichiers de configuration (`appSettings.json`, `LICENSE`, fichiers de traduction) étaient intégrés dans l'exécutable SingleFile au lieu d'être copiés séparément. L'application ne pouvait pas les lire car elle cherche ces fichiers sur le disque.
+
+**Solution**: Ajouter `<ExcludeFromSingleFile>true</ExcludeFromSingleFile>` dans le fichier `.csproj` pour chaque fichier devant rester externe:
+```xml
+<None Update="appSettings.json">
+  <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+  <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+</None>
+```
+
+Cela s'applique à:
+- `appSettings.json`
+- `LICENSE`
+- `Resources/trad.*.json` (fichiers de traduction)
+
+**Corrigé dans**: v1.6.1
+
+---
+
 ### Fichier manifeste corrompu ou incompatible
 
 **Problème**: Le manifeste `.export-manifest.json` semble corrompu ou génère des erreurs.
 
 **Solution**: Supprimer le fichier `.export-manifest.json` du dossier d'export et relancer avec `--incremental`. Un nouveau manifeste sera créé avec un export complet.
 
 ---
+
+### Export incrémental - Optimisation Phase 1 (v2.0 du manifeste)
+
+**Problème**: La Phase 1 de l'export (construction de l'arborescence) était lente car elle chargeait les pages de toutes les sections, même si aucune modification n'avait eu lieu.
+
+**Solution implémentée**: Le manifeste v2.0 stocke maintenant les métadonnées des sections en plus des pages. Lors d'un export incrémental:
+- Seules les sections modifiées ou nouvelles déclenchent un appel à OneNote pour charger leurs pages
+- Les sections inchangées utilisent les données en cache du manifeste
+- Gains de performance estimés: 80-99% selon le % de sections modifiées
+
+**Comportement de migration**:
+- Les manifestes v1.0 existants sont automatiquement migrés en v2.0
+- Après migration, le premier export scanne toutes les sections (comportement normal)
+- Les exports suivants bénéficient de l'optimisation
+
+**Messages dans les logs**:
+- `[SKIP]` - Section inchangée, pages récupérées depuis le cache
+- `[NEW]` - Nouvelle section détectée
+- `[LOAD]` - Section modifiée, pages chargées depuis OneNote
+
+**Structure du manifeste v2.0**:
+```json
+{
+  "version": "2.0",
+  "sections": {
+    "section-onenote-id": {
+      "title": "Section Name",
+      "oneNoteId": "...",
+      "lastModificationDate": "2024-01-15T10:30:00",
+      "path": "Notebook/Section",
+      "isSectionGroup": false
+    }
+  },
+  "pages": {
+    "page-onenote-id": {
+      "title": "Page Title",
+      "sectionId": "section-onenote-id",
+      ...
+    }
+  }
+}
+```
+
+---
+
+### Export incrémental - Reprise après interruption
+
+**Problème**: Si l'export est interrompu (Ctrl+C, crash, etc.), les pages déjà exportées étaient considérées comme "nouvelles" au relancement car le manifeste n'était sauvegardé qu'à la fin.
+
+**Solution implémentée**: Le manifeste est maintenant sauvegardé après chaque page exportée avec succès. Cela permet:
+- De reprendre l'export là où il s'était arrêté
+- De ne pas ré-exporter les pages déjà traitées lors de la session interrompue
+- Une progression fiable même en cas d'interruption
+
+**Comportement**:
+- Chaque page exportée est immédiatement enregistrée dans le manifeste
+- Au relancement, les pages déjà exportées sont détectées comme "unchanged" et ignorées
+- Légère augmentation des écritures disque (1 sauvegarde/page au lieu de 1 à la fin)
+
+---
+
+### Export incrémental - Boucle automatique sur erreurs
+
+**Problème**: Lorsque des pages échouent à l'export (erreurs OneNote, pages corrompues, non synchronisées), il fallait relancer manuellement l'export pour réessayer.
+
+**Solution implémentée**: Nouvelle option `--retry-on-errors` qui boucle automatiquement tant qu'il y a des erreurs.
+
+**Utilisation**:
+- CLI : `OneNoteMdExporter.exe --incremental --retry-on-errors`
+- Interactif : Répondre `[2]` à la question "Voulez-vous activer la boucle automatique en cas d'erreurs ?"
+- appSettings.json : `"RetryOnErrors": true`
+
+**Protection contre les boucles infinies**:
+- Arrêt si aucun progrès (même nombre d'erreurs qu'à l'itération précédente)
+- Arrêt si nombre max d'itérations atteint (par défaut : 10, configurable via `MaxRetryIterations`)
+
+**Messages dans les logs**:
+- `*** Retry iteration X (Y errors remaining) ***` - Début d'une nouvelle itération
+- `--> Stopping retry: no progress made` - Arrêt car aucun progrès
+- `--> All pages exported successfully after X iterations` - Succès après plusieurs tentatives
+
+**Prérequis**:
+- Mode incrémental (`--incremental`) obligatoire pour que le retry fonctionne
+- Les pages en erreur ne sont pas ajoutées au manifeste, donc elles seront réessayées
+
+---
+
+### Export incrémental - Pages en erreur et sections [SKIP]
+
+**Problème**: Si une page échouait à l'export, elle n'était pas ajoutée au manifeste. Si la section parente n'avait pas changé, elle était marquée [SKIP] au prochain export et la page en erreur disparaissait complètement (non rechargée depuis OneNote).
+
+**Solution implémentée**: Le manifeste v2.0 stocke maintenant un flag `HasExportErrors` par section.
+- Quand une page échoue, sa section est marquée `HasExportErrors = true`
+- Au prochain export incrémental, les sections avec `HasExportErrors = true` sont forcées en [LOAD]
+- Les pages en erreur sont ainsi rechargées depuis OneNote et réessayées
+
+**Comportement attendu**:
+```
+# Premier export - erreur sur une page
+- [LOAD] Section A
+  - Page 1 ✓
+  - Page 2 ✗ (erreur)
+  - Page 3 ✓
+→ Section A marquée HasExportErrors=true dans le manifeste
+
+# Deuxième export - la section est forcée en LOAD
+- [LOAD] Section A  ← forcé car HasExportErrors=true
+  - [SKIP] Page 1
+  - [UPDATE] Page 2  ← réessayée
+  - [SKIP] Page 3
+```
+
+---

src/OneNoteMdExporter/Infrastructure/AppSettings.cs

@@ -78,6 +78,17 @@ public class AppSettings
         /// </summary>
         public static bool CleanupDeletedPages { get; set; } = true;
 
+        /// <summary>
+        /// When enabled, automatically retry export if there are pages with errors until all pages are exported successfully
+        /// or no progress is made (same number of errors as previous iteration)
+        /// </summary>
+        public static bool RetryOnErrors { get; set; } = false;
+
+        /// <summary>
+        /// Maximum number of retry iterations when RetryOnErrors is enabled (0 = unlimited)
+        /// </summary>
+        public static int MaxRetryIterations { get; set; } = 10;
+
 
         /*
          * Markdown rendering Settings

src/OneNoteMdExporter/Models/ExportManifest.cs

@@ -4,14 +4,21 @@
 namespace alxnbl.OneNoteMdExporter.Models
 {
     /// <summary>
-    /// Manifest file that tracks exported pages for incremental export
+    /// Manifest file that tracks exported pages and sections for incremental export
     /// </summary>
     public class ExportManifest
     {
+        /// <summary>
+        /// Current manifest format version
+        /// </summary>
+        public const string CurrentVersion = "2.0";
+
         /// <summary>
         /// Version of the manifest format
+        /// v1.0: Pages only
+        /// v2.0: Pages + Sections for Phase 1 optimization
         /// </summary>
-        public string Version { get; set; } = "1.0";
+        public string Version { get; set; } = CurrentVersion;
 
         /// <summary>
         /// OneNote ID of the notebook
@@ -33,12 +40,54 @@ public class ExportManifest
         /// </summary>
         public DateTime LastExportDate { get; set; }
 
+        /// <summary>
+        /// Dictionary of exported sections, keyed by OneNote section ID (v2.0+)
+        /// </summary>
+        public Dictionary<string, SectionManifestEntry> Sections { get; set; } = new Dictionary<string, SectionManifestEntry>();
+
         /// <summary>
         /// Dictionary of exported pages, keyed by OneNote page ID
         /// </summary>
         public Dictionary<string, PageManifestEntry> Pages { get; set; } = new Dictionary<string, PageManifestEntry>();
     }
 
+    /// <summary>
+    /// Entry for a single exported section in the manifest (v2.0+)
+    /// </summary>
+    public class SectionManifestEntry
+    {
+        /// <summary>
+        /// Title of the section
+        /// </summary>
+        public string Title { get; set; }
+
+        /// <summary>
+        /// OneNote ID of the section
+        /// </summary>
+        public string OneNoteId { get; set; }
+
+        /// <summary>
+        /// Last modification date from OneNote
+        /// </summary>
+        public DateTime LastModificationDate { get; set; }
+
+        /// <summary>
+        /// Relative path of the section within the notebook hierarchy
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// Whether this is a section group (true) or a regular section (false)
+        /// </summary>
+        public bool IsSectionGroup { get; set; }
+
+        /// <summary>
+        /// Whether the last export had errors for pages in this section.
+        /// If true, the section will be reloaded from OneNote on next incremental export.
+        /// </summary>
+        public bool HasExportErrors { get; set; }
+    }
+
     /// <summary>
     /// Entry for a single exported page in the manifest
     /// </summary>
@@ -54,6 +103,11 @@ public class PageManifestEntry
         /// </summary>
         public string OneNoteId { get; set; }
 
+        /// <summary>
+        /// OneNote ID of the parent section (v2.0+)
+        /// </summary>
+        public string SectionId { get; set; }
+
         /// <summary>
         /// Last modification date from OneNote
         /// </summary>

src/OneNoteMdExporter/Models/SectionDiff.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+
+namespace alxnbl.OneNoteMdExporter.Models
+{
+    /// <summary>
+    /// Represents the differences between current OneNote sections and last export manifest
+    /// Used to optimize Phase 1 by only loading pages from modified sections
+    /// </summary>
+    public class SectionDiff
+    {
+        /// <summary>
+        /// Sections that are new (not in the previous manifest)
+        /// </summary>
+        public List<Section> NewSections { get; set; } = new List<Section>();
+
+        /// <summary>
+        /// Sections that have been modified since the last export
+        /// </summary>
+        public List<Section> ModifiedSections { get; set; } = new List<Section>();
+
+        /// <summary>
+        /// Sections that have not changed since the last export
+        /// </summary>
+        public List<Section> UnchangedSections { get; set; } = new List<Section>();
+
+        /// <summary>
+        /// Sections that were in the previous manifest but no longer exist in OneNote
+        /// </summary>
+        public List<SectionManifestEntry> DeletedSections { get; set; } = new List<SectionManifestEntry>();
+
+        /// <summary>
+        /// Total number of sections requiring page loading (new + modified)
+        /// </summary>
+        public int SectionsToLoad => NewSections.Count + ModifiedSections.Count;
+
+        /// <summary>
+        /// Total number of sections
+        /// </summary>
+        public int TotalSections => NewSections.Count + ModifiedSections.Count + UnchangedSections.Count;
+    }
+}

src/OneNoteMdExporter/OneNoteMdExporter.csproj

@@ -7,7 +7,7 @@
     <RuntimeIdentifier>win-x86</RuntimeIdentifier>
     <PublishReadyToRun>true</PublishReadyToRun>
     <PublishTrimmed>False</PublishTrimmed>
-    <Version>1.6.1</Version>
+    <Version>1.6.2</Version>
     <PackageId>OneNoteMdExporter</PackageId>
     <Authors>alxnbl</Authors>
     <Company />