@diegopetrucci/pi-extensions 0.1.71 → 0.1.73

package/extensions/annotate-git-diff/index.ts

@@ -8,50 +8,118 @@ import { composeReviewPrompt } from "./prompt.js";
 import { openQuietGlimpse, type QuietGlimpseWindow } from "./quiet-glimpse.js";
 import { startReviewUiServer, type ReviewUiServer } from "./review-server.js";
 import type {
+	CommentSide,
+	DiffReviewComment,
 	ReviewCancelPayload,
 	ReviewClipboardReadPayload,
 	ReviewClipboardWritePayload,
+	ReviewCommitKind,
 	ReviewFile,
 	ReviewFileContents,
 	ReviewHostMessage,
 	ReviewRequestCommitPayload,
 	ReviewRequestFilePayload,
 	ReviewRequestReviewDataPayload,
+	ReviewScope,
 	ReviewSubmitPayload,
 	ReviewWindowMessage,
 } from "./types.js";
 import { createRepoChangeWatcher, type RepoChangeWatcher } from "./watch.js";
 
-function hasMessageType(value: unknown, type: ReviewWindowMessage["type"]): boolean {
-	return typeof value === "object" && value != null && "type" in value && value.type === type;
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function isSubmitPayload(value: unknown): value is ReviewSubmitPayload {
-	return hasMessageType(value, "submit");
+function isString(value: unknown): value is string {
+	return typeof value === "string";
+}
+
+function isNullableString(value: unknown): value is string | null | undefined {
+	return value == null || typeof value === "string";
+}
+
+function isCommentSide(value: unknown): value is CommentSide {
+	return value === "original" || value === "modified" || value === "file";
+}
+
+function isReviewScope(value: unknown): value is ReviewScope {
+	return value === "branch" || value === "commits" || value === "all";
+}
+
+function isReviewCommitKind(value: unknown): value is ReviewCommitKind | null | undefined {
+	return value == null || value === "commit" || value === "working-tree";
+}
+
+function hasNullableInteger(value: Record<string, unknown>, key: string): boolean {
+	if (!Object.prototype.hasOwnProperty.call(value, key)) return false;
+	const field = value[key];
+	return field === null || (typeof field === "number" && Number.isInteger(field));
+}
+
+function isDiffReviewComment(value: unknown): value is DiffReviewComment {
+	if (!isRecord(value)) return false;
+	return (
+		isString(value.id) &&
+		isString(value.fileId) &&
+		isReviewScope(value.scope) &&
+		isNullableString(value.commitSha) &&
+		isNullableString(value.commitShort) &&
+		isReviewCommitKind(value.commitKind) &&
+		isCommentSide(value.side) &&
+		hasNullableInteger(value, "startLine") &&
+		hasNullableInteger(value, "endLine") &&
+		isString(value.body)
+	);
+}
+
+function parseSubmitPayload(value: unknown): ReviewSubmitPayload | null {
+	if (!isRecord(value) || value.type !== "submit") return null;
+	if (!isString(value.overallComment) || !Array.isArray(value.comments) || !value.comments.every(isDiffReviewComment)) {
+		return null;
+	}
+
+	// Fail-safe: only a literal false means the user explicitly clicked Submit.
+	// Missing, true, and malformed discriminator values remain editor-only drafts.
+	return {
+		type: "submit",
+		overallComment: value.overallComment,
+		comments: value.comments,
+		draft: value.draft !== false,
+	};
 }
 
 function isCancelPayload(value: unknown): value is ReviewCancelPayload {
-	return hasMessageType(value, "cancel");
+	return isRecord(value) && value.type === "cancel";
+}
+
+function hasMessageType(value: unknown, type: ReviewWindowMessage["type"]): value is Record<string, unknown> {
+	return isRecord(value) && value.type === type;
 }
 
 function isRequestFilePayload(value: unknown): value is ReviewRequestFilePayload {
-	return hasMessageType(value, "request-file");
+	return (
+		hasMessageType(value, "request-file") &&
+		isString(value.requestId) &&
+		isString(value.fileId) &&
+		isReviewScope(value.scope) &&
+		isNullableString(value.commitSha)
+	);
 }
 
 function isRequestCommitPayload(value: unknown): value is ReviewRequestCommitPayload {
-	return hasMessageType(value, "request-commit");
+	return hasMessageType(value, "request-commit") && isString(value.requestId) && isString(value.sha);
 }
 
 function isRequestReviewDataPayload(value: unknown): value is ReviewRequestReviewDataPayload {
-	return hasMessageType(value, "request-review-data");
+	return hasMessageType(value, "request-review-data") && isString(value.requestId);
 }
 
 function isClipboardReadPayload(value: unknown): value is ReviewClipboardReadPayload {
-	return hasMessageType(value, "clipboard-read");
+	return hasMessageType(value, "clipboard-read") && isString(value.requestId);
 }
 
 function isClipboardWritePayload(value: unknown): value is ReviewClipboardWritePayload {
-	return hasMessageType(value, "clipboard-write");
+	return hasMessageType(value, "clipboard-write") && isString(value.text);
 }
 
 function escapeForInlineScript(value: string): string {
@@ -143,21 +211,85 @@ export default function (pi: ExtensionAPI) {
 			if (window.failure != null) throw window.failure;
 			if (window.closed) throw new Error("Glimpse closed while the review window was starting.");
 
-			const fileMap = new Map(reviewData.files.map((file) => [file.id, file]));
+			const historicalFiles = new Map<string, ReviewFile>();
+			const rememberFiles = (files: ReviewFile[]): void => {
+				for (const file of files) {
+					// A submitted comment may outlive a refresh. Keep the first metadata
+					// advertised for an id so refreshed authorization cannot rewrite its
+					// historical path in the composed prompt.
+					if (!historicalFiles.has(file.id)) historicalFiles.set(file.id, file);
+				}
+			};
+			rememberFiles(reviewData.files);
+
+			type ReviewReadSnapshot = {
+				generation: number;
+				data: typeof reviewData;
+				branchFiles: Map<string, ReviewFile>;
+				allFiles: Map<string, ReviewFile>;
+				commitFiles: Map<string, Map<string, ReviewFile>>;
+			};
+
+			const createReviewReadSnapshot = (
+				data: typeof reviewData,
+				generation: number,
+				previous: ReviewReadSnapshot | null,
+			): ReviewReadSnapshot => {
+				const branchFiles = new Map<string, ReviewFile>();
+				const allFiles = new Map<string, ReviewFile>();
+				for (const file of data.files) {
+					allFiles.set(file.id, file);
+					if (file.inGitDiff) branchFiles.set(file.id, file);
+				}
+
+				const commitFiles = new Map<string, Map<string, ReviewFile>>();
+				for (const commit of data.commits) {
+					if (commit.kind !== "commit") continue;
+					const retainedFiles = previous?.commitFiles.get(commit.sha);
+					if (retainedFiles != null) commitFiles.set(commit.sha, retainedFiles);
+				}
+
+				return { generation, data, branchFiles, allFiles, commitFiles };
+			};
+
 			const commitFileCache = new Map<string, Promise<ReviewFile[]>>();
 			const contentCache = new Map<string, Promise<ReviewFileContents>>();
+			let currentSnapshot = createReviewReadSnapshot(reviewData, 0, null);
+			const isLiveWindow = (): boolean => activeWindow === window && attempt === reviewAttempt && !window.closed;
+
+			const cacheCommitSha = (cacheKey: string): string | null => {
+				if (!cacheKey.startsWith("commits:")) return null;
+				const rest = cacheKey.slice("commits:".length);
+				const separator = rest.indexOf(":");
+				return separator < 0 ? null : rest.slice(0, separator);
+			};
 
-			const clearRefreshableCaches = (): void => {
-				contentCache.clear();
+			const pruneCachesForReviewData = (nextReviewData: typeof reviewData): void => {
+				const retainedImmutableCommits = new Set(
+					nextReviewData.commits.filter((commit) => commit.kind === "commit").map((commit) => commit.sha),
+				);
 				for (const sha of commitFileCache.keys()) {
-					if (isWorkingTreeCommitSha(sha)) {
-						commitFileCache.delete(sha);
+					if (!retainedImmutableCommits.has(sha)) commitFileCache.delete(sha);
+				}
+				for (const cacheKey of contentCache.keys()) {
+					const commitSha = cacheCommitSha(cacheKey);
+					if (commitSha == null || !retainedImmutableCommits.has(commitSha)) {
+						contentCache.delete(cacheKey);
 					}
 				}
 			};
 
-			const sendWindowMessage = (message: ReviewHostMessage): void => {
-				if (activeWindow !== window) return;
+			const replaceReviewData = (nextReviewData: typeof reviewData): void => {
+				pruneCachesForReviewData(nextReviewData);
+				const previousSnapshot = currentSnapshot;
+				reviewData = nextReviewData;
+				rememberFiles(nextReviewData.files);
+				currentSnapshot = createReviewReadSnapshot(nextReviewData, previousSnapshot.generation + 1, previousSnapshot);
+			};
+
+			const sendWindowMessage = (message: ReviewHostMessage, guard?: () => boolean): void => {
+				if (!isLiveWindow()) return;
+				if (guard != null && !guard()) return;
 				const payload = escapeForInlineScript(JSON.stringify(message));
 				window.send(`window.__reviewReceive(${payload});`);
 			};
@@ -184,9 +316,16 @@ export default function (pi: ExtensionAPI) {
 				commitFileCache.set(sha, pending);
 				pending
 					.then((commitFiles) => {
-						for (const cf of commitFiles) fileMap.set(cf.id, cf);
+						if (commitFileCache.get(sha) !== pending || !isLiveWindow()) return;
+						if (!currentSnapshot.data.commits.some((commit) => commit.sha === sha)) return;
+						rememberFiles(commitFiles);
+						currentSnapshot.commitFiles.set(sha, new Map(commitFiles.map((file) => [file.id, file])));
 					})
-					.catch(() => {});
+					.catch(() => {
+						// A rejected promise is retryable, but an old rejection must not
+						// evict a replacement request for the same key.
+						if (isLiveWindow() && commitFileCache.get(sha) === pending) commitFileCache.delete(sha);
+					});
 				return pending;
 			};
 
@@ -194,16 +333,53 @@ export default function (pi: ExtensionAPI) {
 				file: ReviewFile,
 				scope: ReviewRequestFilePayload["scope"],
 				commitSha: string | null,
+				snapshot: ReviewReadSnapshot,
 			): Promise<ReviewFileContents> => {
 				const cacheKey = `${scope}:${commitSha ?? ""}:${file.id}`;
 				const cached = contentCache.get(cacheKey);
 				if (cached != null) return cached;
 
-				const pending = loadReviewFileContents(pi, repoRoot, file, scope, commitSha, reviewData.branchMergeBaseSha);
+				const pending = loadReviewFileContents(pi, repoRoot, file, scope, commitSha, snapshot.data.branchMergeBaseSha);
 				contentCache.set(cacheKey, pending);
+				pending.catch(() => {
+					// Do not let an older rejection remove a newer retry's promise.
+					if (isLiveWindow() && contentCache.get(cacheKey) === pending) contentCache.delete(cacheKey);
+				});
 				return pending;
 			};
 
+			const isAdvertisedCommitSha = (snapshot: ReviewReadSnapshot, sha: string): boolean =>
+				snapshot.data.commits.some((commit) => commit.sha === sha);
+
+			const isCurrentCommitRequest = (
+				snapshot: ReviewReadSnapshot,
+				sha: string,
+				pending: Promise<ReviewFile[]> | null = null,
+			): boolean => {
+				if (!isLiveWindow()) return false;
+				const commit = currentSnapshot.data.commits.find((item) => item.sha === sha);
+				if (commit == null) return false;
+				if (currentSnapshot === snapshot) return true;
+				return commit.kind === "commit" && pending != null && commitFileCache.get(sha) === pending;
+			};
+
+			const isCurrentFileRequest = (
+				snapshot: ReviewReadSnapshot,
+				scope: ReviewRequestFilePayload["scope"],
+				commitSha: string | null,
+				file: ReviewFile,
+			): boolean => {
+				if (!isLiveWindow()) return false;
+				if (scope === "commits") {
+					if (commitSha == null || !isAdvertisedCommitSha(currentSnapshot, commitSha)) return false;
+					if (isWorkingTreeCommitSha(commitSha) && currentSnapshot !== snapshot) return false;
+					return currentSnapshot.commitFiles.get(commitSha)?.get(file.id) === file;
+				}
+				if (currentSnapshot !== snapshot) return false;
+				const files = scope === "branch" ? currentSnapshot.branchFiles : currentSnapshot.allFiles;
+				return files.get(file.id) === file;
+			};
+
 			const terminalMessagePromise = new Promise<ReviewSubmitPayload | ReviewCancelPayload | null>(
 				(resolve, reject) => {
 					let settled = false;
@@ -244,59 +420,146 @@ export default function (pi: ExtensionAPI) {
 					};
 
 					const handleRequestFile = async (message: ReviewRequestFilePayload): Promise<void> => {
+						const snapshot = currentSnapshot;
+						const currentGuard = (): boolean => isLiveWindow() && currentSnapshot === snapshot;
+						const commitSha = message.commitSha ?? null;
+						if (message.scope === "commits") {
+							if (commitSha == null) {
+								sendWindowMessage(
+									{
+										type: "file-error",
+										requestId: message.requestId,
+										fileId: message.fileId,
+										scope: message.scope,
+										commitSha: null,
+										message: "A commit SHA is required for commit-scoped file requests.",
+									},
+									currentGuard,
+								);
+								return;
+							}
+							if (!isAdvertisedCommitSha(snapshot, commitSha)) {
+								sendWindowMessage(
+									{
+										type: "file-error",
+										requestId: message.requestId,
+										fileId: message.fileId,
+										scope: message.scope,
+										commitSha,
+										message: "Unknown commit requested.",
+									},
+									currentGuard,
+								);
+								return;
+							}
+						} else if (commitSha != null) {
+							sendWindowMessage(
+								{
+									type: "file-error",
+									requestId: message.requestId,
+									fileId: message.fileId,
+									scope: message.scope,
+									commitSha,
+									message: "A commit SHA is only valid for commit-scoped file requests.",
+								},
+								currentGuard,
+							);
+							return;
+						}
+
+						const fileMap =
+							message.scope === "branch"
+								? snapshot.branchFiles
+								: message.scope === "all"
+									? snapshot.allFiles
+									: snapshot.commitFiles.get(commitSha as string) ?? new Map<string, ReviewFile>();
 						const file = fileMap.get(message.fileId);
 						if (file == null) {
-							sendWindowMessage({
-								type: "file-error",
-								requestId: message.requestId,
-								fileId: message.fileId,
-								scope: message.scope,
-								commitSha: message.commitSha ?? null,
-								message: "Unknown file requested.",
-							});
+							sendWindowMessage(
+								{
+									type: "file-error",
+									requestId: message.requestId,
+									fileId: message.fileId,
+									scope: message.scope,
+									commitSha,
+									message: "Unknown file requested.",
+								},
+								currentGuard,
+							);
 							return;
 						}
 
 						try {
-							const contents = await loadContents(file, message.scope, message.commitSha ?? null);
-							sendWindowMessage({
-								type: "file-data",
-								requestId: message.requestId,
-								fileId: message.fileId,
-								scope: message.scope,
-								commitSha: message.commitSha ?? null,
-								originalContent: contents.originalContent,
-								modifiedContent: contents.modifiedContent,
-								kind: contents.kind,
-								mimeType: contents.mimeType,
-								originalExists: contents.originalExists,
-								modifiedExists: contents.modifiedExists,
-								originalPreviewUrl: contents.originalPreviewUrl,
-								modifiedPreviewUrl: contents.modifiedPreviewUrl,
-							});
+							const contents = await loadContents(file, message.scope, commitSha, snapshot);
+							if (!isCurrentFileRequest(snapshot, message.scope, commitSha, file)) return;
+							sendWindowMessage(
+								{
+									type: "file-data",
+									requestId: message.requestId,
+									fileId: message.fileId,
+									scope: message.scope,
+									commitSha,
+									originalContent: contents.originalContent,
+									modifiedContent: contents.modifiedContent,
+									kind: contents.kind,
+									mimeType: contents.mimeType,
+									originalExists: contents.originalExists,
+									modifiedExists: contents.modifiedExists,
+									originalPreviewUrl: contents.originalPreviewUrl,
+									modifiedPreviewUrl: contents.modifiedPreviewUrl,
+								},
+								() => isCurrentFileRequest(snapshot, message.scope, commitSha, file),
+							);
 						} catch (error) {
+							if (!isCurrentFileRequest(snapshot, message.scope, commitSha, file)) return;
 							const messageText = error instanceof Error ? error.message : String(error);
-							sendWindowMessage({
-								type: "file-error",
-								requestId: message.requestId,
-								fileId: message.fileId,
-								scope: message.scope,
-								commitSha: message.commitSha ?? null,
-								message: messageText,
-							});
+							sendWindowMessage(
+								{
+									type: "file-error",
+									requestId: message.requestId,
+									fileId: message.fileId,
+									scope: message.scope,
+									commitSha,
+									message: messageText,
+								},
+								() => isCurrentFileRequest(snapshot, message.scope, commitSha, file),
+							);
 						}
 					};
 
 					const handleRequestCommit = async (message: ReviewRequestCommitPayload): Promise<void> => {
+						const snapshot = currentSnapshot;
+						const currentGuard = (): boolean => isLiveWindow() && currentSnapshot === snapshot;
+						if (!isAdvertisedCommitSha(snapshot, message.sha)) {
+							sendWindowMessage(
+								{
+									type: "commit-error",
+									requestId: message.requestId,
+									sha: message.sha,
+									message: "Unknown commit requested.",
+								},
+								currentGuard,
+							);
+							return;
+						}
+
+						const pending = loadCommitFiles(message.sha);
 						try {
-							const commitFiles = await loadCommitFiles(message.sha);
-							sendWindowMessage({
-								type: "commit-data",
-								requestId: message.requestId,
-								sha: message.sha,
-								files: commitFiles,
-							});
+							const commitFiles = await pending;
+							if (!isCurrentCommitRequest(snapshot, message.sha, pending)) return;
+							if (currentSnapshot.commitFiles.get(message.sha) == null) return;
+							sendWindowMessage(
+								{
+									type: "commit-data",
+									requestId: message.requestId,
+									sha: message.sha,
+									files: commitFiles,
+								},
+								() =>
+									isCurrentCommitRequest(snapshot, message.sha, pending) && currentSnapshot.commitFiles.get(message.sha) != null,
+							);
 						} catch (error) {
+							if (!isCurrentCommitRequest(snapshot, message.sha, pending)) return;
 							const messageText = error instanceof Error ? error.message : String(error);
 							sendWindowMessage({
 								type: "commit-error",
@@ -307,22 +570,29 @@ export default function (pi: ExtensionAPI) {
 						}
 					};
 
+					let refreshRequestSequence = 0;
+					let newestRefreshRequest = 0;
 					const handleRequestReviewData = async (message: ReviewRequestReviewDataPayload): Promise<void> => {
+						const refreshRequest = ++refreshRequestSequence;
+						newestRefreshRequest = refreshRequest;
 						try {
 							const nextReviewData = await getReviewWindowData(pi, repoRoot);
-							clearRefreshableCaches();
-							reviewData = nextReviewData;
-							for (const file of reviewData.files) fileMap.set(file.id, file);
-							sendWindowMessage({
-								type: "review-data",
-								requestId: message.requestId,
-								files: reviewData.files,
-								commits: reviewData.commits,
-								branchBaseRef: reviewData.branchBaseRef,
-								branchMergeBaseSha: reviewData.branchMergeBaseSha,
-								repositoryHasHead: reviewData.repositoryHasHead,
-							});
+							if (!isLiveWindow() || refreshRequest !== newestRefreshRequest) return;
+							replaceReviewData(nextReviewData);
+							sendWindowMessage(
+								{
+									type: "review-data",
+									requestId: message.requestId,
+									files: nextReviewData.files,
+									commits: nextReviewData.commits,
+									branchBaseRef: nextReviewData.branchBaseRef,
+									branchMergeBaseSha: nextReviewData.branchMergeBaseSha,
+									repositoryHasHead: nextReviewData.repositoryHasHead,
+								},
+								() => isLiveWindow() && refreshRequest === newestRefreshRequest,
+							);
 						} catch (error) {
+							if (!isLiveWindow() || refreshRequest !== newestRefreshRequest) return;
 							const messageText = error instanceof Error ? error.message : String(error);
 							sendWindowMessage({
 								type: "review-data-error",
@@ -360,6 +630,20 @@ export default function (pi: ExtensionAPI) {
 					};
 
 					const onMessage = (message: unknown): void => {
+						// Terminal messages remain recoverable during the native close grace
+						// period; all other work must stop once the window is closed or retired.
+						const submit = parseSubmitPayload(message);
+						if (submit != null) {
+							settle(submit);
+							requestWindowClose();
+							return;
+						}
+						if (isCancelPayload(message)) {
+							settle(message);
+							requestWindowClose();
+							return;
+						}
+						if (!isLiveWindow()) return;
 						if (isRequestFilePayload(message)) {
 							void handleRequestFile(message);
 							return;
@@ -378,11 +662,6 @@ export default function (pi: ExtensionAPI) {
 						}
 						if (isClipboardWritePayload(message)) {
 							handleClipboardWrite(message);
-							return;
-						}
-						if (isSubmitPayload(message) || isCancelPayload(message)) {
-							requestWindowClose();
-							settle(message);
 						}
 					};
 
@@ -415,7 +694,7 @@ export default function (pi: ExtensionAPI) {
 			void (async () => {
 				try {
 					const message = await terminalMessagePromise;
-					if (suppressedWindows.has(window)) return;
+					if (suppressedWindows.has(window) || attempt !== reviewAttempt) return;
 					if (message == null) return;
 					if (message.type === "cancel") {
 						ctx.ui.notify("Review cancelled.", "info");
@@ -423,11 +702,16 @@ export default function (pi: ExtensionAPI) {
 					}
 					if (!hasReviewFeedback(message)) return;
 
-					const prompt = composeReviewPrompt([...fileMap.values()], message);
-					appendReviewPrompt(ctx, prompt);
-					ctx.ui.notify("Appended review feedback to the editor.", "info");
+					const prompt = composeReviewPrompt([...historicalFiles.values()], message);
+					if (message.draft === true) {
+						appendReviewPrompt(ctx, prompt);
+						ctx.ui.notify("Appended review feedback to the editor.", "info");
+					} else {
+						pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+						ctx.ui.notify("Review feedback sent to the agent.", "info");
+					}
 				} catch (error) {
-					if (suppressedWindows.has(window)) return;
+					if (suppressedWindows.has(window) || attempt !== reviewAttempt) return;
 					const message = error instanceof Error ? error.message : String(error);
 					ctx.ui.notify(`Review failed: ${message}`, "error");
 				}
@@ -435,6 +719,7 @@ export default function (pi: ExtensionAPI) {
 
 			ctx.ui.notify("Opened native review window.", "info");
 		} catch (error) {
+			if (attempt !== reviewAttempt) return;
 			closeActiveWindow({ suppressResults: true });
 			const message = error instanceof Error ? error.message : String(error);
 			ctx.ui.notify(`Review failed: ${message}`, "error");

package/extensions/annotate-git-diff/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-annotate-git-diff",
-  "version": "0.1.11",
-  "description": "A standalone pi extension that adds /annotate-git-diff, a native Glimpse UI for annotating git diffs and sending feedback to the editor.",
+  "version": "0.1.12",
+  "description": "A standalone pi extension that adds /annotate-git-diff, a native Glimpse UI for annotating git diffs and sending explicit feedback directly to the agent; close recovery keeps unsent drafts in the editor.",
   "keywords": [
     "pi-package",
     "pi",

package/extensions/annotate-git-diff/quiet-glimpse.ts

@@ -57,13 +57,15 @@ class QuietGlimpseWindowImpl extends EventEmitter implements QuietGlimpseWindow
 
 		const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
 		rl.on("line", (line) => {
-			let message: GlimpseProtocolMessage;
+			let parsed: unknown;
 			try {
-				message = JSON.parse(line) as GlimpseProtocolMessage;
+				parsed = JSON.parse(line);
 			} catch {
 				this.#reportError(new Error(`Malformed glimpse protocol line: ${line}`));
 				return;
 			}
+			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return;
+			const message = parsed as GlimpseProtocolMessage;
 
 			switch (message.type) {
 				case "ready":

package/extensions/annotate-git-diff/types.ts

@@ -71,6 +71,12 @@ export interface ReviewSubmitPayload {
 	type: "submit";
 	overallComment: string;
 	comments: DiffReviewComment[];
+	/**
+	 * True means this is a close-recovery draft and must stay editor-only.
+	 * Only literal false permits an explicit submission to trigger an agent turn;
+	 * malformed or missing values are normalized to true by the host.
+	 */
+	draft: boolean;
 }
 
 export interface ReviewCancelPayload {