@imenam/mcp-feature-analyzer 1.0.16 → 1.0.18

package/dist/src/gui-worker.js

@@ -1,11 +1,11 @@
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
 import { GUI_LISTEN_HOST, ProxyClient, createLogger, honoGuiGuard, setupLogging } from "@imenam/mcp-gui-interface";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
+import { randomUUID } from "crypto";
 import { IPCMessageSchema, PUSHED_EVENT_TYPES } from "../shared/schemas/ipc.schema.js";
 import { AddNoteBodySchema, DeleteNoteBodySchema, SetFileReviewedBodySchema, SetFindingStatusBodySchema, SubmitReviewBodySchema, UpdateNoteBodySchema, } from "../shared/schemas/api.schema.js";
 import { resolveLogDir } from "./core/log-dir.js";
@@ -79,7 +79,6 @@ const app = new Hono();
 // Contrôle de l'hôte appelé et des requêtes de modification, avant toute route.
 app.use("*", honoGuiGuard({ proxyUrl: guiMode.kind === "proxy" ? guiMode.proxyUrl : undefined }));
 let proxyClient = null;
-const sseStreams = new Set();
 const pendingRequests = new Map();
 function safeSend(message) {
     if (process.send && process.connected) {
@@ -116,6 +115,38 @@ function ipcRequest(type, data, timeout = 5000) {
     });
 }
 const PUSHED_EVENTS = new Set(PUSHED_EVENT_TYPES);
+/** Nombre d'évènements conservés dans le journal servi par `/api/changes`. */
+const CHANGES_JOURNAL_SIZE = 200;
+/** Identifiant de cette instance du worker : un client qui en voit changer recharge tout. */
+const epoch = randomUUID();
+/** Journal des évènements poussés par le master, numérotés par `seq` croissant. */
+const changesJournal = [];
+let lastSeq = 0;
+function recordChange(event) {
+    lastSeq += 1;
+    changesJournal.push({ seq: lastSeq, event });
+    if (changesJournal.length > CHANGES_JOURNAL_SIZE)
+        changesJournal.shift();
+}
+/**
+ * Évènements postérieurs à `since`, ou `reset` quand le client ne peut pas
+ * reprendre : autre instance du worker, évènements sortis du journal, ou
+ * `since` au-delà du dernier évènement.
+ */
+function changesSince(since, clientEpoch) {
+    if (since === undefined || clientEpoch !== epoch || since > lastSeq) {
+        return { epoch, seq: lastSeq, reset: true };
+    }
+    const oldestKept = changesJournal.length > 0 ? changesJournal[0].seq : lastSeq + 1;
+    if (since < oldestKept - 1)
+        return { epoch, seq: lastSeq, reset: true };
+    return {
+        epoch,
+        seq: lastSeq,
+        reset: false,
+        events: changesJournal.filter((entry) => entry.seq > since).map((entry) => entry.event),
+    };
+}
 function setupIpcHandlers() {
     process.on("error", (err) => {
         if (err.code === "ERR_IPC_CHANNEL_CLOSED")
@@ -123,7 +154,7 @@ function setupIpcHandlers() {
         logger.error(`Process error: ${err.message}`);
     });
     process.on("disconnect", () => {
-        logger.warn("IPC disconnected from MCP master. GUI worker exits; EventSource clients show Disconnected.");
+        logger.warn("IPC disconnected from MCP master. GUI worker exits.");
         process.exit(0);
     });
     process.on("message", (raw) => {
@@ -140,12 +171,7 @@ function setupIpcHandlers() {
             return;
         }
         if (PUSHED_EVENTS.has(msg.type)) {
-            for (const stream of sseStreams) {
-                stream.writeSSE({ data: JSON.stringify(msg), event: "message" }).catch((err) => {
-                    logger.warn(`SSE push ${msg.type} failed, stream dropped: ${err?.message ?? err}`);
-                    sseStreams.delete(stream);
-                });
-            }
+            recordChange(msg);
             return;
         }
         logger.debug(`Unhandled IPC message type: ${msg.type}`);
@@ -163,45 +189,21 @@ app.get("/proxy/health", (c) => {
         timestamp: new Date().toISOString(),
     });
 });
-app.get("/api/events", (c) => streamSSE(c, async (stream) => {
-    const clientId = Math.random().toString(36).slice(2, 11);
-    sseStreams.add(stream);
-    logger.info(`SSE /api/events: client connected (id=${clientId})`);
-    stream.onAbort(() => {
-        sseStreams.delete(stream);
-        logger.info(`SSE /api/events: stream closed (id=${clientId}).`);
-    });
-    if (!safeSend({ type: "GET_INITIAL_STATE", timestamp: new Date().toISOString() })) {
-        logger.warn(`SSE /api/events: GET_INITIAL_STATE not sent (id=${clientId}) — IPC unavailable.`);
-    }
-    try {
-        await stream.writeSSE({ data: "connected", event: "ping" });
-    }
-    catch (err) {
-        logger.warn(`SSE /api/events: initial writeSSE failed (id=${clientId}): ${err?.message ?? err}`);
-        sseStreams.delete(stream);
-        return;
-    }
-    while (!stream.aborted) {
-        await stream.sleep(30000);
-        try {
-            await stream.writeSSE({ data: "ping", event: "ping" });
-        }
-        catch (err) {
-            logger.warn(`SSE /api/events: keepalive ping failed (id=${clientId}): ${err?.message ?? err}`);
-            sseStreams.delete(stream);
-            break;
+/**
+ * Changements depuis `since` pour l'instance `epoch`. Répond immédiatement ;
+ * sans `since` ni `epoch`, la réponse est un `reset`.
+ */
+app.get("/api/changes", (c) => {
+    const rawSince = c.req.query("since");
+    const rawEpoch = c.req.query("epoch");
+    let since;
+    if (rawSince !== undefined && rawSince !== "") {
+        if (!/^\d+$/.test(rawSince) || !Number.isSafeInteger(Number(rawSince))) {
+            return c.json({ error: `Invalid "since" query parameter: ${JSON.stringify(rawSince)} — expected a non-negative integer.` }, 400);
         }
+        since = Number(rawSince);
     }
-}));
-app.post("/api/client-diagnostics", async (c) => {
-    try {
-        logger.warn(`Client diagnostics (SSE/EventSource): ${JSON.stringify(await c.req.json())}`);
-    }
-    catch (e) {
-        logger.warn(`Client diagnostics: invalid JSON body (${e?.message ?? e})`);
-    }
-    return c.json({ ok: true });
+    return c.json(changesSince(since, rawEpoch || undefined));
 });
 /** Code HTTP d'une erreur renvoyée par le master ; une erreur locale (timeout, IPC absent) est une erreur serveur. */
 const HTTP_STATUS_BY_ERROR_KIND = {

package/dist/src/index.js

@@ -22,7 +22,7 @@ import { AddNoteRequestSchema, AnalysisRequestSchema, DeleteNoteRequestSchema, S
 import { ANALYSIS_MODES, DIAGRAM_KINDS, EXPLANATION_SIDES, FINDING_KINDS, NODE_SHAPES, NODE_STATUSES, SEVERITIES, } from "../shared/schemas/analysis.schema.js";
 import { errorResult, textResult } from "./tools/types.js";
 import { createAnalysis } from "./tools/create-analysis.js";
-import { listAnalyses } from "./tools/list-analyses.js";
+import { listAnalyses, REVIEW_STATE_FILTERS } from "./tools/list-analyses.js";
 import { getAnalysis } from "./tools/get-analysis.js";
 import { getDiff } from "./tools/get-diff.js";
 import { refreshAnalysis } from "./tools/refresh-analysis.js";
@@ -36,6 +36,7 @@ import { deleteExplanations } from "./tools/delete-explanations.js";
 import { DEFAULT_NODE_SHAPE, DEFAULT_NODE_STATUS, setDiagram } from "./tools/set-diagram.js";
 import { deleteDiagram } from "./tools/delete-diagram.js";
 import { getReviewFeedback } from "./tools/get-review-feedback.js";
+import { markFeedbackProcessed } from "./tools/mark-feedback-processed.js";
 import { deleteAnalysis } from "./tools/delete-analysis.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -103,8 +104,8 @@ Workflow:
 5. add_findings for every problem, including requirement_gap findings for requested behaviour that is missing.
 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.
-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.
+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.
+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.
 
 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.
@@ -245,13 +246,6 @@ function handleIPCMessage(raw) {
         case "ALREADY_RUNNING":
             logger.info(`GUI already served by another instance at ${msg.data?.url}`);
             return;
-        case "GET_INITIAL_STATE":
-            broadcastToGUI({
-                type: "INITIAL_STATE",
-                data: { version: APP_VERSION, analyses: store.list().analyses },
-                timestamp: new Date().toISOString(),
-            });
-            return;
         default:
             if (GUI_REQUESTS.has(msg.type)) {
                 try {
@@ -358,13 +352,20 @@ const TOOLS = [
     {
         name: "list_analyses",
         description: "List the analyses grouped by project, with their refs, open findings by severity, reviewed files, diagram count and review state " +
-            "(not started, in progress, all files reviewed, submitted). Start here: when the project already has an analysis of the feature, " +
+            "(not started, in progress, all files reviewed, submitted; a submitted review is pending processing until mark_feedback_processed or refresh_analysis). " +
+            "Start here: when the project already has an analysis of the feature, " +
             "continue it (update_analysis to rewrite the overview and summary, refresh_analysis after changing the code) instead of creating a duplicate; " +
             "create a new one with create_analysis for another feature or another diff.",
         inputSchema: {
             type: "object",
             properties: {
                 project: { type: "string", description: "Only list the analyses of this project (exact name). An unknown name lists the existing projects." },
+                review_state: {
+                    type: "string",
+                    enum: [...REVIEW_STATE_FILTERS],
+                    description: "Only list the analyses in this review state. to_process = submitted reviews not marked processed yet: the feedback you still have to handle; " +
+                        "processed = submitted reviews marked processed.",
+                },
             },
         },
     },
@@ -659,14 +660,34 @@ const TOOLS = [
     },
     {
         name: "get_review_feedback",
-        description: "Read the reviewer's feedback once the review is submitted: decision, selected findings and notes, and the prompt to act on. " +
-            "Before submission it reports the review progress. Read-only. Always read the feedback before calling refresh_analysis, which discards it.",
+        description: "Read the reviewer's feedback once the review is submitted: decision, whether you already processed it, selected findings and notes, and the prompt to act on. " +
+            "After a resubmission it also lists what changed since the previous submitted version and recalls how that one was processed. " +
+            "Before submission, or while the reviewer is changing a submitted review, it reports the review progress only. " +
+            "Read-only. Always read the feedback before calling refresh_analysis, which discards it.",
         inputSchema: {
             type: "object",
             properties: { analysis_id: { type: "string", description: ANALYSIS_ID_DOC } },
             required: ["analysis_id"],
         },
     },
+    {
+        name: "mark_feedback_processed",
+        description: "Mark the submitted feedback of an analysis as processed once you handled it, when refresh_analysis does not fit: the analysis freezes one commit " +
+            "and the fixes are in other commits, or the notes were answered in the conversation. Records the date and an optional note; the feedback stays readable " +
+            "with get_review_feedback and the GUI shows the review as processed. Refused while the review is not submitted. " +
+            "If the reviewer changes the review afterwards, it becomes pending again until it is resubmitted.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                analysis_id: { type: "string", description: ANALYSIS_ID_DOC },
+                note: {
+                    type: "string",
+                    description: 'How the feedback was handled, shown to the reviewer, e.g. "fixed by 12785d6e3 and 1ff5baaad" or "answers given in the conversation".',
+                },
+            },
+            required: ["analysis_id"],
+        },
+    },
     {
         name: "refresh_analysis",
         description: "Recompute the frozen diff with the same repository, mode and refs, after fixing the code. " +
@@ -743,6 +764,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return afterMutation(setDiagram(store, params));
             case "delete_diagram":
                 return afterMutation(deleteDiagram(store, params));
+            case "mark_feedback_processed":
+                return afterMutation(markFeedbackProcessed(store, params));
             case "refresh_analysis":
                 return await withRepoAccess(exec, async (repoFor) => afterMutation(await refreshAnalysis(store, params, repoFor)));
             case "delete_analysis": {

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

@@ -23,7 +23,10 @@ export declare function severityCountsLabel(counts: Record<Severity, number>): s
 export declare function indentBlock(text: string, indent: string): string;
 /** Nom anglais d'un état de revue : `not started`, `in progress`… */
 export declare function progressStateLabel(state: ReviewProgressState): string;
-/** `in progress (2/7 files reviewed)` ou `submitted, decision approve (7/7 files reviewed)`. */
+/**
+ * `in progress (2/7 files reviewed)`, `submitted, decision approve, pending processing (7/7 files reviewed)`
+ * ou `submitted, decision approve, processed at <date> (7/7 files reviewed)`.
+ */
 export declare function progressLabel(progress: ReviewProgress): 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

@@ -73,9 +73,13 @@ const REVIEW_PROGRESS_TEXT = {
 export function progressStateLabel(state) {
     return REVIEW_PROGRESS_TEXT[state];
 }
-/** `in progress (2/7 files reviewed)` ou `submitted, decision approve (7/7 files reviewed)`. */
+/**
+ * `in progress (2/7 files reviewed)`, `submitted, decision approve, pending processing (7/7 files reviewed)`
+ * ou `submitted, decision approve, processed at <date> (7/7 files reviewed)`.
+ */
 export function progressLabel(progress) {
-    const decision = progress.state === "submitted" ? `, decision ${progress.decision}` : "";
+    const processing = progress.processed === null ? "pending processing" : `processed at ${progress.processed.at}`;
+    const decision = progress.state === "submitted" ? `, decision ${progress.decision}, ${processing}` : "";
     return `${REVIEW_PROGRESS_TEXT[progress.state]}${decision} (${progress.reviewedFiles}/${progress.totalFiles} files reviewed)`;
 }
 /** Bloc « Overview » : objectif, approche et points d'attention ; une ligne d'invitation quand il n'y en a pas. */

package/dist/src/tools/get-review-feedback.d.ts

@@ -1,4 +1,8 @@
 import type { AnalysisStore } from "../core/analysis-store.js";
 import { type Args, type ToolResult } from "./types.js";
-/** Retour du relecteur : décision, points retenus et prompt ; sinon l'avancement de la revue. Lecture seule. */
+/**
+ * Retour du relecteur : décision, état du traitement, écarts avec la version
+ * soumise précédente, points retenus et prompt ; sinon l'avancement de la revue.
+ * Lecture seule.
+ */
 export declare function getReviewFeedback(store: AnalysisStore, args: Args): ToolResult;

package/dist/src/tools/get-review-feedback.js

@@ -1,7 +1,41 @@
-import { reviewProgress } from "../../shared/review-state.js";
+import { hasNoChanges, recordSubmission, reviewProgress, submissionChanges } from "../../shared/review-state.js";
 import { sortBySeverity } from "../../shared/severity.js";
 import { findingLine, indentBlock, noteLocationLabel, overviewLines, progressLabel } from "./format.js";
 import { rejectUnknownFields, requireString, textResult } from "./types.js";
+/** `processed at <date> (note: …)` ou `not processed`. */
+function processingLabel(processed) {
+    if (processed === null)
+        return "not processed";
+    return `processed at ${processed.at}${processed.note === null ? "" : ` (note: ${processed.note})`}`;
+}
+/** `submitted at <date>, decision <d>, processed at <date>…` : rappel d'une version soumise. */
+function submissionLabel(record) {
+    return `submitted at ${record.submittedAt}, decision ${record.decision}, ${processingLabel(record.processed)}`;
+}
+function recordedNoteLine(note) {
+    return `${note.id} — ${noteLocationLabel(note)}\n${indentBlock(note.text, "      ")}`;
+}
+/** Écarts entre la version soumise précédente et la soumission en cours. */
+function changeLines(previous, current) {
+    const changes = submissionChanges(previous, current);
+    const lines = [`Changes since the previous submission (${submissionLabel(previous)}):`];
+    if (hasNoChanges(changes))
+        return [...lines, "  none: same decision and same points."];
+    if (changes.decision)
+        lines.push(`  Decision changed: ${changes.decision.from} → ${changes.decision.to}`);
+    for (const finding of changes.addedFindings)
+        lines.push(`  + finding ${finding.id} — ${finding.title}`);
+    for (const finding of changes.removedFindings)
+        lines.push(`  - finding ${finding.id} — ${finding.title}`);
+    for (const note of changes.addedNotes)
+        lines.push(`  + note ${recordedNoteLine(note)}`);
+    for (const { before, after } of changes.modifiedNotes) {
+        lines.push(`  ~ note ${recordedNoteLine(after)}`, `    was: ${noteLocationLabel(before)}`, indentBlock(before.text, "      "));
+    }
+    for (const note of changes.removedNotes)
+        lines.push(`  - note ${recordedNoteLine(note)}`);
+    return lines;
+}
 function findingDetails(finding) {
     const lines = [`- ${findingLine(finding)}`];
     if (finding.body.trim() !== "")
@@ -13,22 +47,27 @@ function findingDetails(finding) {
 function noteDetails(note) {
     return `- ${note.id} — ${noteLocationLabel(note)}\n${indentBlock(note.text, "    ")}`;
 }
-/** Avancement d'une revue non soumise. */
+/**
+ * Avancement d'une revue non soumise. Une revue rouverte par le relecteur rappelle
+ * la version soumise qu'elle remplacera, sans en donner le contenu.
+ */
 function progressLines(analysis) {
     const progress = reviewProgress(analysis);
     const ignored = analysis.findings.filter((finding) => finding.status === "ignored").length;
-    return [
-        `The review of "${analysis.title}" (${analysis.id}, project "${analysis.project}") is not submitted yet.`,
-        `Review state: ${progressLabel(progress)}.`,
-        `Progress: ${progress.reviewedFiles}/${progress.totalFiles} file(s) reviewed, ${ignored}/${analysis.findings.length} finding(s) ignored, ` +
-            `${analysis.notes.length} reviewer note(s).`,
-        "",
-        ...overviewLines(analysis.overview),
-        "",
-        "Ask the user to finish the review in the GUI and save the feedback, then call get_review_feedback again.",
-    ];
+    const previous = analysis.review.previousSubmission;
+    const lines = [`The review of "${analysis.title}" (${analysis.id}, project "${analysis.project}") is not submitted yet.`];
+    if (previous) {
+        lines.push(`The reviewer reopened the feedback ${submissionLabel(previous)}, and is changing it: do not act on it until it is submitted again.`);
+    }
+    lines.push(`Review state: ${progressLabel(progress)}.`, `Progress: ${progress.reviewedFiles}/${progress.totalFiles} file(s) reviewed, ${ignored}/${analysis.findings.length} finding(s) ignored, ` +
+        `${analysis.notes.length} reviewer note(s).`, "", ...overviewLines(analysis.overview), "", "Ask the user to finish the review in the GUI and save the feedback, then call get_review_feedback again.");
+    return lines;
 }
-/** Retour du relecteur : décision, points retenus et prompt ; sinon l'avancement de la revue. Lecture seule. */
+/**
+ * Retour du relecteur : décision, état du traitement, écarts avec la version
+ * soumise précédente, points retenus et prompt ; sinon l'avancement de la revue.
+ * Lecture seule.
+ */
 export function getReviewFeedback(store, args) {
     rejectUnknownFields(args, ["analysis_id"]);
     const analysis = store.get(requireString(args, "analysis_id"));
@@ -42,11 +81,11 @@ export function getReviewFeedback(store, args) {
     const lines = [
         `Review of "${analysis.title}" (${analysis.id}, project "${analysis.project}") submitted at ${review.submittedAt}.`,
         `Decision: ${review.decision}`,
-        "",
-        ...overviewLines(analysis.overview),
-        "",
-        `Selected findings (${findings.length}):`,
+        `Processing: ${review.processed === null ? "to process (call mark_feedback_processed once handled)" : processingLabel(review.processed)}`,
     ];
+    if (review.previousSubmission)
+        lines.push("", ...changeLines(review.previousSubmission, recordSubmission(analysis)));
+    lines.push("", ...overviewLines(analysis.overview), "", `Selected findings (${findings.length}):`);
     lines.push(...(findings.length === 0 ? ["  none"] : findings.flatMap(findingDetails)), "");
     lines.push(`Selected reviewer notes (${notes.length}):`);
     lines.push(...(notes.length === 0 ? ["  none"] : notes.map(noteDetails)), "");
@@ -64,8 +103,9 @@ export function getReviewFeedback(store, args) {
         lines.push("Next steps: the reviewer approved the feature with no points to address.");
     }
     else {
-        lines.push("Next steps: address the points above in the repository, then call refresh_analysis to recompute the diff " +
-            "(it discards this feedback and starts a new review round).");
+        lines.push("Next steps: address the points above in the repository. Then either call refresh_analysis to recompute the diff " +
+            "(it discards this feedback and starts a new review round), or, when the diff stays as it is (an analysis of one commit, " +
+            "fixes made in other commits, answers given in the conversation), call mark_feedback_processed with a note saying how it was handled.");
     }
     return textResult(lines.join("\n"));
 }

package/dist/src/tools/list-analyses.d.ts

@@ -1,8 +1,14 @@
 import type { AnalysisStore } from "../core/analysis-store.js";
 import { type Args, type ToolResult } from "./types.js";
+/**
+ * Filtre `review_state` : un état d'avancement, ou parmi les revues soumises
+ * celles qui restent à traiter (`to_process`) ou déjà traitées (`processed`).
+ */
+export declare const REVIEW_STATE_FILTERS: readonly ["not_started", "in_progress", "files_reviewed", "submitted", "to_process", "processed"];
+export type ReviewStateFilter = (typeof REVIEW_STATE_FILTERS)[number];
 /**
  * Liste les analyses regroupées par projet (projet le plus récemment modifié en
  * premier, puis analyses de la plus récente à la plus ancienne), éventuellement
- * limitées à un projet, et les fichiers illisibles.
+ * limitées à un projet et à un état de revue, et les fichiers illisibles.
  */
 export declare function listAnalyses(store: AnalysisStore, args: Args): ToolResult;

package/dist/src/tools/list-analyses.js

@@ -1,6 +1,19 @@
 import { REVIEW_PROGRESS_STATES } from "../../shared/schemas/analysis.schema.js";
 import { progressLabel, progressStateLabel, refsLabel, severityCountsLabel } from "./format.js";
-import { optionalString, rejectUnknownFields, textResult } from "./types.js";
+import { optionalEnum, optionalString, rejectUnknownFields, textResult } from "./types.js";
+/**
+ * Filtre `review_state` : un état d'avancement, ou parmi les revues soumises
+ * celles qui restent à traiter (`to_process`) ou déjà traitées (`processed`).
+ */
+export const REVIEW_STATE_FILTERS = [...REVIEW_PROGRESS_STATES, "to_process", "processed"];
+function matchesReviewState(summary, filter) {
+    const { state, processed } = summary.progress;
+    if (filter === "to_process")
+        return state === "submitted" && processed === null;
+    if (filter === "processed")
+        return state === "submitted" && processed !== null;
+    return state === filter;
+}
 /** Analyses regroupées par projet, les projets triés par leur analyse la plus récente. */
 function groupByProject(analyses) {
     const groups = new Map();
@@ -21,41 +34,53 @@ function projectCounts(analyses) {
     return `${analyses.length} analysis(es): ${counts.join(", ")}`;
 }
 function analysisLines(summary) {
-    const feedback = summary.progress.state === "submitted" ? " — read it with get_review_feedback" : "";
-    return [
+    const { state, processed } = summary.progress;
+    const feedback = state !== "submitted" ? "" : processed === null ? " — read it with get_review_feedback" : "";
+    const lines = [
         `- ${summary.id} — "${summary.title}"`,
         `  ${refsLabel(summary)} | files reviewed ${summary.reviewedCount}/${summary.fileCount} | ` +
             `open findings: ${severityCountsLabel(summary.openFindings)} | diagrams: ${summary.diagramCount}`,
         `  review: ${progressLabel(summary.progress)}${feedback} | updated ${summary.updatedAt}`,
     ];
+    if (processed?.note)
+        lines.push(`  processing note: ${processed.note}`);
+    return lines;
 }
 /**
  * Liste les analyses regroupées par projet (projet le plus récemment modifié en
  * premier, puis analyses de la plus récente à la plus ancienne), éventuellement
- * limitées à un projet, et les fichiers illisibles.
+ * limitées à un projet et à un état de revue, et les fichiers illisibles.
  */
 export function listAnalyses(store, args) {
-    rejectUnknownFields(args, ["project"]);
+    rejectUnknownFields(args, ["project", "review_state"]);
     const project = optionalString(args, "project");
-    const { analyses, unreadable } = store.list();
+    const reviewState = optionalEnum(args, "review_state", REVIEW_STATE_FILTERS);
+    const { analyses: all, unreadable } = store.list();
+    const known = new Set(all.map((summary) => summary.project));
+    const analyses = reviewState === undefined ? all : all.filter((summary) => matchesReviewState(summary, reviewState));
     const groups = groupByProject(analyses);
     const lines = [];
-    if (project !== undefined && !groups.has(project)) {
-        const known = [...groups.keys()];
-        throw new Error(known.length === 0
+    if (project !== undefined && !known.has(project)) {
+        const names = [...groupByProject(all).keys()];
+        throw new Error(names.length === 0
             ? `Unknown project "${project}": there are no analyses yet. Create one with create_analysis.`
-            : `Unknown project "${project}". Existing projects: ${known.map((name) => `"${name}"`).join(", ")}. ` +
+            : `Unknown project "${project}". Existing projects: ${names.map((name) => `"${name}"`).join(", ")}. ` +
                 `Call list_analyses without project to see them all, or create_analysis to start a new project.`);
     }
-    if (analyses.length === 0) {
+    const shown = project === undefined ? [...groups] : groups.has(project) ? [[project, groups.get(project)]] : [];
+    const scope = project === undefined ? "" : ` in project "${project}"`;
+    const filtered = reviewState === undefined ? "" : ` with review state ${reviewState}`;
+    if (all.length === 0) {
         lines.push("No analyses yet. Create one with create_analysis once the feature is developed: it freezes the diff of a branch or of the working tree for human review.");
     }
+    else if (shown.length === 0) {
+        lines.push(`No analysis${scope}${filtered}. Call list_analyses without review_state to see them all.`);
+    }
     else {
-        const shown = project === undefined ? [...groups] : [[project, groups.get(project)]];
         const total = shown.reduce((sum, [, list]) => sum + list.length, 0);
         lines.push(project === undefined
-            ? `${total} analysis(es) in ${groups.size} project(s), most recently updated first:`
-            : `${total} analysis(es) in project "${project}", most recently updated first:`);
+            ? `${total} analysis(es)${filtered} in ${groups.size} project(s), most recently updated first:`
+            : `${total} analysis(es)${filtered}${scope}, most recently updated first:`);
         for (const [name, list] of shown) {
             lines.push("", `## Project "${name}" (${projectCounts(list)})`);
             for (const summary of list)

package/dist/src/tools/mark-feedback-processed.d.ts

@@ -0,0 +1,8 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/**
+ * Marque traité le retour soumis d'une analyse, avec la date et une note
+ * facultative. 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.
+ */
+export declare function markFeedbackProcessed(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/mark-feedback-processed.js

@@ -0,0 +1,34 @@
+import { AnalysisError } from "../core/errors.js";
+import { optionalString, rejectUnknownFields, requireString, textResult } from "./types.js";
+/**
+ * Marque traité le retour soumis d'une analyse, avec la date et une note
+ * facultative. 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.
+ */
+export function markFeedbackProcessed(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "note"]);
+    const id = requireString(args, "analysis_id");
+    const note = optionalString(args, "note") ?? null;
+    let replaced = null;
+    const updated = store.mutate(id, "agent", (draft) => {
+        const review = draft.review;
+        if (review.state !== "submitted") {
+            const reopened = review.previousSubmission;
+            throw new AnalysisError(reopened
+                ? `The review of analysis "${id}" is not submitted: the reviewer reopened the feedback submitted at ${reopened.submittedAt} and is changing it. ` +
+                    `Wait until it is submitted again, then read it with get_review_feedback.`
+                : `The review of analysis "${id}" is not submitted yet: there is no feedback to mark processed.`);
+        }
+        replaced = review.processed?.at ?? null;
+        review.processed = { at: new Date().toISOString(), note };
+    });
+    const processed = updated.review.processed;
+    const lines = [
+        `Marked the feedback of "${updated.title}" (${updated.id}), submitted at ${updated.review.submittedAt}, as processed at ${processed.at}.`,
+        `Note: ${processed.note ?? "none"}.`,
+    ];
+    if (replaced !== null)
+        lines.push(`This replaces the processing mark of ${replaced}.`);
+    lines.push("The feedback stays readable with get_review_feedback. If the reviewer changes the review, it becomes pending again.");
+    return { result: textResult(lines.join("\n")), analysisId: updated.id };
+}