@imenam/mcp-feature-analyzer 1.0.20 → 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.
 
@@ -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 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 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 ; ce filtre ressort en sarcelle tant qu'il n'est pas vide), « 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.

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

@@ -321,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;
@@ -548,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;
@@ -562,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

@@ -191,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/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

@@ -26,6 +26,8 @@ export declare const addReviewProcessing: MigrationStep;
  * 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

@@ -79,6 +79,8 @@ export const addProcessingAuthor = (doc) => {
         },
     };
 };
+/** 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,
@@ -87,6 +89,7 @@ export const ANALYSIS_MIGRATIONS = [
     addNoteFindingIds,
     addReviewProcessing,
     addProcessingAuthor,
+    addFollowUpOf,
 ];
 /** Étapes appliquées aux snapshots de diff (`diffs/<id>.json`), dans l'ordre. */
 export const SNAPSHOT_MIGRATIONS = [];

package/dist/src/index.js

@@ -37,6 +37,7 @@ import { DEFAULT_NODE_SHAPE, DEFAULT_NODE_STATUS, setDiagram } from "./tools/set
 import { deleteDiagram } from "./tools/delete-diagram.js";
 import { getReviewFeedback } from "./tools/get-review-feedback.js";
 import { markFeedbackProcessed } from "./tools/mark-feedback-processed.js";
+import { analysisLinks } from "./core/follow-ups.js";
 import { deleteAnalysis } from "./tools/delete-analysis.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -95,6 +96,7 @@ Concepts:
 - An **explanation** describes what a block of added or removed code does and how it works, so that the reviewer understands it before judging it. It is not a finding: it judges nothing and asks for nothing. It is anchored on new-side lines (added code) or old-side lines (removed code), and shown in the diff above the lines it describes.
 - A **diagram** is a flow, layers or mindmap picture of the feature. You give nodes and links only; the GUI lays them out.
 - The **review** belongs to the reviewer: files marked reviewed, findings ignored, notes, and a submitted decision with a prompt for you.
+- A **follow-up review** is a new analysis created with follow_up_of: it reviews the fixes for the submitted feedback of an earlier analysis. Each analysis has at most one follow-up, so the rounds form a chain.
 
 Workflow:
 1. list_analyses (with project) to find an analysis of the same feature: reuse it with update_analysis and refresh_analysis instead of creating a duplicate. Otherwise create_analysis with its project once the feature is developed.
@@ -105,7 +107,7 @@ Workflow:
 6. set_diagram when a picture helps (impacted layers, process flow, concept tree).
 7. Tell the user to review the analysis in the GUI (the link is in the tool results).
 8. get_review_feedback to read the decision, the selected points and the prompt. list_analyses with review_state "to_process" lists the submitted reviews you have not handled yet; an approved review has nothing to process.
-9. Fix the code, then refresh_analysis to recompute the diff for a new review round; re-anchor or rewrite the outdated findings and explanations. When the diff must stay as it is (an analysis of one commit, fixes in other commits, answers given in the conversation), call mark_feedback_processed instead, with a note saying how the feedback was handled.
+9. Fix the code, then refresh_analysis to recompute the diff for a new review round; re-anchor or rewrite the outdated findings and explanations. When the fixes are in other commits (typically an analysis of one commit), create their follow-up review instead: create_analysis on the fix commits with follow_up_of set to the analysis you fixed; it marks that feedback processed and shows its points to the reviewer. When nothing needs a new review (answers given in the conversation), call mark_feedback_processed with a note saying how the feedback was handled.
 
 Explanation rules:
 - Write one for every added or removed block that is long (a function or a block of about 30 lines or more) or complex (non-trivial algorithm, state machine, concurrency, recursion, tricky regular expression or data transformation). A 100-line function always gets one.
@@ -183,8 +185,10 @@ function handleGuiRequest(msg) {
             return { dataDir, version: APP_VERSION };
         case "LIST_ANALYSES":
             return store.list();
-        case "GET_ANALYSIS":
-            return { analysis: store.get(parseRequest(AnalysisRequestSchema, msg.data).analysisId) };
+        case "GET_ANALYSIS": {
+            const analysisId = parseRequest(AnalysisRequestSchema, msg.data).analysisId;
+            return { analysis: store.get(analysisId), links: analysisLinks(store, analysisId) };
+        }
         case "GET_DIFF":
             return { diff: store.getSnapshot(parseRequest(AnalysisRequestSchema, msg.data).analysisId) };
         case "SET_FILE_REVIEWED": {
@@ -407,6 +411,12 @@ const TOOLS = [
                 },
                 request_text: { type: "string", description: REQUEST_TEXT_DOC },
                 request_source: { type: "string", description: `${REQUEST_SOURCE_DOC} Needs request_text.` },
+                follow_up_of: {
+                    type: "string",
+                    description: "Id of the analysis whose submitted feedback this new analysis follows up, typically an analysis of the fix commits. " +
+                        "Its feedback is marked processed if it was still waiting for you, and the reviewer sees its points to check in the new review. " +
+                        "Refused when that review is not submitted or already has a follow-up (one follow-up per analysis; follow up the latest round instead).",
+                },
             },
             required: ["repo_path", "project", "title", "mode"],
         },
@@ -751,6 +761,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await withRepoAccess(exec, async (repoFor) => {
                     const mutation = await createAnalysis(store, params, repoFor);
                     notifyAnalysesListChanged();
+                    if (typeof params.follow_up_of === "string")
+                        notifyAnalysisChanged(params.follow_up_of.trim());
                     return afterMutation(mutation);
                 });
             case "update_analysis":

package/dist/src/tools/create-analysis.d.ts

@@ -1,5 +1,9 @@
 import type { AnalysisStore } from "../core/analysis-store.js";
 import { type RepoAccess } from "../core/git.js";
 import { type Args, type MutationResult } from "./types.js";
-/** Calcule et fige le diff du dépôt, lu par `repoFor(repo_path)` (git local par défaut), puis crée l'analyse. */
+/**
+ * Calcule et fige le diff du dépôt, lu par `repoFor(repo_path)` (git local par
+ * défaut), puis crée l'analyse. Avec `follow_up_of`, la nouvelle analyse est la
+ * revue de suivi de celle-ci, dont le retour est marqué traité s'il attendait l'agent.
+ */
 export declare function createAnalysis(store: AnalysisStore, args: Args, repoFor?: (repoPath: string) => RepoAccess): Promise<MutationResult>;

package/dist/src/tools/create-analysis.js

@@ -1,9 +1,14 @@
+import { assertCanFollowUp, markOriginFollowed } from "../core/follow-ups.js";
 import { computeSnapshot, localRepo } from "../core/git.js";
 import { ANALYSIS_MODES } from "../../shared/schemas/analysis.schema.js";
 import { fileLine, fileTotals, snapshotLabel } from "./format.js";
 import { optionalString, rejectUnknownFields, requireEnum, requireString, textResult, } from "./types.js";
-const FIELDS = ["repo_path", "project", "title", "mode", "base", "head", "request_text", "request_source"];
-/** Calcule et fige le diff du dépôt, lu par `repoFor(repo_path)` (git local par défaut), puis crée l'analyse. */
+const FIELDS = ["repo_path", "project", "title", "mode", "base", "head", "request_text", "request_source", "follow_up_of"];
+/**
+ * Calcule et fige le diff du dépôt, lu par `repoFor(repo_path)` (git local par
+ * défaut), puis crée l'analyse. Avec `follow_up_of`, la nouvelle analyse est la
+ * revue de suivi de celle-ci, dont le retour est marqué traité s'il attendait l'agent.
+ */
 export async function createAnalysis(store, args, repoFor = localRepo) {
     rejectUnknownFields(args, FIELDS);
     const repoPath = requireString(args, "repo_path");
@@ -17,14 +22,27 @@ export async function createAnalysis(store, args, repoFor = localRepo) {
     if (requestSource !== undefined && requestText === undefined) {
         throw new Error(`"request_source" describes the initial request: give "request_text" too.`);
     }
+    const followUpOf = optionalString(args, "follow_up_of");
+    const origin = followUpOf === undefined ? null : assertCanFollowUp(store, followUpOf);
     const computed = await computeSnapshot({ repoPath, mode, base, head }, repoFor(repoPath));
-    const analysis = store.create({ project, title, request: requestText === undefined ? null : { text: requestText, source: requestSource ?? null } }, computed);
+    const analysis = store.create({
+        project,
+        title,
+        request: requestText === undefined ? null : { text: requestText, source: requestSource ?? null },
+        followUpOf: origin?.id ?? null,
+    }, computed);
     const lines = [
         `Created analysis "${analysis.title}" (id: ${analysis.id}) in project "${analysis.project}".`,
         `Repository: ${analysis.repoPath}`,
         `Diff: ${snapshotLabel(analysis)}`,
-        "",
     ];
+    if (origin !== null) {
+        const marked = markOriginFollowed(store, origin.id, analysis);
+        lines.push(`Follow-up of: "${origin.title}" (${origin.id}). The reviewer sees the points of its feedback to check in this new review.`, marked
+            ? `Its feedback was waiting for you: it is now marked processed, with a note naming this follow-up.`
+            : `Its feedback was already processed or approved: its processing mark is unchanged.`);
+    }
+    lines.push("");
     if (analysis.files.length === 0) {
         lines.push("Changed files: none — the diff is empty. Check the mode and refs; delete this analysis with delete_analysis and create it again with the right ones.");
     }

package/dist/src/tools/delete-analysis.d.ts

@@ -1,4 +1,7 @@
 import type { AnalysisStore } from "../core/analysis-store.js";
 import { type Args, type MutationResult } from "./types.js";
-/** Supprime une analyse et son snapshot de diff. */
+/**
+ * Supprime une analyse et son snapshot de diff. Sa revue de suivi, si elle en a
+ * une, est conservée et devient une première revue.
+ */
 export declare function deleteAnalysis(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/delete-analysis.js

@@ -1,11 +1,17 @@
+import { detachFollowUp } from "../core/follow-ups.js";
 import { rejectUnknownFields, requireString, textResult } from "./types.js";
-/** Supprime une analyse et son snapshot de diff. */
+/**
+ * Supprime une analyse et son snapshot de diff. Sa revue de suivi, si elle en a
+ * une, est conservée et devient une première revue.
+ */
 export function deleteAnalysis(store, args) {
     rejectUnknownFields(args, ["analysis_id"]);
     const id = requireString(args, "analysis_id");
+    store.get(id);
+    const detached = detachFollowUp(store, id);
     store.delete(id);
-    return {
-        result: textResult(`Deleted analysis ${id} and its diff snapshot. The repository is untouched.`),
-        analysisId: id,
-    };
+    const lines = [`Deleted analysis ${id} and its diff snapshot. The repository is untouched.`];
+    if (detached !== null)
+        lines.push(`Its follow-up review ${detached} is kept and no longer refers to it.`);
+    return { result: textResult(lines.join("\n")), analysisId: id };
 }

package/dist/src/tools/format.d.ts

@@ -1,4 +1,5 @@
 import { type Analysis, type Explanation, type FileEntry, type Finding, type Note, type Overview, type ReviewProgress, type ReviewProgressState, type Severity } from "../../shared/schemas/analysis.schema.js";
+import type { AnalysisLinks } from "../../shared/follow-ups.js";
 /** Sha abrégé à 7 caractères. */
 export declare function shortSha(sha: string | null): string;
 /** Refs d'une analyse : `branch master...HEAD` ou `working_tree (changes against HEAD)`. */
@@ -29,5 +30,10 @@ export declare function progressStateLabel(state: ReviewProgressState): string;
  * ou `submitted, decision approve, nothing to process (7/7 files reviewed)`.
  */
 export declare function progressLabel(progress: ReviewProgress): string;
+/**
+ * Lignes de suivi d'une analyse : analyse suivie et revue de suivi, avec le rang
+ * dans la chaîne. Aucune ligne pour une analyse sans lien.
+ */
+export declare function followUpLines(links: Pick<AnalysisLinks, "previous" | "next" | "chain">, id: string): string[];
 /** Bloc « Overview » : objectif, approche et points d'attention ; une ligne d'invitation quand il n'y en a pas. */
 export declare function overviewLines(overview: Overview | null): string[];

package/dist/src/tools/format.js

@@ -87,6 +87,21 @@ export function progressLabel(progress) {
     const decision = progress.state === "submitted" ? `, decision ${progress.decision}, ${processing}` : "";
     return `${REVIEW_PROGRESS_TEXT[progress.state]}${decision} (${progress.reviewedFiles}/${progress.totalFiles} files reviewed)`;
 }
+/**
+ * Lignes de suivi d'une analyse : analyse suivie et revue de suivi, avec le rang
+ * dans la chaîne. Aucune ligne pour une analyse sans lien.
+ */
+export function followUpLines(links, id) {
+    const lines = [];
+    const round = links.chain.findIndex((link) => link.id === id) + 1;
+    if (links.previous) {
+        lines.push(`Follow-up of: "${links.previous.title}" (${links.previous.id}) — round ${round} of ${links.chain.length}.`);
+    }
+    if (links.next) {
+        lines.push(`Followed by: "${links.next.title}" (${links.next.id}), review ${progressLabel(links.next.progress)}.`);
+    }
+    return lines;
+}
 /** Bloc « Overview » : objectif, approche et points d'attention ; une ligne d'invitation quand il n'y en a pas. */
 export function overviewLines(overview) {
     if (overview === null)

package/dist/src/tools/get-analysis.js

@@ -1,8 +1,9 @@
 import { summarize } from "../core/analysis-store.js";
+import { analysisLinks } from "../core/follow-ups.js";
 import { diagramQuality } from "../../shared/diagram-quality.js";
 import { reviewProgress } from "../../shared/review-state.js";
 import { sortBySeverity } from "../../shared/severity.js";
-import { fileLine, explanationLine, fileTotals, findingLine, noteLocationLabel, overviewLines, progressLabel, severityCountsLabel, snapshotLabel, } from "./format.js";
+import { fileLine, explanationLine, fileTotals, findingLine, followUpLines, noteLocationLabel, overviewLines, progressLabel, severityCountsLabel, snapshotLabel, } from "./format.js";
 import { rejectUnknownFields, requireString, textResult } from "./types.js";
 function noteLine(note) {
     return `${note.id} — ${noteLocationLabel(note)} — ${note.text.replace(/\n/g, " / ")}`;
@@ -48,6 +49,7 @@ export function getAnalysis(store, args) {
         `Repository: ${analysis.repoPath}`,
         `Diff: ${snapshotLabel(analysis)}`,
         `Revision ${analysis.revision}, last edited by ${analysis.lastEditor} at ${analysis.updatedAt}`,
+        ...followUpLines(analysisLinks(store, analysis.id), analysis.id),
         "",
     ];
     if (analysis.request) {