@imenam/mcp-feature-analyzer 1.0.17 → 1.0.18

package/dist/shared/labels.d.ts

@@ -17,6 +17,8 @@ export declare const MODE_LABELS: Record<AnalysisMode, string>;
 export declare const DECISION_LABELS: Record<ReviewDecision, string>;
 /** Pastille de l'état d'avancement d'une revue. */
 export declare const REVIEW_PROGRESS_STYLES: Record<ReviewProgressState, BadgeStyle>;
+/** Pastille d'une revue soumise dont l'agent a marqué le retour traité. */
+export declare const PROCESSED_STYLE: BadgeStyle;
 /** Pastille de la décision d'une revue soumise, affichée à côté de « Soumise ». */
 export declare const DECISION_STYLES: Record<ReviewDecision, BadgeStyle>;
 /**

package/dist/shared/labels.js

@@ -46,6 +46,8 @@ export const REVIEW_PROGRESS_STYLES = {
     files_reviewed: { label: "Fichiers revus", color: "#8b97ff", background: "#1b1f3d" },
     submitted: { label: "Soumise", color: "#3fb950", background: "#11201a" },
 };
+/** Pastille d'une revue soumise dont l'agent a marqué le retour traité. */
+export const PROCESSED_STYLE = { label: "Traitée", color: "#5fd4c4", background: "#10272a" };
 /** Pastille de la décision d'une revue soumise, affichée à côté de « Soumise ». */
 export const DECISION_STYLES = {
     approve: { label: "Approuvée", color: "#3fb950", background: "#11201a" },

package/dist/shared/review-state.d.ts

@@ -1,10 +1,40 @@
-import type { Analysis, ReviewProgress } from "./schemas/analysis.schema.js";
+import type { Analysis, Review, ReviewProgress, SubmissionRecord } from "./schemas/analysis.schema.js";
 /**
  * Avancement de la revue d'une analyse :
- * - `submitted` : revue soumise, avec sa décision ;
+ * - `submitted` : revue soumise, avec sa décision et son traitement par l'agent ;
  * - `files_reviewed` : tous les fichiers revus, revue non soumise ;
  * - `in_progress` : au moins un fichier revu, revue non soumise ;
  * - `not_started` : aucun fichier revu, revue non soumise. Une analyse sans
  *   fichier reste `not_started` jusqu'à la soumission.
  */
 export declare function reviewProgress(analysis: Pick<Analysis, "files" | "review">): ReviewProgress;
+/** Copie autonome de la revue soumise de `analysis` : décision, date, traitement, points retenus et points écartés. */
+export declare function recordSubmission(analysis: Pick<Analysis, "review" | "findings" | "notes">): SubmissionRecord;
+/**
+ * Repasse une revue soumise à l'état en attente, avant une modification du
+ * relecteur : la version soumise est conservée dans `previousSubmission`. Sans
+ * effet sur une revue en attente.
+ */
+export declare function reopenSubmittedReview(draft: Pick<Analysis, "review" | "findings" | "notes">): void;
+/** Revue vierge : en attente, sans décision, sélection, prompt, traitement ni version précédente. */
+export declare function pendingReview(): Review;
+/** Écarts entre deux versions soumises d'une revue. */
+export interface SubmissionChanges {
+    decision: {
+        from: SubmissionRecord["decision"];
+        to: SubmissionRecord["decision"];
+    } | null;
+    addedFindings: SubmissionRecord["findings"];
+    removedFindings: SubmissionRecord["findings"];
+    addedNotes: SubmissionRecord["notes"];
+    /** Remarques retenues dans les deux versions dont le texte ou l'emplacement a changé. */
+    modifiedNotes: Array<{
+        before: SubmissionRecord["notes"][number];
+        after: SubmissionRecord["notes"][number];
+    }>;
+    removedNotes: SubmissionRecord["notes"];
+}
+/** Ce qui a changé de la version soumise `before` à la version `after`. */
+export declare function submissionChanges(before: SubmissionRecord, after: SubmissionRecord): SubmissionChanges;
+/** Vrai quand `submissionChanges` ne relève aucun écart. */
+export declare function hasNoChanges(changes: SubmissionChanges): boolean;

package/dist/shared/review-state.js

@@ -1,6 +1,6 @@
 /**
  * Avancement de la revue d'une analyse :
- * - `submitted` : revue soumise, avec sa décision ;
+ * - `submitted` : revue soumise, avec sa décision et son traitement par l'agent ;
  * - `files_reviewed` : tous les fichiers revus, revue non soumise ;
  * - `in_progress` : au moins un fichier revu, revue non soumise ;
  * - `not_started` : aucun fichier revu, revue non soumise. Une analyse sans
@@ -10,8 +10,79 @@ export function reviewProgress(analysis) {
     const totalFiles = analysis.files.length;
     const reviewedFiles = analysis.files.filter((file) => file.reviewed).length;
     if (analysis.review.state === "submitted") {
-        return { state: "submitted", reviewedFiles, totalFiles, decision: analysis.review.decision };
+        return { state: "submitted", reviewedFiles, totalFiles, decision: analysis.review.decision, processed: analysis.review.processed };
     }
     const state = reviewedFiles === 0 ? "not_started" : reviewedFiles === totalFiles ? "files_reviewed" : "in_progress";
-    return { state, reviewedFiles, totalFiles, decision: null };
+    return { state, reviewedFiles, totalFiles, decision: null, processed: null };
+}
+/** Copie autonome de la revue soumise de `analysis` : décision, date, traitement, points retenus et points écartés. */
+export function recordSubmission(analysis) {
+    const review = analysis.review;
+    if (review.state !== "submitted" || review.decision === null || review.submittedAt === null) {
+        throw new Error("Only a submitted review can be recorded.");
+    }
+    const findingIds = new Set(review.selectedFindingIds);
+    const noteIds = new Set(review.selectedNoteIds);
+    return {
+        decision: review.decision,
+        submittedAt: review.submittedAt,
+        processed: review.processed,
+        findings: analysis.findings.filter((finding) => findingIds.has(finding.id)).map(({ id, title }) => ({ id, title })),
+        notes: analysis.notes.filter((note) => noteIds.has(note.id)).map(({ id, location, text }) => ({ id, location, text })),
+        excludedFindingIds: analysis.findings.filter((finding) => finding.status === "open" && !findingIds.has(finding.id)).map(({ id }) => id),
+        excludedNoteIds: analysis.notes.filter((note) => !noteIds.has(note.id)).map(({ id }) => id),
+    };
+}
+/**
+ * Repasse une revue soumise à l'état en attente, avant une modification du
+ * relecteur : la version soumise est conservée dans `previousSubmission`. Sans
+ * effet sur une revue en attente.
+ */
+export function reopenSubmittedReview(draft) {
+    if (draft.review.state !== "submitted")
+        return;
+    draft.review = { ...pendingReview(), previousSubmission: recordSubmission(draft) };
+}
+/** Revue vierge : en attente, sans décision, sélection, prompt, traitement ni version précédente. */
+export function pendingReview() {
+    return {
+        state: "pending",
+        decision: null,
+        selectedFindingIds: [],
+        selectedNoteIds: [],
+        prompt: null,
+        submittedAt: null,
+        processed: null,
+        previousSubmission: null,
+    };
+}
+function sameLocation(a, b) {
+    return a === null || b === null ? a === b : a.path === b.path && a.line === b.line;
+}
+/** Ce qui a changé de la version soumise `before` à la version `after`. */
+export function submissionChanges(before, after) {
+    const afterFindings = new Set(after.findings.map((finding) => finding.id));
+    const beforeFindings = new Set(before.findings.map((finding) => finding.id));
+    const afterNotes = new Map(after.notes.map((note) => [note.id, note]));
+    const beforeNotes = new Map(before.notes.map((note) => [note.id, note]));
+    return {
+        decision: before.decision === after.decision ? null : { from: before.decision, to: after.decision },
+        addedFindings: after.findings.filter((finding) => !beforeFindings.has(finding.id)),
+        removedFindings: before.findings.filter((finding) => !afterFindings.has(finding.id)),
+        addedNotes: after.notes.filter((note) => !beforeNotes.has(note.id)),
+        modifiedNotes: after.notes.flatMap((note) => {
+            const previous = beforeNotes.get(note.id);
+            return previous && (previous.text !== note.text || !sameLocation(previous.location, note.location)) ? [{ before: previous, after: note }] : [];
+        }),
+        removedNotes: before.notes.filter((note) => !afterNotes.has(note.id)),
+    };
+}
+/** Vrai quand `submissionChanges` ne relève aucun écart. */
+export function hasNoChanges(changes) {
+    return (changes.decision === null &&
+        changes.addedFindings.length === 0 &&
+        changes.removedFindings.length === 0 &&
+        changes.addedNotes.length === 0 &&
+        changes.modifiedNotes.length === 0 &&
+        changes.removedNotes.length === 0);
 }

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

@@ -191,6 +191,42 @@ 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…). */
+export declare const ProcessingSchema: z.ZodObject<{
+    at: z.ZodString;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Dernière version soumise d'une revue, conservée quand le relecteur la modifie
+ * ou la soumet à nouveau. Elle recopie les points retenus pour rester lisible
+ * même après la suppression de constats ou de remarques.
+ */
+export declare const SubmissionRecordSchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+        request_changes: "request_changes";
+    }>;
+    submittedAt: z.ZodString;
+    processed: z.ZodNullable<z.ZodObject<{
+        at: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    notes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        location: z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    excludedFindingIds: z.ZodArray<z.ZodString>;
+    excludedNoteIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
 export declare const ReviewSchema: z.ZodObject<{
     state: z.ZodEnum<{
         pending: "pending";
@@ -205,6 +241,36 @@ export declare const ReviewSchema: z.ZodObject<{
     selectedNoteIds: z.ZodArray<z.ZodString>;
     prompt: z.ZodNullable<z.ZodString>;
     submittedAt: z.ZodNullable<z.ZodString>;
+    processed: z.ZodNullable<z.ZodObject<{
+        at: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    previousSubmission: z.ZodNullable<z.ZodObject<{
+        decision: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            request_changes: "request_changes";
+        }>;
+        submittedAt: z.ZodString;
+        processed: z.ZodNullable<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        findings: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        notes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            location: z.ZodNullable<z.ZodObject<{
+                path: z.ZodString;
+                line: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+        excludedFindingIds: z.ZodArray<z.ZodString>;
+        excludedNoteIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const RequestSchema: z.ZodObject<{
     text: z.ZodString;
@@ -371,6 +437,36 @@ export declare const AnalysisSchema: z.ZodObject<{
         selectedNoteIds: z.ZodArray<z.ZodString>;
         prompt: z.ZodNullable<z.ZodString>;
         submittedAt: z.ZodNullable<z.ZodString>;
+        processed: z.ZodNullable<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        previousSubmission: z.ZodNullable<z.ZodObject<{
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                request_changes: "request_changes";
+            }>;
+            submittedAt: z.ZodString;
+            processed: z.ZodNullable<z.ZodObject<{
+                at: z.ZodString;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            findings: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+            }, z.core.$strip>>;
+            notes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                location: z.ZodNullable<z.ZodObject<{
+                    path: z.ZodString;
+                    line: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strip>>;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+            excludedFindingIds: z.ZodArray<z.ZodString>;
+            excludedNoteIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     revision: z.ZodNumber;
     createdAt: z.ZodString;
@@ -404,6 +500,8 @@ export type DiagramNodeLocation = z.infer<typeof DiagramNodeLocationSchema>;
 export type DiagramNode = z.infer<typeof DiagramNodeSchema>;
 export type DiagramLink = z.infer<typeof DiagramLinkSchema>;
 export type Diagram = z.infer<typeof DiagramSchema>;
+export type Processing = z.infer<typeof ProcessingSchema>;
+export type SubmissionRecord = z.infer<typeof SubmissionRecordSchema>;
 export type Review = z.infer<typeof ReviewSchema>;
 export type AnalysisRequest = z.infer<typeof RequestSchema>;
 export type Overview = z.infer<typeof OverviewSchema>;
@@ -418,6 +516,8 @@ export interface ReviewProgress {
     totalFiles: number;
     /** Décision de la revue soumise ; null tant qu'elle ne l'est pas. */
     decision: ReviewDecision | null;
+    /** Traitement de la revue soumise par l'agent ; null tant qu'il est à faire ou que la revue n'est pas soumise. */
+    processed: Processing | null;
 }
 /** Vue légère d'une analyse, pour les listes. */
 export interface AnalysisSummary {

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

@@ -122,6 +122,26 @@ 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…). */
+export const ProcessingSchema = z.object({
+    at: IsoDateSchema,
+    note: z.string().min(1).nullable(),
+});
+/**
+ * Dernière version soumise d'une revue, conservée quand le relecteur la modifie
+ * ou la soumet à nouveau. Elle recopie les points retenus pour rester lisible
+ * même après la suppression de constats ou de remarques.
+ */
+export const SubmissionRecordSchema = z.object({
+    decision: z.enum(REVIEW_DECISIONS),
+    submittedAt: IsoDateSchema,
+    processed: ProcessingSchema.nullable(),
+    findings: z.array(z.object({ id: ItemIdSchema, title: z.string().min(1) })),
+    notes: z.array(z.object({ id: ItemIdSchema, location: NoteLocationSchema.nullable(), text: z.string().min(1) })),
+    /** Constats ouverts et remarques que le relecteur pouvait transmettre et a écartés. */
+    excludedFindingIds: z.array(ItemIdSchema),
+    excludedNoteIds: z.array(ItemIdSchema),
+});
 export const ReviewSchema = z.object({
     state: z.enum(REVIEW_STATES),
     decision: z.enum(REVIEW_DECISIONS).nullable(),
@@ -129,6 +149,10 @@ export const ReviewSchema = z.object({
     selectedNoteIds: z.array(ItemIdSchema),
     prompt: z.string().nullable(),
     submittedAt: IsoDateSchema.nullable(),
+    /** Traitement de la soumission en cours par l'agent ; null tant qu'il ne l'a pas marquée traitée. */
+    processed: ProcessingSchema.nullable(),
+    /** Version soumise précédente ; null avant la première modification ou nouvelle soumission. */
+    previousSubmission: SubmissionRecordSchema.nullable(),
 });
 export const RequestSchema = z.object({
     text: z.string().min(1),

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

@@ -21,9 +21,24 @@ export declare const IPCMessageSchema: z.ZodObject<{
     timestamp: z.ZodString;
 }, z.core.$strip>;
 export type IPCMessage = z.infer<typeof IPCMessageSchema>;
-/** Types d'IPC envoyés par le maître et relayés tels quels aux clients SSE de la GUI. */
-export declare const PUSHED_EVENT_TYPES: readonly ["INITIAL_STATE", "ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
+/** Types d'IPC envoyés par le maître, journalisés par le GUI worker et servis tels quels par `/api/changes`. */
+export declare const PUSHED_EVENT_TYPES: readonly ["ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
 export type PushedEventType = (typeof PUSHED_EVENT_TYPES)[number];
+/**
+ * Réponse de `GET /api/changes`. `epoch` identifie l'instance du GUI worker,
+ * `seq` le dernier évènement journalisé. `reset: true` signifie que le client
+ * doit tout recharger ; sinon `events` liste les évènements postérieurs à `since`.
+ */
+export type ChangesResponse = {
+    epoch: string;
+    seq: number;
+    reset: true;
+} | {
+    epoch: string;
+    seq: number;
+    reset: false;
+    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 type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];

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

@@ -14,8 +14,8 @@ export const IPCMessageSchema = z.object({
     errorKind: z.enum(IPC_ERROR_KINDS).optional(),
     timestamp: z.string(),
 });
-/** Types d'IPC envoyés par le maître et relayés tels quels aux clients SSE de la GUI. */
-export const PUSHED_EVENT_TYPES = ["INITIAL_STATE", "ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
+/** Types d'IPC envoyés par le maître, journalisés par le GUI worker et servis tels quels par `/api/changes`. */
+export const PUSHED_EVENT_TYPES = ["ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
 /** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
 export const GUI_REQUEST_TYPES = [
     "GET_CONFIG",

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

@@ -29,8 +29,6 @@ export interface ReplaceSnapshotResult {
     /** Revue en place avant le recalcul, remplacée par une revue vierge. */
     previousReview: Review;
 }
-/** Revue vierge : en attente, sans décision, sélection ni prompt. */
-export declare function pendingReview(): Review;
 /**
  * Persistance des analyses : `<dataDir>/analyses/<id>.json` pour l'analyse et
  * `<dataDir>/diffs/<id>.json` pour son snapshot de diff. Plusieurs processus

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

@@ -3,17 +3,13 @@ import fs from "fs";
 import path from "path";
 import { ANALYSIS_ID_PATTERN, AnalysisSchema, } from "../../shared/schemas/analysis.schema.js";
 import { DiffSnapshotSchema } from "../../shared/schemas/diff.schema.js";
-import { reviewProgress } from "../../shared/review-state.js";
+import { pendingReview, reviewProgress } from "../../shared/review-state.js";
 import { emptySeverityCounts } from "../../shared/severity.js";
 import { AnalysisError, NotFoundError, RevisionConflictError } from "./errors.js";
 import { analysisId } from "./ids.js";
 import { assertInvariants, assertSnapshotFieldsUnchanged } from "./invariants.js";
 import { migrateAnalysis, migrateSnapshot } from "./migrate.js";
 import { applyRefresh } from "./refresh.js";
-/** Revue vierge : en attente, sans décision, sélection ni prompt. */
-export function pendingReview() {
-    return { state: "pending", decision: null, selectedFindingIds: [], selectedNoteIds: [], prompt: null, submittedAt: null };
-}
 /** Au-delà de ce délai, un verrou est réputé abandonné par un processus arrêté en cours d'écriture. */
 const LOCK_STALE_MS = 10_000;
 const LOCK_RETRY_MS = 25;

package/dist/src/core/invariants.js

@@ -148,6 +148,9 @@ export function findInvariantViolations(analysis) {
     if (review.state === "pending" && review.submittedAt !== null) {
         problems.push("a pending review cannot have a submittedAt date");
     }
+    if (review.state === "pending" && review.processed !== null) {
+        problems.push("a pending review cannot be marked processed");
+    }
     return problems;
 }
 /** Lève une AnalysisError listant toutes les violations, s'il y en a. */

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

@@ -16,6 +16,11 @@ export declare const addOverview: MigrationStep;
 export declare const addExplanations: MigrationStep;
 /** Ajoute `findingId` à null sur les remarques qui n'en ont pas : elles restent des remarques libres. */
 export declare const addNoteFindingIds: MigrationStep;
+/**
+ * Ajoute à la revue `processed` et `previousSubmission` à null : une revue soumise
+ * avant ce format est à traiter, sans version précédente.
+ */
+export declare const addReviewProcessing: 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

@@ -36,8 +36,21 @@ export const addNoteFindingIds = (doc) => {
         return null;
     return { ...doc, notes: notes.map((note) => (missing(note) ? { ...note, findingId: null } : note)) };
 };
+/**
+ * Ajoute à la revue `processed` et `previousSubmission` à null : une revue soumise
+ * avant ce format est à traiter, sans version précédente.
+ */
+export const addReviewProcessing = (doc) => {
+    const review = doc.review;
+    if (!review || typeof review !== "object" || Array.isArray(review))
+        return null;
+    const raw = review;
+    if (raw.processed !== undefined && raw.previousSubmission !== undefined)
+        return null;
+    return { ...doc, review: { ...raw, processed: raw.processed ?? null, previousSubmission: raw.previousSubmission ?? null } };
+};
 /** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
-export const ANALYSIS_MIGRATIONS = [addProject, addOverview, addExplanations, addNoteFindingIds];
+export const ANALYSIS_MIGRATIONS = [addProject, addOverview, addExplanations, addNoteFindingIds, addReviewProcessing];
 /** É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. */

package/dist/src/core/review-actions.d.ts

@@ -4,6 +4,9 @@ import type { AnalysisStore } from "./analysis-store.js";
 /**
  * Modifications faites par le relecteur depuis la GUI. Chacune passe par
  * `store.mutate(id, "user", …, { baseRevision })` et renvoie l'analyse écrite.
+ * Changer une remarque ou le statut d'un constat repasse une revue soumise en
+ * attente (voir `reopenSubmittedReview`) : son retour n'est plus à traiter tant
+ * qu'elle n'est pas soumise à nouveau.
  */
 /** Marque un fichier de l'analyse comme revu, ou le repasse à revoir. */
 export declare function setFileReviewed(store: AnalysisStore, analysisId: string, body: SetFileReviewedBody): Analysis;
@@ -18,18 +21,14 @@ export declare function setFindingStatus(store: AnalysisStore, analysisId: strin
  * liée au constat `findingId` quand elle y répond.
  */
 export declare function addNote(store: AnalysisStore, analysisId: string, body: AddNoteBody): Analysis;
-/**
- * Remplace le texte d'une remarque. Quand elle fait partie d'une revue soumise,
- * le prompt enregistré est recalculé avec le nouveau texte.
- */
+/** Remplace le texte d'une remarque. */
 export declare function updateNote(store: AnalysisStore, analysisId: string, noteId: string, body: UpdateNoteBody): Analysis;
-/**
- * Supprime une remarque. Quand elle fait partie d'une revue soumise, elle est
- * retirée de la sélection et le prompt enregistré est recalculé sans elle.
- */
+/** Supprime une remarque et la retire de la sélection de la revue. */
 export declare function deleteNote(store: AnalysisStore, analysisId: string, noteId: string, body: DeleteNoteBody): Analysis;
 /**
- * Soumet la revue : décision, points retenus et prompt calculé ici. Une
- * nouvelle soumission remplace la précédente.
+ * Soumet la revue : décision, points retenus et prompt calculé ici. La revue
+ * soumise est à traiter par l'agent. Une nouvelle soumission remplace la
+ * précédente, conservée dans `previousSubmission` ; une revue rouverte garde la
+ * version soumise qu'elle conservait déjà.
  */
 export declare function submitReview(store: AnalysisStore, analysisId: string, body: SubmitReviewBody): Analysis;

package/dist/src/core/review-actions.js

@@ -1,10 +1,14 @@
 import { buildAgentPrompt } from "../../shared/prompt.js";
+import { recordSubmission, reopenSubmittedReview } from "../../shared/review-state.js";
 import { AnalysisError, NotFoundError } from "./errors.js";
 import { itemId } from "./ids.js";
 import { assertNoteLocation } from "./locations.js";
 /**
  * Modifications faites par le relecteur depuis la GUI. Chacune passe par
  * `store.mutate(id, "user", …, { baseRevision })` et renvoie l'analyse écrite.
+ * Changer une remarque ou le statut d'un constat repasse une revue soumise en
+ * attente (voir `reopenSubmittedReview`) : son retour n'est plus à traiter tant
+ * qu'elle n'est pas soumise à nouveau.
  */
 /** Marque un fichier de l'analyse comme revu, ou le repasse à revoir. */
 export function setFileReviewed(store, analysisId, body) {
@@ -31,6 +35,9 @@ export function setFindingStatus(store, analysisId, findingId, body) {
         if (finding.status === "outdated") {
             throw new AnalysisError(`Finding "${findingId}" is outdated: its lines changed since it was written. The agent must anchor it again with update_finding before it can be ignored or reopened.`);
         }
+        if (finding.status === body.status)
+            return;
+        reopenSubmittedReview(draft);
         finding.status = body.status;
     }, { baseRevision: body.baseRevision });
 }
@@ -46,6 +53,7 @@ export function addNote(store, analysisId, body) {
         if (findingId !== null && !draft.findings.some((finding) => finding.id === findingId)) {
             throw new NotFoundError(`Finding "${findingId}" not found in analysis "${analysisId}".`);
         }
+        reopenSubmittedReview(draft);
         draft.notes.push({
             id: itemId("note", new Set(draft.notes.map((note) => note.id))),
             location,
@@ -55,47 +63,27 @@ export function addNote(store, analysisId, body) {
         });
     }, { baseRevision: body.baseRevision });
 }
-/**
- * Remplace le texte d'une remarque. Quand elle fait partie d'une revue soumise,
- * le prompt enregistré est recalculé avec le nouveau texte.
- */
+/** Remplace le texte d'une remarque. */
 export function updateNote(store, analysisId, noteId, body) {
     return store.mutate(analysisId, "user", (draft) => {
         const note = draft.notes.find((entry) => entry.id === noteId);
         if (!note)
             throw new NotFoundError(`Note "${noteId}" not found in analysis "${analysisId}".`);
+        if (note.text === body.text)
+            return;
+        reopenSubmittedReview(draft);
         note.text = body.text;
-        const review = draft.review;
-        if (review.state === "submitted" && review.selectedNoteIds.includes(noteId)) {
-            review.prompt = buildAgentPrompt(draft, {
-                findingIds: review.selectedFindingIds,
-                noteIds: review.selectedNoteIds,
-                decision: review.decision,
-            });
-        }
     }, { baseRevision: body.baseRevision });
 }
-/**
- * Supprime une remarque. Quand elle fait partie d'une revue soumise, elle est
- * retirée de la sélection et le prompt enregistré est recalculé sans elle.
- */
+/** Supprime une remarque et la retire de la sélection de la revue. */
 export function deleteNote(store, analysisId, noteId, body) {
     return store.mutate(analysisId, "user", (draft) => {
         const index = draft.notes.findIndex((note) => note.id === noteId);
         if (index === -1)
             throw new NotFoundError(`Note "${noteId}" not found in analysis "${analysisId}".`);
+        reopenSubmittedReview(draft);
         draft.notes.splice(index, 1);
-        const review = draft.review;
-        if (!review.selectedNoteIds.includes(noteId))
-            return;
-        review.selectedNoteIds = review.selectedNoteIds.filter((id) => id !== noteId);
-        if (review.state === "submitted") {
-            review.prompt = buildAgentPrompt(draft, {
-                findingIds: review.selectedFindingIds,
-                noteIds: review.selectedNoteIds,
-                decision: review.decision,
-            });
-        }
+        draft.review.selectedNoteIds = draft.review.selectedNoteIds.filter((id) => id !== noteId);
     }, { baseRevision: body.baseRevision });
 }
 function assertKnownIds(label, ids, known) {
@@ -108,13 +96,16 @@ function assertKnownIds(label, ids, known) {
         throw new AnalysisError(`The selection lists ${label} id(s) twice: ${[...new Set(duplicated)].join(", ")}.`);
 }
 /**
- * Soumet la revue : décision, points retenus et prompt calculé ici. Une
- * nouvelle soumission remplace la précédente.
+ * Soumet la revue : décision, points retenus et prompt calculé ici. La revue
+ * soumise est à traiter par l'agent. Une nouvelle soumission remplace la
+ * précédente, conservée dans `previousSubmission` ; une revue rouverte garde la
+ * version soumise qu'elle conservait déjà.
  */
 export function submitReview(store, analysisId, body) {
     return store.mutate(analysisId, "user", (draft) => {
         assertKnownIds("finding", body.findingIds, draft.findings.map((finding) => finding.id));
         assertKnownIds("note", body.noteIds, draft.notes.map((note) => note.id));
+        const previousSubmission = draft.review.state === "submitted" ? recordSubmission(draft) : draft.review.previousSubmission;
         draft.review = {
             state: "submitted",
             decision: body.decision,
@@ -122,6 +113,8 @@ export function submitReview(store, analysisId, body) {
             selectedNoteIds: [...body.noteIds],
             prompt: buildAgentPrompt(draft, { findingIds: body.findingIds, noteIds: body.noteIds, decision: body.decision }),
             submittedAt: new Date().toISOString(),
+            processed: null,
+            previousSubmission,
         };
     }, { baseRevision: body.baseRevision });
 }