@imenam/mcp-feature-analyzer 1.0.19 → 1.0.21

package/README.md

@@ -137,11 +137,11 @@ Quatorze outils. Les noms, descriptions et textes de résultat sont en anglais ;
 | Outil | Effet |
 |---|---|
 | `list_analyses` | Point d'entrée : les analyses regroupées par projet, chacune avec ses refs, ses constats ouverts par gravité, ses fichiers revus, son nombre de schémas et l'état de sa revue ; une revue soumise est « pending processing » tant que l'agent ne l'a pas marquée traitée, « processed at … » ensuite, avec la note du traitement ; une revue approuvée est « nothing to process ». `project` limite la liste à un projet (un nom inconnu liste les projets existants) ; `review_state` à un état de revue (`not_started`, `in_progress`, `files_reviewed`, `submitted`), aux revues soumises restant à traiter (`to_process`) ou qui n'attendent plus l'agent (`processed` : marquées traitées, ou approuvées). Invite l'agent à reprendre l'analyse existante d'une feature plutôt qu'à en créer une autre. Signale aussi les fichiers d'analyse illisibles. |
-| `create_analysis` | Calcule et fige le diff : `repo_path` (racine absolue du dépôt), `project` (projet ou feature, dossier de rangement, requis), `title`, `mode` (`branch` ou `working_tree`), `base` (requis en `branch`), `head` (en `branch`, défaut `HEAD`), `request_text` et `request_source` (la demande initiale : ticket, prompt). Renvoie l'identifiant et la liste des fichiers. |
-| `get_analysis` | Vue complète : projet, demande, vue d'ensemble, résumé, fichiers (revus ou non), constats avec statut et emplacement, remarques du relecteur, schémas (signalés quand leur tracé a des croisements), état de la revue. |
+| `create_analysis` | Calcule et fige le diff : `repo_path` (racine absolue du dépôt), `project` (projet ou feature, dossier de rangement, requis), `title`, `mode` (`branch` ou `working_tree`), `base` (requis en `branch`), `head` (en `branch`, défaut `HEAD`), `request_text` et `request_source` (la demande initiale : ticket, prompt), `follow_up_of` (voir [Revues de suivi](#revues-de-suivi)). Renvoie l'identifiant et la liste des fichiers. |
+| `get_analysis` | Vue complète : projet, demande, vue d'ensemble, résumé, fichiers (revus ou non), constats avec statut et emplacement, remarques du relecteur, schémas (signalés quand leur tracé a des croisements), état de la revue, et ses liens de suivi (analyse suivie avec le rang du tour, revue de suivi avec son état). |
 | `update_analysis` | Change `title`, `project`, la vue d'ensemble (`objective`, `approach`, `attention_points`), `summary` (les changements fonctionnels de la feature, une puce par changement, remplace toute la liste) ou la demande initiale (`request_text`, `request_source` ; `null` efface). Les champs absents sont conservés. |
 | `refresh_analysis` | Recalcule le diff avec le même dépôt, le même mode et les mêmes refs, après correction. Voir [Les deux modes de diff](#les-deux-modes-de-diff). |
-| `delete_analysis` | Supprime l'analyse et son diff figé. Le dépôt n'est pas touché. Supprime aussi une analyse listée comme illisible. |
+| `delete_analysis` | Supprime l'analyse et son diff figé. Le dépôt n'est pas touché. Supprime aussi une analyse listée comme illisible. Sa revue de suivi, si elle en a une, est conservée et devient une première revue. |
 
 La **vue d'ensemble** est l'analyse globale de l'agent : l'objectif fonctionnel de la feature, l'approche retenue (architecture, flux principal) et les points d'attention à vérifier en priorité. Sans vue d'ensemble, `objective` et `approach` sont requis ensemble pour la créer (`attention_points` vaut alors une liste vide s'il est omis) ; ensuite, chaque champ donné remplace le précédent. `objective: null` retire toute la vue d'ensemble. L'objectif figure aussi en tête du prompt de retour.
 
@@ -197,7 +197,7 @@ Chaque nœud a un `id`, un `label`, une forme `shape` (`box` par défaut, `pill`
 | Outil | Effet |
 |---|---|
 | `get_review_feedback` | Une fois la revue soumise : décision (`approve`, `request_changes`, `reject`), état du traitement (à traiter, ou traité avec sa date et sa note), constats et remarques retenus avec leur détail, et le prompt généré, recopié tel quel. Après une nouvelle soumission, il liste aussi ce qui a changé depuis la version soumise précédente (décision, constats et remarques ajoutés, modifiés ou retirés) et rappelle comment celle-ci avait été traitée. Avant la soumission, ou pendant que le relecteur modifie une revue soumise : l'avancement seul (fichiers revus, constats ignorés, remarques). Lecture seule. |
-| `mark_feedback_processed` | Marque traité le retour soumis, avec la date et une `note` facultative (« corrigé par 12785d6e3 et 1ff5baaad », « réponses données en conversation »). Sert quand `refresh_analysis` ne convient pas : analyse d'un commit précis corrigée dans d'autres commits, remarques auxquelles l'agent a répondu dans la conversation. Le retour reste lisible avec `get_review_feedback`. Refusé tant que la revue n'est pas soumise ; un nouveau marquage remplace le précédent. |
+| `mark_feedback_processed` | Marque traité le retour soumis, avec la date et une `note` facultative (« corrigé par 12785d6e3 et 1ff5baaad », « réponses données en conversation »). Sert quand `refresh_analysis` ne convient pas : analyse d'un commit précis corrigée dans d'autres commits, remarques auxquelles l'agent a répondu dans la conversation. Le retour reste lisible avec `get_review_feedback`. Refusé tant que la revue n'est pas soumise ; un nouveau marquage remplace le précédent. Le relecteur peut aussi marquer un retour traité depuis l'accueil de la GUI ; le traitement enregistre son auteur, et `get_review_feedback` l'indique (« by the agent » ou « by the reviewer »). |
 
 Le retour se lit **avant** `refresh_analysis`, qui le remplace par une revue vierge : le recalcul vaut traitement, puisqu'il relance la revue.
 
@@ -230,10 +230,22 @@ list_analyses       { review_state: "to_process" }  ← revues soumises restant
 get_review_feedback { analysis_id }                 ← décision, points retenus, prompt
   … l'agent corrige le code …
 refresh_analysis    { analysis_id }                 ← nouveau diff, nouveau tour de revue
-  ou, quand le diff reste tel quel (commit précis, réponses en conversation) :
-mark_feedback_processed { analysis_id, note: "corrigé par 12785d6e3" }
+  ou, quand les corrections sont dans d'autres commits (analyse d'un commit précis) :
+create_analysis { …, base: "<sha>^", head: "<sha>", follow_up_of: analysis_id }  ← revue de suivi
+  ou, quand rien n'est à relire (réponses en conversation) :
+mark_feedback_processed { analysis_id, note: "réponses données en conversation" }
 ```
 
+### Revues de suivi
+
+Une **revue de suivi** est une nouvelle analyse, créée avec `create_analysis` et `follow_up_of`, qui relit les corrections apportées au retour soumis d'une analyse précédente : typiquement les commits de correction d'une analyse qui porte sur un commit précis.
+
+- Seule une analyse dont la revue est soumise peut être suivie, et elle a **au plus une** revue de suivi : les tours forment une chaîne (tour 1 → tour 2 → …), et le tour suivant suit le dernier.
+- À la création du suivi, le retour de l'analyse suivie est marqué traité par l'agent s'il l'attendait encore, avec la note « Suivie par la revue « … » ». Une revue approuvée ou déjà traitée garde son marquage.
+- `get_analysis`, `list_analyses` et `get_review_feedback` indiquent les liens dans les deux sens ; `get_review_feedback` propose de créer la revue de suivi, et `mark_feedback_processed` le rappelle.
+- Dans la GUI, une analyse suivie quitte les filtres d'étape de l'accueil et ne reste visible que dans « Toutes ».
+- Il n'y a pas d'outil pour lier deux analyses après coup.
+
 ---
 
 ## L'interface
@@ -242,11 +254,11 @@ Thème sombre. La barre supérieure porte la marque (un clic ramène à l'accuei
 
 ### Accueil (`#/`)
 
-Les analyses sont rangées par projet, dans des sections repliables. L'en-tête d'un projet compte ses analyses par état de revue. Chaque analyse est une carte séparée des autres. Son titre s'affiche en entier sur toute la largeur et passe à la ligne s'il le faut. Dessous, sur une seconde ligne : ses refs, la date de sa dernière modification, la progression des fichiers revus, ses constats ouverts par gravité (exigences manquantes comprises, ce que dit l'infobulle) et son état de revue : « Non commencée », « En cours », « Fichiers revus » ou « Soumise », suivi de la décision, puis « Traitée » une fois que l'agent a marqué le retour traité (date et note en infobulle) ; la pastille disparaît dès que le relecteur modifie la revue, qui repasse en cours. Quand l'agent a marqué le retour traité, une ligne sous les références donne sa note et la date du traitement. Une colonne à gauche filtre la liste, chaque filtre avec son icône et son nombre d'analyses : « À relire » (par défaut, revues pas encore soumises), « Traitées par l'agent » (retour traité, corrections à vérifier ; ce filtre ressort en sarcelle tant qu'il n'est pas vide), « À traiter par l'agent » (retour soumis que l'agent n'a pas encore traité), « Approuvées », et « Toutes ». Les quatre premiers se partagent les analyses sans se recouvrir. Sous 900 px de large, les filtres passent au-dessus de la liste. L'accueil n'ouvre aucune analyse d'office ; sans analyse, il explique que l'agent les crée avec `create_analysis`.
+Les analyses sont rangées par projet, dans des sections repliables. L'en-tête d'un projet compte ses analyses par état de revue. Chaque analyse est une carte séparée des autres. Son titre s'affiche en entier sur toute la largeur et passe à la ligne s'il le faut. Dessous, sur une seconde ligne : ses refs, la date de sa dernière modification, la progression des fichiers revus, ses constats ouverts par gravité (exigences manquantes comprises, ce que dit l'infobulle) et son état de revue : « Non commencée », « En cours », « Fichiers revus » ou « Soumise », suivi de la décision, puis « Traitée » une fois que l'agent a marqué le retour traité (date et note en infobulle) ; la pastille disparaît dès que le relecteur modifie la revue, qui repasse en cours. Quand le retour est marqué traité, une ligne sous les références donne la note, l'auteur du marquage (l'agent, ou le relecteur) et la date. Dans le filtre « À traiter par l'agent », chaque carte porte à droite du titre un bouton « Marquer comme traité » : il ouvre une petite fenêtre avec une note facultative (Entrée confirme, Échap referme), et la revue passe dans « Traitées par l'agent », comme avec `mark_feedback_processed`. Le reste de la carte mène à l'analyse. Une analyse suivie porte la ligne « Nouvelle revue disponible : » avec un bouton au titre de sa revue de suivi et son état ; une revue de suivi porte « Revue faisant suite à : » avec un bouton au titre de l'analyse suivie et son rang (« tour 2 »). Une analyse suivie n'apparaît que dans « Toutes ». Une colonne à gauche filtre la liste, chaque filtre avec son icône et son nombre d'analyses : « À relire » (par défaut, revues pas encore soumises), « À traiter par l'agent » (retour soumis que l'agent n'a pas encore traité), « Traitées par l'agent » (retour traité, corrections à vérifier), « Approuvées », et « Toutes ». Les quatre premiers ne se recouvrent pas et laissent de côté les analyses qui ont une revue de suivi. Sous 900 px de large, les filtres passent au-dessus de la liste. L'accueil n'ouvre aucune analyse d'office ; sans analyse, il explique que l'agent les crée avec `create_analysis`.
 
 ### Écran Feature (`#/<id>`)
 
-Titre, mode et refs (un sha complet est abrégé à 7 caractères), nombre de fichiers, lignes ajoutées et supprimées, bouton « Commencer la revue » qui ouvre le premier fichier non revu. Quatre onglets, avec leur compteur : fichiers modifiés, constats **ouverts** (exigences manquantes comprises ; l'infobulle donne aussi le total), schémas :
+Titre, mode et refs (un sha complet est abrégé à 7 caractères), nombre de fichiers, lignes ajoutées et supprimées, bouton « Commencer la revue » qui ouvre le premier fichier non revu. Quand l'analyse fait partie d'une chaîne de revues, un bandeau suit l'en-tête : sur une analyse suivie, « Nouvelle revue disponible : » et un bouton au titre de sa revue de suivi, avec son état ; sur une revue de suivi, « Revue faisant suite à : » et un bouton au titre de l'analyse suivie, le rappel de son retour (date, décision, traitement) et les « Points du retour précédent à vérifier » (constats et remarques qu'il retenait, en lecture seule). La chaîne des tours (« Tour 1 → Tour 2 »), un lien par tour, accompagne la première ligne. Quatre onglets, avec leur compteur : fichiers modifiés, constats **ouverts** (exigences manquantes comprises ; l'infobulle donne aussi le total), schémas :
 
 - **Résumé** — la carte « Vue d'ensemble » (objectif, approche, points d'attention) quand l'agent l'a rédigée, « Ce que l'agent a fait », la demande initiale et sa source, la section « Constats ouverts » (compteurs par gravité, constats ouverts du plus grave au moins grave, lien « Voir les N constats, tous statuts confondus ») et « Copier le prompt pour l'agent » (tous les constats ouverts).
 - **Fichiers** — chaque fichier avec son statut, ses `+`/`−`, ses constats ouverts par gravité et son état de revue.
@@ -259,7 +271,8 @@ L'ajustement à la fenêtre ne descend jamais sous l'échelle **0,85** : en dess
 
 ### Écran Revue (`#/<id>/review/<chemin>`)
 
-- **Panneau des fichiers** — progression, fichiers groupés par dossier, état revu, pastilles des constats ouverts par gravité et, en bout de ligne, la lettre du statut git à la manière de VS Code : `M` modifié, `A` ajouté, `D` supprimé, `R` renommé, `U` non suivi (libellé complet en infobulle). Un nom trop long est tronqué au milieu (`reminder-sch…uler.ts`), l'extension reste visible et le chemin complet est en infobulle. Chaque pastille est un lien : elle ouvre le fichier sur son premier constat ouvert de cette gravité (`?line=N`) ; son infobulle le dit (« 3 constats mineurs ouverts — aller au premier »). Sa largeur se règle en glissant son bord droit (entre 200 et 600 px ; flèches gauche et droite quand la poignée a le focus, double-clic pour revenir à 280 px) et se conserve dans le navigateur d'un rechargement à l'autre. Le bouton en tête de l'en-tête du fichier masque ou réaffiche le panneau, pour toute la session : le diff s'élargit vers la gauche, la colonne de droite garde sa largeur. Il reste affiché quand le chemin demandé ne fait pas partie de l'analyse.
+- **Progression** — dans la barre supérieure, à gauche de « Terminer la revue » : « 3/7 revus » et une barre étroite, visibles quel que soit le défilement et même panneau des fichiers masqué.
+- **Panneau des fichiers** — nombre de fichiers, fichiers groupés par dossier, état revu, pastilles des constats ouverts par gravité et, en bout de ligne, la lettre du statut git à la manière de VS Code : `M` modifié, `A` ajouté, `D` supprimé, `R` renommé, `U` non suivi (libellé complet en infobulle). Un nom trop long est tronqué au milieu (`reminder-sch…uler.ts`), l'extension reste visible et le chemin complet est en infobulle. Chaque pastille est un lien : elle ouvre le fichier sur son premier constat ouvert de cette gravité (`?line=N`) ; son infobulle le dit (« 3 constats mineurs ouverts — aller au premier »). Sa largeur se règle en glissant son bord droit (entre 200 et 600 px ; flèches gauche et droite quand la poignée a le focus, double-clic pour revenir à 280 px) et se conserve dans le navigateur d'un rechargement à l'autre. Le bouton en tête de l'en-tête du fichier masque ou réaffiche le panneau, pour toute la session : le diff s'élargit vers la gauche, la colonne de droite garde sa largeur. Il reste affiché quand le chemin demandé ne fait pas partie de l'analyse.
 - **En-tête du fichier** — bascule du panneau des fichiers, chemin, `+`/`−`, statut, fichier précédent et suivant, « Remarque sur le fichier », « Marquer comme revu ».
 - **Diff** — code coloré selon le langage du fichier, déduit de son extension ou de son nom (grammaires de [Shiki](https://shiki.style), chargées à la demande) : le côté nouveau à partir du contenu complet du fichier quand le snapshot le conserve, sinon bloc par bloc ; les lignes supprimées bloc par bloc ; chaque correctif proposé séparément ; les lignes barrées par un correctif restent sans couleur. Un fichier dont le langage n'est pas reconnu s'affiche sans coloration ; une grammaire qui ne se charge pas est signalée dans la barre du diff. Numéros du côté nouveau et repère vertical à la couleur de la gravité le long des lignes visées par un constat. La barre du diff porte trois réglages, communs à tous les fichiers et conservés dans le navigateur d'un rechargement à l'autre : chacun est un bouton compact qui affiche sa valeur courante, et un clic ouvre la liste de ses choix, chacun avec son icône et une description d'une ligne (un clic dehors, Échap ou un défilement la referme). « Afficher » choisit entre « Modifications » (les blocs du diff git, entourés de leurs lignes de contexte) et « Fichier entier » (tout le fichier en un seul bloc : les lignes inchangées, tirées du contenu conservé, s'intercalent entre les modifications, ce qui donne à lire en entier une fonction modifiée en son milieu ; les deux autres sélecteurs s'y appliquent de la même façon, un correctif dont les lignes chevauchaient deux blocs s'y affiche, et « Copier une demande d'explication » porte alors sur tout le fichier). En « Fichier entier », une mini-carte de 22 px longe le bord droit du diff et reste à l'écran pendant le défilement : toute sa hauteur représente tout le fichier affiché. Sa piste de gauche place les lignes ajoutées (vert), supprimées (rouge), supprimées et ajoutées en vis-à-vis en vue « Côte à côte » (moitié rouge, moitié verte) ou seulement réindentées (violet) ; sa piste de droite porte un point par constat, à la couleur de sa gravité (atténué s'il n'est plus ouvert), et un point par ligne portant une remarque. Un cadre bleuté suit la portion visible. Le survol d'un repère en donne la description (« 12 lignes ajoutées · lignes 120 à 131 », « Constat 3 · Majeur » et son titre) ; un clic ou un glissé sur la carte fait défiler le diff jusqu'à l'endroit visé. « Fichier entier » est inactif pour un fichier dont le contenu n'est pas conservé ; la liste en donne la raison à la place de sa description. « Code » choisit entre « Unifié » (une seule colonne : lignes supprimées sur fond rouge au-dessus des lignes ajoutées sur fond vert), « Côte à côte » (ancien code à gauche avec ses numéros du côté ancien, nouveau code à droite : lignes de contexte des deux côtés, lignes supprimées et ajoutées appariées ligne à ligne, case hachurée en face d'une ligne sans vis-à-vis ; remarques, repères et lignes proposées par un correctif sont du côté droit, le bandeau d'un correctif sur toute la largeur) et « Nouveau code » (le code du côté nouveau seul, dans les mêmes blocs : les lignes supprimées ne sont pas affichées et les lignes ajoutées portent un fin filet vert à la place de leur fond et de leur marque ; une explication de code supprimé s'aligne alors sur la ligne voisine du bloc). « Correctifs » choisit entre « Sans correctif », « Avant / après » et « Code corrigé ». Le correctif proposé s'affiche à l'endroit où il s'applique : bandeau « Correctif proposé par l'agent — remplace les lignes X à Y » avec le numéro du constat et « Masquer le correctif », lignes visées barrées sur fond ambre, lignes proposées juste en dessous sur fond violet (marque « › », sans numéro). Le correctif est affiché d'office pour un constat ouvert ; masqué, ou pour un constat sans correctif, une pastille numérotée marque la première ligne visée. Un filet sarcelle longe les lignes décrites par une explication. En « Modifications », quand le contenu du fichier est conservé, l'en-tête de chaque bloc porte un réglage « −5 · N lignes · +5 » : « +5 » ajoute cinq lignes de contexte au-dessus et cinq en dessous du bloc, « −5 » les retire, et le compteur donne le nombre de lignes de contexte au-dessus de la première modification. Les lignes ajoutées s'insèrent sous l'en-tête et après le bloc, si bien que le réglage ne bouge pas à l'écran ; elles se distinguent par un fond plus sombre et un filet gris (« Contexte ajouté » dans la légende). Les lignes entre deux blocs vont d'abord au bloc du dessus ; quand plus aucune ligne masquée ne les sépare, les deux blocs n'en forment plus qu'un, sous un seul en-tête dont « +5 » et « −5 » s'appliquent à chacun des blocs réunis. « +5 » s'éteint quand le bloc atteint les bords du fichier. Le contexte choisi est propre à chaque fichier et dure le temps de la session. L'en-tête de chaque bloc porte aussi « Copier une demande d'explication » (icône du robot) : le bouton copie un prompt à coller dans la conversation de l'agent, qui situe le bloc (analyse, dépôt et refs, fichier, lignes des deux côtés, code tel que figé) et lui demande de l'expliquer en enregistrant ses explications avec `add_explanations`, ou `update_explanation` si une explication couvre déjà ces lignes. Deux correctifs dont les lignes se recouvrent ne s'affichent pas ensemble. Le fond ambre des lignes visées se distingue du rouge des lignes `−` supprimées par la feature. Une légende suit le diff, limitée aux fonds que la vue et le mode affichent : « Ajouté par la feature » (fond ou filet selon la vue), « Supprimé par la feature » (Unifié et Côte à côte), « Lignes remplacées par le correctif » (Avant / après), « Correctif proposé » ou « Correctif appliqué », « Code décrit par une explication ». Quand une ligne supprimée et la ligne ajoutée qui la remplace se ressemblent (la moitié de leurs mots au moins en commun), seules leurs parties modifiées sont surlignées, en rouge sur l'ancienne ligne et en vert sur la nouvelle, sans fond sur le reste de la ligne ; dans chaque suite de lignes supprimées puis ajoutées, la i-ème ligne supprimée est comparée à la i-ème ligne ajoutée, mot à mot. Une ligne sans correspondante proche garde son fond entier (« Partie modifiée de la ligne » dans la légende). Un clic sur un numéro de ligne ouvre la saisie d'une remarque sur cette ligne. Les exigences manquantes sans emplacement s'affichent en bandeau au-dessus du diff de chaque fichier ; le bandeau « N exigences manquantes » se replie, et reste replié pour la session.
 - **Affichage des correctifs** — le sélecteur « Correctifs », au-dessus du diff, propose trois modes, conservés d'un fichier à l'autre et d'un rechargement à l'autre :

package/dist/shared/follow-ups.d.ts

@@ -0,0 +1,36 @@
+import type { Analysis, AnalysisLink, FindingLocation, FollowUpLink, NoteLocation, Processing, ReviewDecision, Severity } from "./schemas/analysis.schema.js";
+/** Point retenu dans le retour d'une analyse, à vérifier dans sa revue de suivi. */
+export type FeedbackPoint = {
+    kind: "finding";
+    id: string;
+    severity: Severity | null;
+    title: string;
+    location: FindingLocation | null;
+} | {
+    kind: "note";
+    id: string;
+    text: string;
+    location: NoteLocation | null;
+};
+/** Analyse suivie, vue depuis sa revue de suivi : son retour et les points qu'il retenait. */
+export interface PreviousReview extends AnalysisLink {
+    submittedAt: string | null;
+    decision: ReviewDecision | null;
+    processed: Processing | null;
+    points: FeedbackPoint[];
+}
+/** Liens de suivi d'une analyse. */
+export interface AnalysisLinks {
+    /** Analyse dont celle-ci est la revue de suivi. */
+    previous: PreviousReview | null;
+    /** Revue de suivi de celle-ci. */
+    next: FollowUpLink | null;
+    /** Toutes les analyses de la chaîne, de la première revue à la dernière, celle-ci comprise. */
+    chain: AnalysisLink[];
+}
+/**
+ * Points retenus par le retour d'une analyse : constats (du plus grave au moins
+ * grave) puis remarques. Pour une revue rouverte par le relecteur, ceux de sa
+ * dernière version soumise ; aucun pour une revue jamais soumise.
+ */
+export declare function feedbackPoints(analysis: Pick<Analysis, "review" | "findings" | "notes">): FeedbackPoint[];

package/dist/shared/follow-ups.js

@@ -0,0 +1,33 @@
+import { sortBySeverity } from "./severity.js";
+/**
+ * Points retenus par le retour d'une analyse : constats (du plus grave au moins
+ * grave) puis remarques. Pour une revue rouverte par le relecteur, ceux de sa
+ * dernière version soumise ; aucun pour une revue jamais soumise.
+ */
+export function feedbackPoints(analysis) {
+    const review = analysis.review;
+    if (review.state === "submitted") {
+        const findingIds = new Set(review.selectedFindingIds);
+        const noteIds = new Set(review.selectedNoteIds);
+        return [
+            ...sortBySeverity(analysis.findings.filter((finding) => findingIds.has(finding.id))).map((finding) => ({ kind: "finding", id: finding.id, severity: finding.severity, title: finding.title, location: finding.location })),
+            ...analysis.notes
+                .filter((note) => noteIds.has(note.id))
+                .map((note) => ({ kind: "note", id: note.id, text: note.text, location: note.location })),
+        ];
+    }
+    const previous = review.previousSubmission;
+    if (!previous)
+        return [];
+    const findings = new Map(analysis.findings.map((finding) => [finding.id, finding]));
+    return [
+        ...previous.findings.map(({ id, title }) => ({
+            kind: "finding",
+            id,
+            severity: findings.get(id)?.severity ?? null,
+            title,
+            location: findings.get(id)?.location ?? null,
+        })),
+        ...previous.notes.map(({ id, text, location }) => ({ kind: "note", id, text, location })),
+    ];
+}

package/dist/shared/schemas/analysis.schema.d.ts

@@ -191,10 +191,17 @@ export declare const DiagramSchema: z.ZodObject<{
     }, z.core.$strip>>;
     updatedAt: z.ZodString;
 }, z.core.$strip>;
-/** Traitement d'un retour par l'agent : date et note facultative (commits, réponses données…). */
+/**
+ * Traitement d'un retour : date, note facultative (commits, réponses données…) et
+ * auteur du marquage — l'agent, ou le relecteur depuis la GUI.
+ */
 export declare const ProcessingSchema: z.ZodObject<{
     at: z.ZodString;
     note: z.ZodNullable<z.ZodString>;
+    by: z.ZodEnum<{
+        agent: "agent";
+        user: "user";
+    }>;
 }, z.core.$strip>;
 /**
  * Dernière version soumise d'une revue, conservée quand le relecteur la modifie
@@ -211,6 +218,10 @@ export declare const SubmissionRecordSchema: z.ZodObject<{
     processed: z.ZodNullable<z.ZodObject<{
         at: z.ZodString;
         note: z.ZodNullable<z.ZodString>;
+        by: z.ZodEnum<{
+            agent: "agent";
+            user: "user";
+        }>;
     }, z.core.$strip>>;
     findings: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -244,6 +255,10 @@ export declare const ReviewSchema: z.ZodObject<{
     processed: z.ZodNullable<z.ZodObject<{
         at: z.ZodString;
         note: z.ZodNullable<z.ZodString>;
+        by: z.ZodEnum<{
+            agent: "agent";
+            user: "user";
+        }>;
     }, z.core.$strip>>;
     previousSubmission: z.ZodNullable<z.ZodObject<{
         decision: z.ZodEnum<{
@@ -255,6 +270,10 @@ export declare const ReviewSchema: z.ZodObject<{
         processed: z.ZodNullable<z.ZodObject<{
             at: z.ZodString;
             note: z.ZodNullable<z.ZodString>;
+            by: z.ZodEnum<{
+                agent: "agent";
+                user: "user";
+            }>;
         }, z.core.$strip>>;
         findings: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -302,6 +321,7 @@ export declare const AnalysisSchema: z.ZodObject<{
         text: z.ZodString;
         source: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
+    followUpOf: z.ZodNullable<z.ZodString>;
     overview: z.ZodNullable<z.ZodObject<{
         objective: z.ZodString;
         approach: z.ZodString;
@@ -440,6 +460,10 @@ export declare const AnalysisSchema: z.ZodObject<{
         processed: z.ZodNullable<z.ZodObject<{
             at: z.ZodString;
             note: z.ZodNullable<z.ZodString>;
+            by: z.ZodEnum<{
+                agent: "agent";
+                user: "user";
+            }>;
         }, z.core.$strip>>;
         previousSubmission: z.ZodNullable<z.ZodObject<{
             decision: z.ZodEnum<{
@@ -451,6 +475,10 @@ export declare const AnalysisSchema: z.ZodObject<{
             processed: z.ZodNullable<z.ZodObject<{
                 at: z.ZodString;
                 note: z.ZodNullable<z.ZodString>;
+                by: z.ZodEnum<{
+                    agent: "agent";
+                    user: "user";
+                }>;
             }, z.core.$strip>>;
             findings: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -521,6 +549,15 @@ export interface ReviewProgress {
     /** Revue soumise dont le retour attend l'agent (voir `needsProcessing`). */
     toProcess: boolean;
 }
+/** Référence à une autre analyse. */
+export interface AnalysisLink {
+    id: string;
+    title: string;
+}
+/** Revue de suivi d'une analyse, avec l'avancement de sa revue. */
+export interface FollowUpLink extends AnalysisLink {
+    progress: ReviewProgress;
+}
 /** Vue légère d'une analyse, pour les listes. */
 export interface AnalysisSummary {
     id: string;
@@ -535,6 +572,12 @@ export interface AnalysisSummary {
     openFindings: Record<Severity, number>;
     diagramCount: number;
     progress: ReviewProgress;
+    /** Analyse dont celle-ci est la revue de suivi. */
+    followUpOf: AnalysisLink | null;
+    /** Revue de suivi de celle-ci ; une analyse en a au plus une. */
+    followedBy: FollowUpLink | null;
+    /** Rang de l'analyse dans sa chaîne de revues : 1 pour une première revue. */
+    round: number;
     updatedAt: string;
     revision: number;
 }

package/dist/shared/schemas/analysis.schema.js

@@ -122,10 +122,14 @@ export const DiagramSchema = z.object({
     links: z.array(DiagramLinkSchema),
     updatedAt: IsoDateSchema,
 });
-/** Traitement d'un retour par l'agent : date et note facultative (commits, réponses données…). */
+/**
+ * Traitement d'un retour : date, note facultative (commits, réponses données…) et
+ * auteur du marquage — l'agent, ou le relecteur depuis la GUI.
+ */
 export const ProcessingSchema = z.object({
     at: IsoDateSchema,
     note: z.string().min(1).nullable(),
+    by: z.enum(EDITORS),
 });
 /**
  * Dernière version soumise d'une revue, conservée quand le relecteur la modifie
@@ -187,6 +191,8 @@ export const AnalysisSchema = z.object({
     headCommit: z.string().min(1).nullable(),
     snapshotAt: IsoDateSchema,
     request: RequestSchema.nullable(),
+    /** Analyse dont celle-ci est la revue de suivi ; null pour une première revue. */
+    followUpOf: z.string().regex(ANALYSIS_ID_PATTERN).nullable(),
     overview: OverviewSchema.nullable(),
     /** Changements fonctionnels de la feature, une puce par changement. */
     summary: z.array(z.string().min(1)),

package/dist/shared/schemas/api.schema.d.ts

@@ -40,7 +40,13 @@ export declare const SubmitReviewBodySchema: z.ZodObject<{
     noteIds: z.ZodArray<z.ZodString>;
     baseRevision: z.ZodNumber;
 }, z.core.$strict>;
+/** Marquage du retour soumis comme traité par le relecteur, avec une note facultative. */
+export declare const MarkProcessedBodySchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
 export type SetFileReviewedBody = z.infer<typeof SetFileReviewedBodySchema>;
+export type MarkProcessedBody = z.infer<typeof MarkProcessedBodySchema>;
 export type SetFindingStatusBody = z.infer<typeof SetFindingStatusBodySchema>;
 export type AddNoteBody = z.infer<typeof AddNoteBodySchema>;
 export type UpdateNoteBody = z.infer<typeof UpdateNoteBodySchema>;
@@ -108,3 +114,10 @@ export declare const SubmitReviewRequestSchema: z.ZodObject<{
         baseRevision: z.ZodNumber;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const MarkProcessedRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    body: z.ZodObject<{
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/shared/schemas/api.schema.js

@@ -39,6 +39,11 @@ export const SubmitReviewBodySchema = z.strictObject({
     noteIds: z.array(z.string().min(1)),
     baseRevision: BaseRevisionSchema,
 });
+/** Marquage du retour soumis comme traité par le relecteur, avec une note facultative. */
+export const MarkProcessedBodySchema = z.strictObject({
+    note: z.string().trim().min(1, "the note is empty").nullable().optional(),
+    baseRevision: BaseRevisionSchema,
+});
 /** Données IPC des requêtes de la GUI qui visent une analyse. */
 export const AnalysisRequestSchema = z.strictObject({ analysisId: z.string().min(1) });
 export const SetFileReviewedRequestSchema = AnalysisRequestSchema.extend({ body: SetFileReviewedBodySchema });
@@ -56,3 +61,4 @@ export const DeleteNoteRequestSchema = AnalysisRequestSchema.extend({
     body: DeleteNoteBodySchema,
 });
 export const SubmitReviewRequestSchema = AnalysisRequestSchema.extend({ body: SubmitReviewBodySchema });
+export const MarkProcessedRequestSchema = AnalysisRequestSchema.extend({ body: MarkProcessedBodySchema });

package/dist/shared/schemas/ipc.schema.d.ts

@@ -40,5 +40,5 @@ export type ChangesResponse = {
     events: IPCMessage[];
 };
 /** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
-export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_ANALYSES", "GET_ANALYSIS", "GET_DIFF", "SET_FILE_REVIEWED", "SET_FINDING_STATUS", "ADD_NOTE", "UPDATE_NOTE", "DELETE_NOTE", "SUBMIT_REVIEW"];
+export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_ANALYSES", "GET_ANALYSIS", "GET_DIFF", "SET_FILE_REVIEWED", "SET_FINDING_STATUS", "ADD_NOTE", "UPDATE_NOTE", "DELETE_NOTE", "SUBMIT_REVIEW", "MARK_PROCESSED"];
 export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];

package/dist/shared/schemas/ipc.schema.js

@@ -28,4 +28,5 @@ export const GUI_REQUEST_TYPES = [
     "UPDATE_NOTE",
     "DELETE_NOTE",
     "SUBMIT_REVIEW",
+    "MARK_PROCESSED",
 ];

package/dist/src/core/analysis-store.d.ts

@@ -7,6 +7,8 @@ export interface CreateAnalysisInput {
     title: string;
     request?: AnalysisRequest | null;
     summary?: string[];
+    /** Analyse dont la nouvelle analyse est la revue de suivi. */
+    followUpOf?: string | null;
 }
 export interface MutateOptions {
     /**
@@ -89,5 +91,12 @@ export declare class AnalysisStore {
     /** Supprime l'analyse et son snapshot de diff. */
     delete(id: string): void;
 }
-/** Vue légère d'une analyse. */
+/**
+ * Renseigne les liens de suivi des résumés : `followUpOf` (analyse suivie),
+ * `followedBy` (revue de suivi) et `round` (rang dans la chaîne). `followUpOf`
+ * associe chaque revue de suivi à l'analyse qu'elle suit ; un lien vers une
+ * analyse absente de la liste est ignoré.
+ */
+export declare function linkFollowUps(summaries: AnalysisSummary[], followUpOf: ReadonlyMap<string, string>): void;
+/** Vue légère d'une analyse, sans ses liens de suivi (voir `linkFollowUps`). */
 export declare function summarize(analysis: Analysis): AnalysisSummary;

package/dist/src/core/analysis-store.js

@@ -204,6 +204,7 @@ export class AnalysisStore {
             .readdirSync(this.analysesDir)
             .filter((file) => file.endsWith(".json"))
             .map((file) => file.slice(0, -".json".length));
+        const followUpOf = new Map();
         for (const id of ids) {
             let analysis;
             try {
@@ -215,7 +216,10 @@ export class AnalysisStore {
                 continue;
             }
             analyses.push(summarize(analysis));
+            if (analysis.followUpOf !== null)
+                followUpOf.set(analysis.id, analysis.followUpOf);
         }
+        linkFollowUps(analyses, followUpOf);
         analyses.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
         return { analyses, unreadable };
     }
@@ -261,6 +265,7 @@ export class AnalysisStore {
             headCommit: snapshot.headCommit,
             snapshotAt: snapshot.snapshotAt,
             request: input.request ?? null,
+            followUpOf: input.followUpOf ?? null,
             overview: null,
             summary: input.summary ?? [],
             files: snapshot.files.map((file) => ({ ...file, reviewed: false })),
@@ -359,7 +364,35 @@ export class AnalysisStore {
         });
     }
 }
-/** Vue légère d'une analyse. */
+/**
+ * Renseigne les liens de suivi des résumés : `followUpOf` (analyse suivie),
+ * `followedBy` (revue de suivi) et `round` (rang dans la chaîne). `followUpOf`
+ * associe chaque revue de suivi à l'analyse qu'elle suit ; un lien vers une
+ * analyse absente de la liste est ignoré.
+ */
+export function linkFollowUps(summaries, followUpOf) {
+    const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+    for (const [followUpId, originId] of followUpOf) {
+        const followUp = byId.get(followUpId);
+        const origin = byId.get(originId);
+        if (!followUp || !origin)
+            continue;
+        followUp.followUpOf = { id: origin.id, title: origin.title };
+        origin.followedBy = { id: followUp.id, title: followUp.title, progress: followUp.progress };
+    }
+    for (const summary of summaries) {
+        const seen = new Set([summary.id]);
+        let round = 1;
+        let previous = summary.followUpOf;
+        while (previous !== null && !seen.has(previous.id)) {
+            seen.add(previous.id);
+            round++;
+            previous = byId.get(previous.id)?.followUpOf ?? null;
+        }
+        summary.round = round;
+    }
+}
+/** Vue légère d'une analyse, sans ses liens de suivi (voir `linkFollowUps`). */
 export function summarize(analysis) {
     const openFindings = emptySeverityCounts();
     for (const finding of analysis.findings) {
@@ -378,6 +411,9 @@ export function summarize(analysis) {
         openFindings,
         diagramCount: analysis.diagrams.length,
         progress: reviewProgress(analysis),
+        followUpOf: null,
+        followedBy: null,
+        round: 1,
         updatedAt: analysis.updatedAt,
         revision: analysis.revision,
     };

package/dist/src/core/follow-ups.d.ts

@@ -0,0 +1,19 @@
+import { type AnalysisLinks } from "../../shared/follow-ups.js";
+import type { Analysis } from "../../shared/schemas/analysis.schema.js";
+import type { AnalysisStore } from "./analysis-store.js";
+/**
+ * Revues de suivi : une analyse peut déclarer, à sa création, celle dont elle est
+ * la suite (`followUpOf`). Une analyse a au plus une revue de suivi, et seule une
+ * analyse dont la revue est soumise peut en avoir une.
+ */
+/** Vérifie que `originId` peut recevoir une revue de suivi et renvoie l'analyse. */
+export declare function assertCanFollowUp(store: AnalysisStore, originId: string): Analysis;
+/**
+ * Marque traitée l'analyse suivie quand son retour attendait encore l'agent, avec
+ * une note qui nomme la revue de suivi. Renvoie vrai si elle a été marquée.
+ */
+export declare function markOriginFollowed(store: AnalysisStore, originId: string, followUp: Analysis): boolean;
+/** Liens de suivi d'une analyse : analyse suivie avec son retour, revue de suivi et chaîne complète. */
+export declare function analysisLinks(store: AnalysisStore, id: string): AnalysisLinks;
+/** Détache la revue de suivi de `id`, s'il en a une, avant la suppression de `id`. Renvoie son id. */
+export declare function detachFollowUp(store: AnalysisStore, id: string): string | null;

package/dist/src/core/follow-ups.js

@@ -0,0 +1,85 @@
+import { feedbackPoints } from "../../shared/follow-ups.js";
+import { needsProcessing } from "../../shared/review-state.js";
+import { AnalysisError } from "./errors.js";
+import { markFeedbackProcessed } from "./review-actions.js";
+/**
+ * Revues de suivi : une analyse peut déclarer, à sa création, celle dont elle est
+ * la suite (`followUpOf`). Une analyse a au plus une revue de suivi, et seule une
+ * analyse dont la revue est soumise peut en avoir une.
+ */
+/** Vérifie que `originId` peut recevoir une revue de suivi et renvoie l'analyse. */
+export function assertCanFollowUp(store, originId) {
+    const origin = store.get(originId);
+    if (origin.review.state !== "submitted") {
+        throw new AnalysisError(`Analysis "${originId}" cannot get a follow-up review: its review is not submitted. ` +
+            `A follow-up answers submitted feedback; read it with get_review_feedback once the reviewer has submitted it.`);
+    }
+    const existing = store.list().analyses.find((summary) => summary.id === originId)?.followedBy;
+    if (existing) {
+        throw new AnalysisError(`Analysis "${originId}" already has a follow-up review: "${existing.title}" (${existing.id}). ` +
+            `An analysis has at most one follow-up; follow up "${existing.id}" instead to start the next round.`);
+    }
+    return origin;
+}
+/**
+ * Marque traitée l'analyse suivie quand son retour attendait encore l'agent, avec
+ * une note qui nomme la revue de suivi. Renvoie vrai si elle a été marquée.
+ */
+export function markOriginFollowed(store, originId, followUp) {
+    if (!needsProcessing(store.get(originId).review))
+        return false;
+    markFeedbackProcessed(store, originId, "agent", `Suivie par la revue « ${followUp.title} »`);
+    return true;
+}
+/** Résumé de `id` dans la liste, avec ses liens de suivi. */
+function summaryOf(summaries, id) {
+    const summary = summaries.find((entry) => entry.id === id);
+    if (!summary)
+        throw new AnalysisError(`Analysis "${id}" is missing from the listing.`);
+    return summary;
+}
+/** Liens de suivi d'une analyse : analyse suivie avec son retour, revue de suivi et chaîne complète. */
+export function analysisLinks(store, id) {
+    const summaries = store.list().analyses;
+    const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+    const summary = summaryOf(summaries, id);
+    const backwards = [];
+    const seen = new Set([id]);
+    for (let link = summary.followUpOf; link !== null && !seen.has(link.id); link = byId.get(link.id)?.followUpOf ?? null) {
+        seen.add(link.id);
+        backwards.unshift({ id: link.id, title: link.title });
+    }
+    const forwards = [];
+    for (let link = summary.followedBy; link !== null && !seen.has(link.id); link = byId.get(link.id)?.followedBy ?? null) {
+        seen.add(link.id);
+        forwards.push({ id: link.id, title: link.title });
+    }
+    let previous = null;
+    if (summary.followUpOf !== null) {
+        const origin = store.get(summary.followUpOf.id);
+        const submitted = origin.review.state === "submitted" ? origin.review : origin.review.previousSubmission;
+        previous = {
+            id: origin.id,
+            title: origin.title,
+            submittedAt: submitted?.submittedAt ?? null,
+            decision: submitted?.decision ?? null,
+            processed: submitted?.processed ?? null,
+            points: feedbackPoints(origin),
+        };
+    }
+    return {
+        previous,
+        next: summary.followedBy,
+        chain: [...backwards, { id: summary.id, title: summary.title }, ...forwards],
+    };
+}
+/** Détache la revue de suivi de `id`, s'il en a une, avant la suppression de `id`. Renvoie son id. */
+export function detachFollowUp(store, id) {
+    const followUp = store.list().analyses.find((summary) => summary.id === id)?.followedBy;
+    if (!followUp)
+        return null;
+    store.mutate(followUp.id, "agent", (draft) => {
+        draft.followUpOf = null;
+    });
+    return followUp.id;
+}

package/dist/src/core/migrate.d.ts

@@ -21,6 +21,13 @@ export declare const addNoteFindingIds: MigrationStep;
  * avant ce format est à traiter, sans version précédente.
  */
 export declare const addReviewProcessing: MigrationStep;
+/**
+ * Ajoute `by: "agent"` aux traitements enregistrés sans auteur, dans la revue et
+ * dans sa version soumise précédente : seul l'agent pouvait alors les poser.
+ */
+export declare const addProcessingAuthor: MigrationStep;
+/** Ajoute `followUpOf` à null : l'analyse n'est la revue de suivi d'aucune autre. */
+export declare const addFollowUpOf: MigrationStep;
 /** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
 export declare const ANALYSIS_MIGRATIONS: readonly MigrationStep[];
 /** Étapes appliquées aux snapshots de diff (`diffs/<id>.json`), dans l'ordre. */

package/dist/src/core/migrate.js

@@ -49,8 +49,48 @@ export const addReviewProcessing = (doc) => {
         return null;
     return { ...doc, review: { ...raw, processed: raw.processed ?? null, previousSubmission: raw.previousSubmission ?? null } };
 };
+/** `processed` augmenté de `by: "agent"` quand il n'a pas d'auteur ; null quand il n'y a rien à changer. */
+function withProcessingAuthor(processed) {
+    if (!processed || typeof processed !== "object" || Array.isArray(processed))
+        return null;
+    const raw = processed;
+    return raw.by !== undefined ? null : { ...raw, by: "agent" };
+}
+/**
+ * Ajoute `by: "agent"` aux traitements enregistrés sans auteur, dans la revue et
+ * dans sa version soumise précédente : seul l'agent pouvait alors les poser.
+ */
+export const addProcessingAuthor = (doc) => {
+    const review = doc.review;
+    if (!review || typeof review !== "object" || Array.isArray(review))
+        return null;
+    const raw = review;
+    const processed = withProcessingAuthor(raw.processed);
+    const previous = raw.previousSubmission;
+    const previousProcessed = previous && typeof previous === "object" ? withProcessingAuthor(previous.processed) : null;
+    if (processed === null && previousProcessed === null)
+        return null;
+    return {
+        ...doc,
+        review: {
+            ...raw,
+            ...(processed === null ? {} : { processed }),
+            ...(previousProcessed === null ? {} : { previousSubmission: { ...previous, processed: previousProcessed } }),
+        },
+    };
+};
+/** Ajoute `followUpOf` à null : l'analyse n'est la revue de suivi d'aucune autre. */
+export const addFollowUpOf = (doc) => (doc.followUpOf !== undefined ? null : { ...doc, followUpOf: null });
 /** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
-export const ANALYSIS_MIGRATIONS = [addProject, addOverview, addExplanations, addNoteFindingIds, addReviewProcessing];
+export const ANALYSIS_MIGRATIONS = [
+    addProject,
+    addOverview,
+    addExplanations,
+    addNoteFindingIds,
+    addReviewProcessing,
+    addProcessingAuthor,
+    addFollowUpOf,
+];
 /** Étapes appliquées aux snapshots de diff (`diffs/<id>.json`), dans l'ordre. */
 export const SNAPSHOT_MIGRATIONS = [];
 /** Applique `steps` à la suite. Renvoie null si aucune étape n'a modifié le document. */