@@ -12,6 +12,7 @@
 -   Suggest mode: keep a pasted run's bold, italics and links when it becomes a suggestion. A rich-text paste was diffed as plain text, so the marker held the words and none of their formatting and accepting the suggestion destroyed a pasted link. The pasted run is now carried into the marker as rich text, whether it opens a new addition or grows the author's own pending one, with the marker stamped as the outermost format so the proposal stays a single `<mark>` ([#81672](https://github.com/WordPress/gutenberg/pull/81672)).
 -   Suggest mode: keep the code editor closed while the Suggest intent is active and while the post still carries unresolved inline suggestion markers, and identify a marker by its element rather than by a substring of the document ([#81662](https://github.com/WordPress/gutenberg/pull/81662)).
 -   Suggest mode: Announce inline suggestion markers to screen readers. A marker's state was carried entirely by color and text decoration, so a run proposed for deletion was read aloud as ordinary prose. Each marker is now bracketed by an announcement naming the kind of change and the person who proposed it, and add and delete markers carry `role="insertion"` and `role="deletion"`; a formatting suggestion no longer claims to be a deletion. Suggestions over overlapping runs nest, and each is announced and attributed to the person who made it ([#81663](https://github.com/WordPress/gutenberg/pull/81663), [#81957](https://github.com/WordPress/gutenberg/pull/81957)).
+-   Suggest mode: keep a review decision and its note together through undo. Accepting or rejecting a suggestion changes block content and resolves the note, but only the content half is in the undo stack, so undo put the marker back on a note that stayed resolved - a marked-up run with no Accept/Reject on it and no way to clear it. Undoing a decision made in this session now reopens its note along with the marker ([#81669](https://github.com/WordPress/gutenberg/pull/81669)).
 -   Suggest mode: extend a format suggestion on a second toggle instead of opening a second one. Toggling a further format over a run that already carries the suggester's own pending `format` marker recorded a suggestion whose before and after were both empty - unreviewable and unapplyable - and made every marker in the block disappear. The existing suggestion is now revised in place, a toggle that restores the original run retracts it rather than storing a note that proposes nothing, and a note that has replies is revised rather than withdrawn ([#81665](https://github.com/WordPress/gutenberg/pull/81665)).
 -   Suggest mode: refuse post status changes while suggesting. `editPost` drops the `status` field in the `suggest` intent, the status control and the summary panel show the status without offering to change it, and the publish button is disabled there rather than dropping the status edit and saving the post anyway. A status edit that travels with a companion field - the `password` that visibility changes carry, the `date` that scheduling carries - is refused whole rather than half-applied, a status repeated at the value it already holds is not announced as a refusal, and a status staged before the intent changed is discarded on the way in. The refusal is announced and shown in a snackbar ([#81664](https://github.com/WordPress/gutenberg/pull/81664)).
 -   Register the editor and block editor keyboard shortcuts from the editor provider, so shortcuts work for consumers that mount the editor without rendering `EditorKeyboardShortcutsRegister` themselves ([#81580](https://github.com/WordPress/gutenberg/pull/81580)).
 
@@ -426,10 +426,56 @@ function withDecisionInFlight( decide ) {
 			return await decide( args );
 		} finally {
 			decisionsInFlight.delete( key );
+			resolvedThisSession.add( key );
 		}
 	};
 }
 
+/*
+ * Suggestions this session has applied or rejected.
+ *
+ * A decision has two halves: the block change, which the undo stack holds, and
+ * the comment's lifecycle status, which lives on the server and no keystroke
+ * here can walk back. Undo therefore puts a marker back while its note stays
+ * resolved, leaving a marked-up run with no Accept/Reject on it and no way to
+ * clear it through the UI (issue #73411, F-18). The note collector watches this
+ * set and reopens a note whose marker reappears, so the two halves travel
+ * together again.
+ *
+ * Deliberately scoped to decisions made HERE rather than to every resolved note
+ * that has a live marker: a peer's decision arriving through sync before this
+ * session's content catches up looks identical from the outside, and reopening
+ * that would undo their review.
+ */
+const resolvedThisSession = new Set();
+
+/**
+ * Comment ids this session applied or rejected and has not yet reopened.
+ *
+ * @return {Set<string>} Comment id keys.
+ */
+export function getSuggestionsResolvedThisSession() {
+	return resolvedThisSession;
+}
+
+/**
+ * Forget a decision, once its note has been reopened or is past reopening.
+ *
+ * @param {number|string} commentId Comment id.
+ */
+export function forgetResolvedSuggestion( commentId ) {
+	resolvedThisSession.delete( String( commentId ) );
+}
+
+/**
+ * Record a decision again, so a failed reopen is retried on a later pass.
+ *
+ * @param {number|string} commentId Comment id.
+ */
+export function rememberResolvedSuggestion( commentId ) {
+	resolvedThisSession.add( String( commentId ) );
+}
+
 /**
  * Comment-meta backed suggestions provider. The provider shape is stable so
  * a future Yjs-backed provider can swap in without touching the UI.
 
@@ -36,8 +36,11 @@ import { useSuggestionOverlay } from './overlay-context';
 import {
 	findInlineOp,
 	findStructuralOp,
+	forgetResolvedSuggestion,
+	getSuggestionsResolvedThisSession,
 	isSuggestionDecisionInFlight,
 	parseSuggestionPayload,
+	rememberResolvedSuggestion,
 } from './provider';
 import { findSuggestionRange } from '../inline-suggestions';
 import { getNoteIdsFromMetadata } from '../collab-sidebar/utils';
@@ -156,13 +159,25 @@ export default function SuggestionNoteGC() {
 	// Pending suggestion root notes only; replies and resolved notes have no
 	// anchor contract.
 	const suggestionNotes = [];
+	/*
+	 * Notes this session applied or rejected. Their marker should be gone; if
+	 * it is back, an undo walked the block half of the decision back while the
+	 * note stayed resolved, and the note has to follow (#73411, F-18).
+	 */
+	const resolvedNotes = [];
+	const resolvedIds = getSuggestionsResolvedThisSession();
 	for ( const note of notes ?? [] ) {
-		if ( note.parent !== 0 || note.status !== 'hold' ) {
+		if ( note.parent !== 0 ) {
 			continue;
 		}
 		const anchor = describeAnchor( note );
-		if ( anchor ) {
+		if ( ! anchor ) {
+			continue;
+		}
+		if ( note.status === 'hold' ) {
 			suggestionNotes.push( { note, anchor } );
+		} else if ( resolvedIds.has( String( note.id ) ) ) {
+			resolvedNotes.push( { note, anchor } );
 		}
 	}
 
@@ -174,6 +189,8 @@ export default function SuggestionNoteGC() {
 
 	const entriesRef = useRef( entries );
 	entriesRef.current = entries;
+	const resolvedNotesRef = useRef( resolvedNotes );
+	resolvedNotesRef.current = resolvedNotes;
 	const clearOverlayRef = useRef( clearOverlay );
 	clearOverlayRef.current = clearOverlay;
 
@@ -210,6 +227,15 @@ export default function SuggestionNoteGC() {
 					}`
 				);
 			}
+			for ( const { note, anchor } of resolvedNotes ) {
+				parts.push(
+					`r${ note.id }:${
+						isAnchorPresent( note, anchor, blockEditor, entries )
+							? 1
+							: 0
+					}`
+				);
+			}
 			return parts.join( '|' );
 		},
 		// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -338,6 +364,42 @@ export default function SuggestionNoteGC() {
 				trashedRef.current.set( idKey, info );
 			} );
 		}
+		/*
+		 * Undo: a decision this session made has had its marker put back. The
+		 * comment's status is the half undo cannot reach, so reopen it here -
+		 * otherwise the run stays marked with no Accept/Reject on it and no way
+		 * to clear it through the UI (#73411, F-18). The in-flight guard keeps
+		 * this off the decision's own window, where the status can land before
+		 * the tree has been mutated.
+		 */
+		for ( const { note, anchor } of resolvedNotesRef.current ) {
+			if (
+				isSuggestionDecisionInFlight( note.id ) ||
+				! isAnchorPresent(
+					note,
+					anchor,
+					blockEditor,
+					entriesRef.current
+				)
+			) {
+				continue;
+			}
+			forgetResolvedSuggestion( note.id );
+			saveEntityRecord(
+				'root',
+				'comment',
+				{
+					id: note.id,
+					status: 'hold',
+					meta: { _wp_suggestion_status: '' },
+				},
+				{ throwOnError: true }
+			).catch( () => {
+				// Reopen failed; leave it recorded so a later pass retries.
+				rememberResolvedSuggestion( note.id );
+			} );
+		}
+
 		// `presenceSignature` fully determines the work; the other values are
 		// read through refs or stable.
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 
@@ -34,6 +34,8 @@ import {
 	findInlineOp,
 	clearSuggestionMarkerAttributes,
 	useSuggestionsProvider,
+	getSuggestionsResolvedThisSession,
+	forgetResolvedSuggestion,
 } from '../provider';
 
 describe( 'operationsFromOverlay', () => {
@@ -1158,3 +1160,169 @@ describe( 'createSuggestion (notes sidebar switch)', () => {
 		).toBe( FLOATING_NOTES_SIDEBAR );
 	} );
 } );
+
+describe( 'review decisions and undo history', () => {
+	const PARAGRAPH = 'core/test-decision-paragraph';
+
+	beforeAll( () => {
+		if (
+			! select( richTextStore ).getFormatType( SUGGESTION_FORMAT_NAME )
+		) {
+			registerFormatType( SUGGESTION_FORMAT_NAME, suggestionFormat );
+		}
+		registerBlockType( PARAGRAPH, {
+			apiVersion: 3,
+			attributes: {
+				content: { type: 'string', default: '' },
+				metadata: { type: 'object' },
+			},
+			save: () => null,
+			category: 'text',
+			title: 'Test Decision Paragraph',
+		} );
+	} );
+
+	afterAll( () => {
+		if ( select( richTextStore ).getFormatType( SUGGESTION_FORMAT_NAME ) ) {
+			unregisterFormatType( SUGGESTION_FORMAT_NAME );
+		}
+		getBlockTypes().forEach( ( block ) =>
+			unregisterBlockType( block.name )
+		);
+	} );
+
+	function setup() {
+		const registry = createRegistry();
+		registry.register( noticesStore );
+		registry.register( blockEditorStore );
+		registry.register(
+			createReduxStore( 'core', {
+				reducer: ( state = {} ) => state,
+				actions: {
+					saveEntityRecord: () => async () => ( { id: 9 } ),
+				},
+				selectors: {
+					getEditedEntityRecord: () => null,
+					getEntityRecord: () => null,
+					getCurrentUser: () => null,
+				},
+			} )
+		);
+		registry.register( createStubInterfaceStore() );
+
+		const block = createBlock( PARAGRAPH );
+		registry.dispatch( blockEditorStore ).resetBlocks( [ block ] );
+		registry
+			.dispatch( blockEditorStore )
+			.updateBlockAttributes( block.clientId, {
+				content: RichTextData.fromHTMLString(
+					'Hello <mark class="wp-suggestion" data-suggestion-id="9" data-suggestion-type="add">world</mark>'
+				),
+			} );
+		// Close the setup writes as a normal undo level so the assertions
+		// below observe the decision's own history mode, not a leftover.
+		registry
+			.dispatch( blockEditorStore )
+			.__unstableMarkLastChangeAsPersistent();
+
+		let providerHandle;
+		function CaptureProvider() {
+			providerHandle = useSuggestionsProvider();
+			return null;
+		}
+
+		render(
+			<RegistryProvider value={ registry }>
+				<CaptureProvider />
+			</RegistryProvider>
+		);
+
+		return { registry, block, getProvider: () => providerHandle };
+	}
+
+	const inlinePayload = {
+		schemaVersion: 2,
+		blockName: PARAGRAPH,
+		baseRevision: null,
+		operations: [
+			{
+				type: 'inline-suggestion',
+				attribute: 'content',
+				suggestionType: 'add',
+			},
+		],
+	};
+
+	it( 'commits an applied suggestion as a persistent change', async () => {
+		const { registry, block, getProvider } = setup();
+
+		await act( async () => {
+			await getProvider().applySuggestion( {
+				commentId: 9,
+				clientId: block.clientId,
+				payload: inlinePayload,
+			} );
+		} );
+
+		// The proposed text is committed...
+		expect(
+			registry
+				.select( blockEditorStore )
+				.getBlockAttributes( block.clientId )
+				?.content.toHTMLString()
+		).toBe( 'Hello world' );
+		/*
+		 * ...as a PERSISTENT change. Hiding the decision from undo also hides
+		 * it from the entity: a non-persistent block change reaches the parent
+		 * through `onInput`, which never writes `content`, so the post would
+		 * never go dirty and the applied text would be gone on reload. The
+		 * undo half of F-18 is handled by reopening the note instead, in
+		 * `SuggestionNoteGC`.
+		 */
+		expect(
+			registry
+				.select( blockEditorStore )
+				.__unstableGetLastBlockChangeHistoryMode()
+		).toBe( 'persistent' );
+	} );
+
+	it( 'commits a rejected suggestion as a persistent change', async () => {
+		const { registry, block, getProvider } = setup();
+
+		await act( async () => {
+			await getProvider().rejectSuggestion( {
+				commentId: 9,
+				clientId: block.clientId,
+				payload: inlinePayload,
+			} );
+		} );
+
+		expect(
+			registry
+				.select( blockEditorStore )
+				.getBlockAttributes( block.clientId )
+				?.content.toHTMLString()
+		).toBe( 'Hello ' );
+		expect(
+			registry
+				.select( blockEditorStore )
+				.__unstableGetLastBlockChangeHistoryMode()
+		).toBe( 'persistent' );
+	} );
+
+	it( 'records a decided suggestion so its note can be reopened', async () => {
+		const { block, getProvider } = setup();
+
+		await act( async () => {
+			await getProvider().applySuggestion( {
+				commentId: 9,
+				clientId: block.clientId,
+				payload: inlinePayload,
+			} );
+		} );
+
+		// The note collector reads this to spot a marker an undo put back.
+		expect( getSuggestionsResolvedThisSession().has( '9' ) ).toBe( true );
+		forgetResolvedSuggestion( 9 );
+	} );
+} );