@@ -17,6 +17,7 @@
 -   Notes: Keep the clicked thread selected on a block with several notes, instead of switching to the block's primary note ([#83528](https://github.com/WordPress/gutenberg/pull/83528)).
 -   Notes: Keep floating threads aligned with their blocks when an editor notice or the device preview moves the canvas ([#83485](https://github.com/WordPress/gutenberg/pull/83485)).
 -   Notes: Add an Undo action to the "Note deleted." snackbar, and stop the editor's undo from bringing back the highlight of a deleted note ([#83988](https://github.com/WordPress/gutenberg/pull/83988)).
+-   Notes: Stop the editor's undo from detaching a newly added note from its block, or bringing back the highlight of a resolved note ([#84079](https://github.com/WordPress/gutenberg/pull/84079)).
 
 ### Internal
 
 
@@ -22,15 +22,14 @@ import { unlock } from '../../lock-unlock';
 import { createBoardStore } from './board-store';
 import {
 	calculateNotePositions,
-	clearInlineNoteMarker,
 	findNoteInBlock,
 	focusNoteThread,
 	getInlineMarkerStart,
 	getNoteIdsFromMetadata,
 	addNoteIdToMetadata,
 	pickPrimaryNote,
 	readInlineSelection,
-	removeNoteFormat,
+	removeInlineNote,
 	removeNoteIdFromMetadata,
 	wrapInlineNote,
 } from './utils';
@@ -177,7 +176,6 @@ export function useNoteActions() {
 	const { getCurrentPostId } = useSelect( editorStore );
 	const {
 		getBlockAttributes,
-		getClientIdsWithDescendants,
 		getSelectedBlockClientId,
 		getSelectionStart,
 		getSelectionEnd,
@@ -199,6 +197,17 @@ export function useNoteActions() {
 		} );
 	};
 
+	/*
+	 * Update a note's anchor without an undo step, since undo can't bring the
+	 * note back with it. The last call flags the post as changed, so "Save
+	 * draft" turns on.
+	 */
+	const updateNoteAnchor = ( clientId, attributes ) => {
+		__unstableMarkNextChangeAsNotPersistent( { history: 'ignore' } );
+		updateBlockAttributes( clientId, attributes );
+		__unstableMarkLastChangeAsPersistent();
+	};
+
 	const onCreate = async ( { content, parent } ) => {
 		try {
 			// Capture the target block and inline selection *before* the async
@@ -257,7 +266,7 @@ export function useNoteActions() {
 					}
 				}
 
-				updateBlockAttributes( clientId, newAttributes );
+				updateNoteAnchor( clientId, newAttributes );
 			}
 
 			createNotice(
@@ -274,7 +283,8 @@ export function useNoteActions() {
 		}
 	};
 
-	const onEdit = async ( { id, content, status } ) => {
+	const onEdit = async ( note, { content, status } ) => {
+		const { id } = note;
 		try {
 			// For resolution or reopen actions, create a new note with metadata.
 			if ( status === 'approved' || status === 'hold' ) {
@@ -315,13 +325,17 @@ export function useNoteActions() {
 
 				// Resolving a note drops its inline highlight: strip the marker
 				// so the note falls back to a block-level note in the content.
-				if ( status === 'approved' ) {
-					clearInlineNoteMarker(
-						id,
-						getClientIdsWithDescendants,
-						getBlockAttributes,
-						updateBlockAttributes
+				const removed =
+					status === 'approved' &&
+					note.blockClientId &&
+					removeInlineNote(
+						getBlockAttributes( note.blockClientId ),
+						id
 					);
+				if ( removed ) {
+					updateNoteAnchor( note.blockClientId, {
+						[ removed.attributeKey ]: removed.value,
+					} );
 				}
 
 				// The note visibly updates in place, so there is no snackbar,
@@ -361,17 +375,6 @@ export function useNoteActions() {
 		}
 	};
 
-	/*
-	 * Update a note's anchor without an undo step, since undo can't bring the
-	 * note back with it. The last call flags the post as changed, so "Save
-	 * draft" turns on.
-	 */
-	const updateNoteAnchor = ( clientId, attributes ) => {
-		__unstableMarkNextChangeAsNotPersistent( { history: 'ignore' } );
-		updateBlockAttributes( clientId, attributes );
-		__unstableMarkLastChangeAsPersistent();
-	};
-
 	const restoreNote = async ( noteId, anchor ) => {
 		try {
 			// Untrash first, so a failure doesn't leave an anchor without a note.
@@ -439,9 +442,7 @@ export function useNoteActions() {
 			// Capture the target block *before* the async delete: selection may
 			// shift during the round-trip, pointing the attribute cleanup at the
 			// wrong block.
-			const clientId = ! note.parent
-				? note.blockClientId || getSelectedBlockClientId()
-				: null;
+			const clientId = ! note.parent ? note.blockClientId : null;
 
 			// Without `force`, this moves the note to the trash, so the
 			// snackbar's Undo can bring it back.
@@ -465,19 +466,16 @@ export function useNoteActions() {
 				};
 				// Strip the inline marker too (if any) so the deleted note's
 				// highlight doesn't linger in the content.
-				const found = findNoteInBlock( attributes, note.id );
-				if ( found ) {
-					const next = removeNoteFormat(
-						attributes[ found.attributeKey ],
-						note.id
-					);
-					if ( next ) {
-						newAttributes[ found.attributeKey ] = next;
-						anchor.inline = {
-							...found,
-							text: next.text.slice( found.start, found.end ),
-						};
-					}
+				const removed = removeInlineNote( attributes, note.id );
+				if ( removed ) {
+					const { attributeKey, start, end, value } = removed;
+					newAttributes[ attributeKey ] = value;
+					anchor.inline = {
+						attributeKey,
+						start,
+						end,
+						text: value.text.slice( start, end ),
+					};
 				}
 				updateNoteAnchor( clientId, newAttributes );
 			}
 
@@ -148,7 +148,7 @@ export function NoteThread( {
 	}
 
 	function handleResolve() {
-		onEditNote( { id: note.id, status: 'approved' } );
+		onEditNote( note, { status: 'approved' } );
 		onDeselectNote();
 		if ( isFloating ) {
 			relatedBlockElement?.focus();
@@ -301,8 +301,7 @@ export function NoteThread( {
 						onSubmit={ ( inputComment ) => {
 							if ( 'approved' === note.status ) {
 								// For reopening, include the content in the reopen action.
-								return onEditNote( {
-									id: note.id,
+								return onEditNote( note, {
 									status: 'hold',
 									content: inputComment,
 								} );
 
@@ -99,7 +99,7 @@ export function Note( {
 			id: 'reopen',
 			title: _x( 'Reopen', 'Reopen note' ),
 			isEligible: ( { status } ) => canResolve && hasResolved( status ),
-			onClick: () => onEditNote( { id: note.id, status: 'hold' } ),
+			onClick: () => onEditNote( note, { status: 'hold' } ),
 		},
 		{
 			id: 'delete',
@@ -130,8 +130,7 @@ export function Note( {
 		body = (
 			<NoteForm
 				onSubmit={ async ( value ) => {
-					const saved = await onEditNote( {
-						id: note.id,
+					const saved = await onEditNote( note, {
 						content: value,
 					} );
 					// Keep the form open on failure so the edit isn't lost.
 
@@ -520,38 +520,17 @@ export function removeNoteFormat( value, noteId ) {
 }
 
 /**
- * Strip a note's inline `core/note` marker from whichever block holds it, if
- * any, so a deleted or resolved note's highlight does not linger in the content.
- * No-op for block-level notes (those carry no marker). Used by the resolve path,
- * which only knows the note id; the delete path strips the marker inline since
- * it already has the block.
+ * Remove a note's inline `core/note` marker from block attributes.
  *
- * @param {number}                                         noteId                      Note id whose marker to remove.
- * @param {() => string[]}                                 getClientIdsWithDescendants Block-editor selector.
- * @param {(clientId: string) => Record<string, unknown>}  getBlockAttributes          Block-editor selector.
- * @param {(clientId: string, attributes: Object) => void} updateBlockAttributes       Block-editor action.
+ * @param {?Object}       attributes Block attributes.
+ * @param {number|string} noteId     Note id whose marker to remove.
+ * @return {?{attributeKey: string, start: number, end: number, value: RichTextData}} Marker range and the new attribute value, or null when no marker.
  */
-export function clearInlineNoteMarker(
-	noteId,
-	getClientIdsWithDescendants,
-	getBlockAttributes,
-	updateBlockAttributes
-) {
-	for ( const clientId of getClientIdsWithDescendants() ) {
-		const attributes = getBlockAttributes( clientId );
-		const found = findNoteInBlock( attributes, noteId );
-		if ( ! found ) {
-			continue;
-		}
-		const next = removeNoteFormat(
-			attributes[ found.attributeKey ],
-			noteId
-		);
-		if ( next ) {
-			updateBlockAttributes( clientId, { [ found.attributeKey ]: next } );
-		}
-		return;
-	}
+export function removeInlineNote( attributes, noteId ) {
+	const found = findNoteInBlock( attributes, noteId );
+	const value =
+		found && removeNoteFormat( attributes[ found.attributeKey ], noteId );
+	return value ? { ...found, value } : null;
 }
 
 /**
 
@@ -1732,6 +1732,45 @@ test.describe( 'Block Notes', () => {
 		} );
 	} );
 
+	test( 'keeps note anchors out of the undo history', async ( {
+		editor,
+		page,
+		pageUtils,
+		blockNoteUtils,
+	} ) => {
+		await editor.insertBlock( {
+			name: 'core/paragraph',
+			attributes: { content: 'Keep my anchor.' },
+		} );
+		// Start with an empty undo stack, so the shortcut can only reach the
+		// note's anchor.
+		await editor.saveDraft();
+		await page.reload();
+		await blockNoteUtils.showAllNotes();
+
+		const paragraph = editor.canvas.getByRole( 'document', {
+			name: 'Block: Paragraph',
+		} );
+		await paragraph.click();
+		await blockNoteUtils.selectBlockText();
+		await blockNoteUtils.addNote( 'Stay attached' );
+		const marker = editor.canvas.locator( 'mark.wp-note' );
+
+		// Undo doesn't detach the new note from its block.
+		await pageUtils.pressKeys( 'primary+z' );
+		await expect( marker ).toHaveText( 'Keep my anchor.' );
+		const [ block ] = await editor.getBlocks();
+		expect( block.attributes.metadata?.noteId ).toHaveLength( 1 );
+
+		// Undo doesn't bring back the marker of a resolved note.
+		await blockNoteUtils.getThread( 'Stay attached' ).click();
+		await page.getByRole( 'button', { name: 'Resolve' } ).click();
+		await expect( marker ).toHaveCount( 0 );
+		await pageUtils.pressKeys( 'primary+z' );
+		await expect( marker ).toHaveCount( 0 );
+		await expect( paragraph ).toHaveText( 'Keep my anchor.' );
+	} );
+
 	test.describe( 'Restoring a deleted note', () => {
 		async function addInlineNote( { editor, blockNoteUtils }, note ) {
 			const paragraph = editor.canvas.getByRole( 'document', {
@@ -1821,6 +1860,11 @@ test.describe( 'Block Notes', () => {
 				name: 'core/paragraph',
 				attributes: { content: 'Undo after delete.' },
 			} );
+			// Start with an empty undo stack, so the shortcut can't undo the
+			// block insertion instead.
+			await editor.saveDraft();
+			await page.reload();
+			await blockNoteUtils.showAllNotes();
 			await addInlineNote( { editor, blockNoteUtils }, 'Stay deleted' );
 
 			await blockNoteUtils.deleteNote();