diff --git a/playwright/e2e/comments.spec.ts b/playwright/e2e/comments.spec.ts
index 74b37ca25f0..07d387c0570 100644
--- a/playwright/e2e/comments.spec.ts
+++ b/playwright/e2e/comments.spec.ts
@@ -139,14 +139,48 @@ test.describe('deletes last comment reply', () => {
 	})
 })
 
-test('hides and shows comment references via annotations toggle', async ({ editor, open }) => {
-	await open()
-	await editor.type('Test[?]')
-	await expect(editor.commentReferences.first()).toBeVisible()
+test.describe('toggles annotations', () => {
+	test.use({
+		fileContent: 'Test[^comment-1]\n\n'
+			+ '[^comment-1]:\n'
+			+ '    - @[jane](mention://user/jane) *(2026-0716T13:12Z)*\n'
+			+ '      Comment by Jane\n',
+	})
+	test('hides and shows comment references via annotations toggle', async ({ editor, open }) => {
+		await open()
+		await expect(editor.commentReferences.first()).toBeVisible()
 
-	await editor.clickMenu('Annotations', 'Hide annotations')
-	await expect(editor.commentReferences.first()).toBeHidden()
+		await editor.clickMenu('Annotations', 'Hide annotations')
+		await expect(editor.commentReferences).toHaveCount(1)
+		await expect(editor.commentReferences.first()).toBeHidden()
 
-	await editor.clickMenu('Annotations', 'Show annotations')
-	await expect(editor.commentReferences.first()).toBeVisible()
+		await editor.clickMenu('Annotations', 'Show annotations')
+		await expect(editor.commentReferences.first()).toBeVisible()
+	})
+})
+
+test.describe('navigates between comments', () => {
+	test.use({
+		fileContent: 'The quick[^comment-1] brown[^comment-2] fox.\n\n'
+			+ '[^comment-1]:\n'
+			+ '    - @[jane](mention://user/jane) *(2026-07-16T13:12Z)*\n'
+			+ '      First comment\n\n'
+			+ '[^comment-2]:\n'
+			+ '    - @[bob](mention://user/bob) *(2026-07-16T13:13Z)*\n'
+			+ '      Second comment\n',
+	})
+
+	test('shows the position and moves with buttons and shortcut', async ({ open, editor }) => {
+		await open()
+		await editor.getCommentReference('comment-1').click()
+		await expect(editor.commentBubble).toContainText('Comment 1 of 2')
+		await expect(editor.commentBubble).toContainText('First comment')
+
+		await editor.commentBubble.getByRole('button', { name: 'Next comment' }).click()
+		await expect(editor.commentBubble).toContainText('Comment 2 of 2')
+		await expect(editor.commentBubble).toContainText('Second comment')
+
+		await editor.commentBubble.press('ControlOrMeta+Alt+ArrowLeft')
+		await expect(editor.commentBubble).toContainText('Comment 1 of 2')
+	})
 })
diff --git a/src/components/Comment/CommentBubbleView.vue b/src/components/Comment/CommentBubbleView.vue
index 341780d4702..1967c4440e0 100644
--- a/src/components/Comment/CommentBubbleView.vue
+++ b/src/components/Comment/CommentBubbleView.vue
@@ -7,27 +7,30 @@
 	<div
 		:id="`comment-bubble-${referenceId}`"
 		class="comment-bubble"
-		@keydown.escape.prevent.stop="closeAndRefocus">
+		@keydown="onKeyDown">
 		<div class="comment-bubble__header">
-			<span class="comment-bubble__title">{{ t('text', 'Comments') }}</span>
-			<div v-if="commentCount > 1" class="comment-bubble__nav">
+			<div class="comment-bubble__nav">
 				<NcButton
+					v-if="commentCount > 1"
 					variant="tertiary"
 					size="small"
-					:title="t('text', 'Previous comment')"
+					:aria-label="t('text', 'Previous comment')"
+					:title="previousTitle"
 					@click="navigate('prev')">
 					<template #icon>
-						<ChevronUpIcon :size="16" />
+						<ChevronLeftIcon :size="16" />
 					</template>
 				</NcButton>
-				<span class="comment-bubble__nav-position">{{ commentPosition }} / {{ commentCount }}</span>
+				<span class="comment-bubble__title">{{ title }}</span>
 				<NcButton
+					v-if="commentCount > 1"
 					variant="tertiary"
 					size="small"
-					:title="t('text', 'Next comment')"
+					:aria-label="t('text', 'Next comment')"
+					:title="nextTitle"
 					@click="navigate('next')">
 					<template #icon>
-						<ChevronDownIcon :size="16" />
+						<ChevronRightIcon :size="16" />
 					</template>
 				</NcButton>
 			</div>
@@ -169,24 +172,24 @@ import NcDateTime from '@nextcloud/vue/components/NcDateTime'
 import NcRichContenteditable from '@nextcloud/vue/components/NcRichContenteditable'
 import NcTextField from '@nextcloud/vue/components/NcTextField'
 import CheckIcon from 'vue-material-design-icons/Check.vue'
-import ChevronDownIcon from 'vue-material-design-icons/ChevronDown.vue'
-import ChevronUpIcon from 'vue-material-design-icons/ChevronUp.vue'
+import ChevronLeftIcon from 'vue-material-design-icons/ChevronLeft.vue'
+import ChevronRightIcon from 'vue-material-design-icons/ChevronRight.vue'
 import CloseIcon from 'vue-material-design-icons/Close.vue'
 import DeleteIcon from 'vue-material-design-icons/Delete.vue'
 import PencilIcon from 'vue-material-design-icons/Pencil.vue'
 import { useGuestName } from '../../composables/useGuestName.ts'
 import { createMarkdownSerializer } from '../../extensions/Markdown.ts'
+import { getCommentDraft, removeCommentDraft, setCommentDraft } from '../../plugins/referenceHelpers.ts'
+import { MODIFIERS, TRANSLATIONS } from '../Menu/keys.js'
 
 const props = defineProps<{
 	editor: Editor
 	referenceId: string
 }>()
 
-const DRAFT_KEY_PREFIX = 'text-comment-draft-'
-
 // References used in template
 const itemsContainer = ref<HTMLElement | null>(null)
-const replyText = ref(sessionStorage.getItem(`${DRAFT_KEY_PREFIX}${props.referenceId}`) ?? '')
+const replyText = ref(getCommentDraft(props.referenceId))
 const editInput = ref<InstanceType<typeof NcRichContenteditable>[] | null>(null)
 const replyInput = ref<InstanceType<typeof NcRichContenteditable> | null>(null)
 const userData = ref<Record<string, object>>({})
@@ -201,6 +204,14 @@ const commentCount = computed(() => commentRefIds.value.length)
 const commentPosition = computed(() => commentRefIds.value.indexOf(props.referenceId) + 1)
 const commentNode = computed<Node | null>(() => commentNodesMap.value[props.referenceId] ?? null)
 
+const title = computed(() => (commentCount.value > 1
+	? t('text', 'Comment {position} of {count}', { position: commentPosition.value, count: commentCount.value })
+	: t('text', 'Comment')))
+
+const shortcutPrefix = `${TRANSLATIONS[MODIFIERS.Mod]} + ${TRANSLATIONS[MODIFIERS.Alt]} + `
+const previousTitle = t('text', 'Previous comment ({shortcut})', { shortcut: shortcutPrefix + '←' })
+const nextTitle = t('text', 'Next comment ({shortcut})', { shortcut: shortcutPrefix + '→' })
+
 const editingItemIndex = ref<number | null>(null)
 const editText = ref('')
 
@@ -240,17 +251,12 @@ const { setGuestName } = useGuestName(props.editor)
 
 // Persist draft as user types
 watch(replyText, (val) => {
-	const key = `${DRAFT_KEY_PREFIX}${props.referenceId}`
-	if (val.trim()) {
-		sessionStorage.setItem(key, val)
-	} else {
-		sessionStorage.removeItem(key)
-	}
+	setCommentDraft(props.referenceId, val)
 })
 
 // Restore draft when bubble opens or switches to a different comment
 watch(() => props.referenceId, (id) => {
-	replyText.value = sessionStorage.getItem(`${DRAFT_KEY_PREFIX}${id}`) ?? ''
+	replyText.value = getCommentDraft(id)
 })
 
 // Focus input field when switching between comment references.
@@ -315,7 +321,7 @@ function submitReply() {
 		return
 	}
 	props.editor.commands.addOrUpdateCommentReply(commentNode.value, replyText.value.trim())
-	sessionStorage.removeItem(`${DRAFT_KEY_PREFIX}${props.referenceId}`)
+	removeCommentDraft(props.referenceId)
 	replyText.value = ''
 	nextTick(() => {
 		if (itemsContainer.value) {
@@ -374,7 +380,7 @@ function deleteItem(index: number) {
 		return
 	}
 	if (items.value.length === 1) {
-		sessionStorage.removeItem(`${DRAFT_KEY_PREFIX}${props.referenceId}`)
+		removeCommentDraft(props.referenceId)
 	}
 	props.editor.commands.deleteCommentReply(commentNode.value, index)
 }
@@ -398,6 +404,25 @@ async function submitGuestName() {
 function closeAndRefocus() {
 	props.editor.commands.hideCommentBubble({ refocus: true })
 }
+
+function onKeyDown(event: KeyboardEvent) {
+	if (event.key === 'Escape') {
+		event.preventDefault()
+		event.stopPropagation()
+		closeAndRefocus()
+		return
+	}
+	if (!(event.ctrlKey || event.metaKey) || !event.altKey) {
+		return
+	}
+	if (event.key === 'ArrowLeft') {
+		event.preventDefault()
+		navigate('prev')
+	} else if (event.key === 'ArrowRight') {
+		event.preventDefault()
+		navigate('next')
+	}
+}
 </script>
 
 <style scoped lang="scss">
@@ -426,19 +451,13 @@ function closeAndRefocus() {
 		font-weight: bold;
 		font-size: 0.9em;
 		color: var(--color-text-maxcontrast);
+		white-space: nowrap;
 	}
 
 	&__nav {
 		display: flex;
 		align-items: center;
 		gap: var(--default-grid-baseline);
-		margin-inline-start: auto;
-	}
-
-	&__nav-position {
-		font-size: 0.8em;
-		color: var(--color-text-maxcontrast);
-		white-space: nowrap;
 	}
 
 	&__items {
diff --git a/src/css/prosemirror.scss b/src/css/prosemirror.scss
index 061454e361f..1fdad505fb2 100644
--- a/src/css/prosemirror.scss
+++ b/src/css/prosemirror.scss
@@ -479,7 +479,7 @@ div.ProseMirror {
 		}
 
 		&.is-active {
-			background-color: var(--color-primary-element-light-text);
+			background-color: var(--color-primary-element-light);
 			border-radius: var(--border-radius);
 		}
 	}
diff --git a/src/extensions/CommentBubble.ts b/src/extensions/CommentBubble.ts
index 6a031157f51..bbf9eb945c7 100644
--- a/src/extensions/CommentBubble.ts
+++ b/src/extensions/CommentBubble.ts
@@ -5,8 +5,10 @@
 
 import type { CommandProps } from '@tiptap/core'
 
+import { getCurrentUser } from '@nextcloud/auth'
 import { Extension } from '@tiptap/core'
 import { commentBubble, commentBubbleKey, hideCommentBubble, navigateCommentBubble, openCommentBubble } from '../plugins/commentBubble.ts'
+import { findComment, getCommentDraft, isEmptyComment } from '../plugins/referenceHelpers.ts'
 
 declare module '@tiptap/core' {
 	interface Commands<ReturnType> {
@@ -28,16 +30,27 @@ const CommentBubble = Extension.create({
 					return openCommentBubble(referenceId)(state, dispatch)
 				}
 			},
-			hideCommentBubble: (options?: { refocus?: boolean }) => ({ state, dispatch, chain }) => {
+			hideCommentBubble: (options?: { refocus?: boolean }) => ({ state, dispatch, chain, commands }) => {
 				const pluginState = commentBubbleKey.getState(state)
 				const active = pluginState?.active
 				const result = hideCommentBubble(state, dispatch)
-				if (!result) {
+				if (!result || !active) {
 					return result
 				}
-				if (options?.refocus && active) {
-					const node = state.doc.nodeAt(active.nodeStart)
-					const cursorPos = active.nodeStart + (node?.nodeSize ?? 1)
+
+				const refNode = state.doc.nodeAt(active.nodeStart)
+				let cursorPos = active.nodeStart + (refNode?.nodeSize ?? 1)
+
+				// Discard a comment that was created but never submitted
+				const comment = findComment(state.doc, active.referenceId)
+				const currentUserId = getCurrentUser()?.uid ?? ''
+				const hasDraft = !!getCommentDraft(active.referenceId)
+				if (comment && isEmptyComment(comment) && comment.firstChild!.attrs.author === currentUserId && !hasDraft) {
+					commands.deleteCommentReply(comment, 0)
+					cursorPos = active.nodeStart
+				}
+
+				if (options?.refocus) {
 					chain().setTextSelection(cursorPos).focus().run()
 				}
 				return true
@@ -50,6 +63,13 @@ const CommentBubble = Extension.create({
 		}
 	},
 
+	addKeyboardShortcuts() {
+		return {
+			'Mod-Alt-ArrowLeft': () => this.editor.commands.navigateCommentBubble('prev'),
+			'Mod-Alt-ArrowRight': () => this.editor.commands.navigateCommentBubble('next'),
+		}
+	},
+
 	addProseMirrorPlugins() {
 		return [commentBubble({ editor: this.editor })]
 	},
diff --git a/src/markdownit/comments.ts b/src/markdownit/comments.ts
index d76a3b27205..f8a8ee880dd 100644
--- a/src/markdownit/comments.ts
+++ b/src/markdownit/comments.ts
@@ -305,14 +305,11 @@ function extractMetadata(inline: Token): Metadata {
 		authorLabel = mention.label || ''
 		children.shift()
 	} else if (first?.type === 'text') {
-		// Guest mention
-		const match = first.content.match(/^@([^\s*]+)/)
+		// Guest mention: the text token runs up to the timestamp or the end of the line
+		const match = first.content.match(/^@(\S.*?)\s*$/)
 		if (match) {
 			authorLabel = match[1]
-			first.content = first.content.slice(match[0].length)
-			if (!first.content) {
-				children.shift()
-			}
+			children.shift()
 		}
 	}
 
diff --git a/src/nodes/CommentReference.ts b/src/nodes/CommentReference.ts
index a2c292dce68..c920e2de48e 100644
--- a/src/nodes/CommentReference.ts
+++ b/src/nodes/CommentReference.ts
@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode, Schema } from '@tiptap/pm/model'
+import type { Transaction } from '@tiptap/pm/state'
 
 import { getCurrentUser } from '@nextcloud/auth'
 import { InputRule, mergeAttributes, Node } from '@tiptap/core'
@@ -11,7 +12,7 @@ import { DOMParser } from '@tiptap/pm/model'
 import { TextSelection } from '@tiptap/pm/state'
 import markdownit from '../markdownit/index.js'
 import { commentBubbleKey } from '../plugins/commentBubble.ts'
-import { generateReferenceId, isInsideCommentOrFootnote } from '../plugins/referenceHelpers.ts'
+import { generateReferenceId, isEmptyComment, isInsideCommentOrFootnote, removeCommentDraft } from '../plugins/referenceHelpers.ts'
 
 declare module '@tiptap/core' {
 	interface Commands<ReturnType> {
@@ -23,6 +24,36 @@ declare module '@tiptap/core' {
 	}
 }
 
+function createEmptyComment(schema: Schema, referenceId: string): ProseMirrorNode {
+	const currentUser = getCurrentUser()
+	const commentItem = schema.nodes.commentItem.create({
+		author: currentUser?.uid ?? '',
+		authorLabel: currentUser?.displayName ?? localStorage.getItem('nick') ?? '',
+		timestamp: new Date().toISOString(),
+	}, schema.nodes.paragraph.create())
+	return schema.nodes.comment.create({ referenceId }, commentItem)
+}
+
+// Append a comment to the comments container, creating the container before footnotes if missing
+function insertIntoCommentsContainer(tr: Transaction, comment: ProseMirrorNode): void {
+	let commentsInsidePos = -1
+	let footnotesStartPos = -1
+	tr.doc.forEach((child, offset) => {
+		if (child.type.name === 'comments') {
+			commentsInsidePos = offset + child.nodeSize - 1
+		}
+		if (child.type.name === 'footnotes') {
+			footnotesStartPos = offset
+		}
+	})
+	if (commentsInsidePos !== -1) {
+		tr.insert(commentsInsidePos, comment)
+		return
+	}
+	const comments = tr.doc.type.schema.nodes.comments.create(null, comment)
+	tr.insert(footnotesStartPos !== -1 ? footnotesStartPos : tr.doc.content.size, comments)
+}
+
 const CommentReference = Node.create({
 	name: 'commentReference',
 	group: 'inline',
@@ -97,56 +128,21 @@ const CommentReference = Node.create({
 				}
 
 				// Clear any stale draft from a previous comment that used this ID
-				sessionStorage.removeItem('text-comment-draft-' + referenceId)
+				removeCommentDraft(referenceId)
 
 				// In can-check mode, the above guards are sufficient
 				if (!dispatch) {
 					return true
 				}
 
-				const currentUser = getCurrentUser()
-				const author = currentUser?.uid ?? ''
-				const authorLabel = currentUser?.displayName ?? localStorage.getItem('nick') ?? ''
-				const timestamp = new Date().toISOString()
-
-				const commentType = state.schema.nodes.comment
-				const commentItemType = state.schema.nodes.commentItem
-				const paragraphType = state.schema.nodes.paragraph
-
-				const newCommentItem = commentItemType.create(
-					{ author, authorLabel, timestamp },
-					paragraphType.create(),
-				)
-				const newComment = commentType.create({ referenceId }, newCommentItem)
+				const newComment = createEmptyComment(state.schema, referenceId)
 
 				let c = chain()
-					.insertContent({ type: 'commentReference', attrs: { referenceId } })
-
-				// Find positions of existing containers in the original doc
-				let commentsInsidePos = -1
-				let footnotesStartPos = -1
-				state.doc.forEach((child, offset) => {
-					if (child.type.name === 'comments') {
-						commentsInsidePos = offset + child.nodeSize - 1
-					}
-					if (child.type.name === 'footnotes') {
-						footnotesStartPos = offset
-					}
-				})
-
-				if (commentsInsidePos !== -1) {
-					c = c.insertContentAt(commentsInsidePos, newComment.toJSON())
-				} else if (footnotesStartPos !== -1) {
-					c = c.insertContentAt(footnotesStartPos, {
-						type: 'comments',
-						content: [newComment.toJSON()],
+					.insertContentAt(state.selection.to, { type: 'commentReference', attrs: { referenceId } })
+					.command(({ tr }) => {
+						insertIntoCommentsContainer(tr, newComment)
+						return true
 					})
-				} else {
-					c = c.insertContentAt(state.doc.content.size, {
-						type: 'comments',
-						content: [newComment.toJSON()],
-					})
-				}
 
 				// Move selection/cursor to reference to avoid it being inside the hidden comments container
 				c = c.command(({ state, dispatch }) => {
@@ -231,8 +227,7 @@ const CommentReference = Node.create({
 				}
 
 				const tr = state.tr
-				const shouldAppendNewReply = itemIndex === undefined
-					&& !(comment.childCount === 1 && item.textContent === '')
+				const shouldAppendNewReply = itemIndex === undefined && !isEmptyComment(comment)
 				if (shouldAppendNewReply) {
 					// Append a new reply item
 					const commentItemType = state.schema.nodes.commentItem
diff --git a/src/nodes/Comments.ts b/src/nodes/Comments.ts
index 0804d548e49..4c934020e24 100644
--- a/src/nodes/Comments.ts
+++ b/src/nodes/Comments.ts
@@ -96,7 +96,6 @@ const Comments = Node.create({
 					for (const del of deletions) {
 						tr.delete(del.pos, del.pos + del.size)
 					}
-					tr.setMeta('addToHistory', false)
 					return tr
 				},
 			}),
diff --git a/src/nodes/FootnoteReference.ts b/src/nodes/FootnoteReference.ts
index d135eebd221..915c1c769b3 100644
--- a/src/nodes/FootnoteReference.ts
+++ b/src/nodes/FootnoteReference.ts
@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
+import type { Transaction } from '@tiptap/pm/state'
+
 import { InputRule, mergeAttributes, Node } from '@tiptap/core'
 import { Plugin, TextSelection } from '@tiptap/pm/state'
 import { footnoteExists, generateReferenceId, isInsideCommentOrFootnote } from '../plugins/referenceHelpers.ts'
@@ -20,6 +22,22 @@ declare module '@tiptap/core' {
 	}
 }
 
+// Append an empty footnote to the trailing footnotes container, creating the container
+// if missing, and place the cursor inside it
+function insertIntoFootnotesContainer(tr: Transaction, referenceId: string): void {
+	const { footnotes, footnote, paragraph } = tr.doc.type.schema.nodes
+	const newFootnote = footnote.create({ referenceId }, paragraph.create())
+	let footnotePos: number
+	if (tr.doc.lastChild?.type === footnotes) {
+		footnotePos = tr.doc.content.size - 1
+		tr.insert(footnotePos, newFootnote)
+	} else {
+		footnotePos = tr.doc.content.size + 1
+		tr.insert(tr.doc.content.size, footnotes.create(null, newFootnote))
+	}
+	tr.setSelection(TextSelection.create(tr.doc, footnotePos + 2))
+}
+
 const FootnoteReference = Node.create({
 	name: 'footnoteReference',
 	group: 'inline',
@@ -83,30 +101,14 @@ const FootnoteReference = Node.create({
 
 				const existingFootnote = footnoteExists(state.doc, referenceId)
 
-				const footnotesType = state.schema.nodes.footnotes
-				const footnoteType = state.schema.nodes.footnote
-				const paragraphType = state.schema.nodes.paragraph
-
 				let c = chain()
-					.insertContent({ type: 'footnoteReference', attrs: { referenceId } })
+					.insertContentAt(state.selection.to, { type: 'footnoteReference', attrs: { referenceId } }, { updateSelection: false })
 
 				if (!existingFootnote) {
-					// Create footnote
-					const newFootnote = footnoteType.create({ referenceId }, paragraphType.create())
-					const lastChild = state.doc.lastChild
-					const hasFootnotesBlock = lastChild?.type === footnotesType
-
-					if (hasFootnotesBlock) {
-						// Append footnote inside the existing footnotes container
-						const insertPos = state.doc.content.size - 1
-						c = c.insertContentAt(insertPos, newFootnote.toJSON())
-					} else {
-						// Create footnotes container + footnote
-						c = c.insertContentAt(state.doc.content.size, {
-							type: 'footnotes',
-							content: [newFootnote.toJSON()],
-						})
-					}
+					c = c.command(({ tr }) => {
+						insertIntoFootnotesContainer(tr, referenceId)
+						return true
+					})
 				} else {
 					// Jump cursor into existing footnote
 					c = c.command(({ tr }) => {
diff --git a/src/nodes/Footnotes.ts b/src/nodes/Footnotes.ts
index e8dfbb06687..32d34309302 100644
--- a/src/nodes/Footnotes.ts
+++ b/src/nodes/Footnotes.ts
@@ -72,7 +72,6 @@ const Footnotes = Node.create({
 					if (!hasChange) {
 						return null
 					}
-					tr.setMeta('addToHistory', false)
 					return tr
 				},
 			}),
@@ -138,7 +137,6 @@ const Footnotes = Node.create({
 					for (const del of deletions) {
 						tr.delete(del.pos, del.pos + del.size)
 					}
-					tr.setMeta('addToHistory', false)
 					return tr
 				},
 			}),
diff --git a/src/plugins/referenceHelpers.ts b/src/plugins/referenceHelpers.ts
index 93d7641e8e2..7c1c3cc86c6 100644
--- a/src/plugins/referenceHelpers.ts
+++ b/src/plugins/referenceHelpers.ts
@@ -6,6 +6,40 @@
 import type { Node } from '@tiptap/pm/model'
 import type { EditorState } from '@tiptap/pm/state'
 
+const commentDraftPrefix = 'text-comment-draft-'
+
+/**
+ * Get the unsubmitted reply draft for a comment
+ *
+ * @param referenceId the comment reference id
+ */
+export function getCommentDraft(referenceId: string): string {
+	return sessionStorage.getItem(commentDraftPrefix + referenceId) ?? ''
+}
+
+/**
+ * Store the unsubmitted reply draft for a comment, removing it if blank
+ *
+ * @param referenceId the comment reference id
+ * @param value - the draft text
+ */
+export function setCommentDraft(referenceId: string, value: string): void {
+	if (value.trim()) {
+		sessionStorage.setItem(commentDraftPrefix + referenceId, value)
+	} else {
+		removeCommentDraft(referenceId)
+	}
+}
+
+/**
+ * Remove the reply draft for a comment
+ *
+ * @param referenceId - the comment reference id
+ */
+export function removeCommentDraft(referenceId: string): void {
+	sessionStorage.removeItem(commentDraftPrefix + referenceId)
+}
+
 /**
  * Check if selection is inside a node type
  *
@@ -93,3 +127,32 @@ export function footnoteExists(doc: Node, id: string): boolean {
 	})
 	return found
 }
+
+/**
+ * Find the comment node with the given reference id
+ *
+ * @param doc - the ProseMirror node
+ * @param referenceId - the searched reference id
+ */
+export function findComment(doc: Node, referenceId: string): Node | null {
+	let found: Node | null = null
+	doc.descendants((node) => {
+		if (found) {
+			return false
+		}
+		if (node.type.name === 'comment' && node.attrs.referenceId === referenceId) {
+			found = node
+			return false
+		}
+	})
+	return found
+}
+
+/**
+ * Check if a comment thread contains only empty placeholder
+ *
+ * @param comment - the comment node
+ */
+export function isEmptyComment(comment: Node): boolean {
+	return comment.childCount === 1 && comment.firstChild!.textContent === ''
+}
diff --git a/src/tests/markdownit/comments.spec.ts b/src/tests/markdownit/comments.spec.ts
index 03cec48d5aa..d57fb774c91 100644
--- a/src/tests/markdownit/comments.spec.ts
+++ b/src/tests/markdownit/comments.spec.ts
@@ -56,6 +56,21 @@ describe('comments (markdown-it)', () => {
 			+ '</section>\n')
 	})
 
+	it('guest comment with multi-word name', () => {
+		const md = 'The quick[^comment-1] brown fox.\n\n'
+			+ '[^comment-1]:\n'
+			+ '    - @Alma Lauer *(2026-09-14T12:51:39.978Z)*\n'
+			+ '      Guest reply\n'
+		expect(markdownit.render(md)).to.eq('<p>The quick<sup data-type="comment-reference" data-reference-id="comment-1"></sup> brown fox.</p>\n'
+			+ '<section data-type="comments">\n'
+			+ '<div data-type="comment" data-reference-id="comment-1">\n'
+			+ '<div data-type="comment-item" data-author="" data-author-label="Alma Lauer" data-timestamp="2026-09-14T12:51:39.978Z">\n'
+			+ '<p>Guest reply</p>\n'
+			+ '</div>\n'
+			+ '</div>\n'
+			+ '</section>\n')
+	})
+
 	it('comment without metadata', () => {
 		const md = 'Foo[^comment-1] bar\n\n'
 			+ '[^comment-1]:\n'
diff --git a/src/tests/nodes/Comments.spec.ts b/src/tests/nodes/Comments.spec.ts
index 4686820293c..dd46e46ee70 100644
--- a/src/tests/nodes/Comments.spec.ts
+++ b/src/tests/nodes/Comments.spec.ts
@@ -7,17 +7,28 @@ import type { Editor } from '@tiptap/core'
 
 import { Document } from '@tiptap/extension-document'
 import { ListItem } from '@tiptap/extension-list'
-import { describe, expect } from 'vitest'
+import { describe, expect, vi } from 'vitest'
+import CommentBubble from '../../extensions/CommentBubble.ts'
 import KeepSyntax from '../../extensions/KeepSyntax.js'
 import Mention from '../../extensions/Mention.js'
 import BulletList from '../../nodes/BulletList.ts'
 import Comments from '../../nodes/Comments.ts'
 import Footnotes from '../../nodes/Footnotes.ts'
+import { commentBubbleKey } from '../../plugins/commentBubble.ts'
+import { removeCommentDraft, setCommentDraft } from '../../plugins/referenceHelpers.ts'
 import testEditor from '../testHelpers/testEditor.ts'
 
+vi.mock('../../plugins/CommentBubblePluginView.ts', () => ({
+	default: class {
+		update() {}
+		destroy() {}
+	},
+}))
+
 const test = testEditor.override('extensions', [
 	Document.extend({ content: 'block+ comments? footnotes?' }),
 	Comments,
+	CommentBubble,
 	Footnotes,
 	BulletList,
 	KeepSyntax,
@@ -254,6 +265,133 @@ describe('insertComment command', () => {
 		editor.state.doc.forEach((child) => childNames.push(child.type.name))
 		expect(childNames.indexOf('comments')).toBeLessThan(childNames.indexOf('footnotes'))
 	})
+
+	test('appends into existing comments container when footnotes follow', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world<sup data-type="comment-reference" data-reference-id="comment-1"></sup>'
+			+ '<sup data-type="footnote-reference" data-reference-id="1"></sup></p>'
+			+ '<section data-type="comments">'
+			+ '<div data-type="comment" data-reference-id="comment-1">'
+			+ '<div data-type="comment-item" data-author="jane" data-author-label="jane" data-timestamp="2026-07-15T11:11Z"><p>x</p></div>'
+			+ '</div>'
+			+ '</section>'
+			+ '<section data-type="footnotes">'
+			+ '<div data-type="footnote" data-reference-id="1"><p>fn</p></div>'
+			+ '</section>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		editor.commands.insertComment()
+
+		const paragraph = editor.state.doc.firstChild!
+		expect(paragraph.child(1).type.name).toBe('commentReference')
+		expect(paragraph.child(1).attrs.referenceId).toBe('comment-2')
+
+		expect(editor.state.doc.childCount).toBe(3)
+		const comments = editor.state.doc.child(1)
+		expect(comments.type.name).toBe('comments')
+		expect(comments.childCount).toBe(2)
+		expect(comments.lastChild!.attrs.referenceId).toBe('comment-2')
+		expect(editor.state.doc.lastChild!.type.name).toBe('footnotes')
+		expect(editor.state.doc.lastChild!.childCount).toBe(1)
+	})
+
+	test('inserts the reference after a selected range and keeps the text', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world</p>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		const result = editor.commands.insertComment()
+		expect(result).toBe(true)
+
+		const paragraph = editor.state.doc.firstChild!
+		expect(paragraph.textContent).toBe('Hello world')
+		expect(paragraph.child(0).text).toBe('Hello')
+		expect(paragraph.child(1).type.name).toBe('commentReference')
+		expect(paragraph.child(2).text).toBe(' world')
+
+		expect(editor.state.doc.childCount).toBe(2)
+		expect(editor.state.doc.lastChild!.type.name).toBe('comments')
+		expect(editor.state.doc.lastChild!.firstChild!.attrs.referenceId).toBe('comment-1')
+	})
+
+	test('appends into existing comments container with a selected range', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world<sup data-type="comment-reference" data-reference-id="comment-1"></sup></p>'
+			+ '<section data-type="comments">'
+			+ '<div data-type="comment" data-reference-id="comment-1">'
+			+ '<div data-type="comment-item" data-author="jane" data-author-label="jane" data-timestamp="2026-07-15T11:11Z"><p>x</p></div>'
+			+ '</div>'
+			+ '</section>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		editor.commands.insertComment()
+
+		const paragraph = editor.state.doc.firstChild!
+		expect(paragraph.textContent).toBe('Hello world')
+		expect(paragraph.child(1).type.name).toBe('commentReference')
+		expect(paragraph.child(1).attrs.referenceId).toBe('comment-2')
+
+		expect(editor.state.doc.childCount).toBe(2)
+		const comments = editor.state.doc.lastChild!
+		expect(comments.type.name).toBe('comments')
+		expect(comments.childCount).toBe(2)
+		expect(comments.lastChild!.attrs.referenceId).toBe('comment-2')
+	})
+})
+
+describe('hideCommentBubble command', () => {
+	function hasNode(editor: Editor, typeName: string): boolean {
+		let found = false
+		editor.state.doc.descendants((node) => {
+			if (node.type.name === typeName) {
+				found = true
+			}
+		})
+		return found
+	}
+
+	test('removes an empty comment when the bubble is closed', ({ editor }) => {
+		editor.commands.setContent('<p>Foo</p>')
+		editor.commands.focus('end')
+		editor.commands.insertComment()
+		expect(commentBubbleKey.getState(editor.state).active?.referenceId).toBe('comment-1')
+
+		editor.commands.hideCommentBubble({ refocus: true })
+
+		expect(commentBubbleKey.getState(editor.state).active).toBeNull()
+		expect(hasNode(editor, 'commentReference')).toBe(false)
+		expect(hasNode(editor, 'comments')).toBe(false)
+		expect(editor.state.doc.textContent).toBe('Foo')
+		expect(editor.state.selection.from).toBe(4)
+	})
+
+	test('keeps an empty comment with an unsent draft', ({ editor }) => {
+		editor.commands.setContent('<p>Foo</p>')
+		editor.commands.focus('end')
+		editor.commands.insertComment()
+		setCommentDraft('comment-1', 'work in progress')
+
+		editor.commands.hideCommentBubble()
+		removeCommentDraft('comment-1')
+
+		expect(commentBubbleKey.getState(editor.state).active).toBeNull()
+		expect(hasNode(editor, 'commentReference')).toBe(true)
+		expect(hasNode(editor, 'comment')).toBe(true)
+	})
+
+	test('keeps a comment with content when the bubble is closed', ({ editor }) => {
+		editor.commands.setContent('<p>Foo<sup data-type="comment-reference" data-reference-id="comment-1"></sup></p>'
+			+ '<section data-type="comments">'
+			+ '<div data-type="comment" data-reference-id="comment-1">'
+			+ '<div data-type="comment-item" data-author="jane" data-author-label="jane" data-timestamp="2026-07-15T11:11Z"><p>x</p></div>'
+			+ '</div>'
+			+ '</section>')
+		editor.commands.openCommentBubble('comment-1')
+		expect(commentBubbleKey.getState(editor.state).active?.referenceId).toBe('comment-1')
+
+		editor.commands.hideCommentBubble()
+
+		expect(commentBubbleKey.getState(editor.state).active).toBeNull()
+		expect(hasNode(editor, 'commentReference')).toBe(true)
+		expect(hasNode(editor, 'comment')).toBe(true)
+	})
 })
 
 describe('Comments Markdown roundtrip', () => {
@@ -321,17 +459,11 @@ describe('Comments Markdown roundtrip', () => {
 		expect(markdownThroughEditor(testOut)).toBe(testOut)
 	})
 	test('idempotent through round-trip with broken metadata #2', ({ markdownThroughEditor }) => {
-		const testIn = 'Foo[^comment-1]\n\n'
-			+ '[^comment-1]:\n'
-			+ '    - @jane xyz\n'
-			+ '      Hello there'
-		const testOut = 'Foo[^comment-1]\n\n'
+		const test = 'Foo[^comment-1]\n\n'
 			+ '[^comment-1]:\n'
-			+ '    - @jane\n'
-			+ '      xyz\n'
+			+ '    - @jane doe\n'
 			+ '      Hello there'
-		expect(markdownThroughEditor(testIn)).toBe(testOut)
-		expect(markdownThroughEditor(testOut)).toBe(testOut)
+		expect(markdownThroughEditor(test)).toBe(test)
 	})
 	test('idempotent through round-trip with broken metadata #3', ({ markdownThroughEditor }) => {
 		const testIn = 'Foo[^comment-1]\n\n'
@@ -360,4 +492,11 @@ describe('Comments Markdown roundtrip', () => {
 		expect(markdownThroughEditor(testIn2)).toBe(testOut)
 		expect(markdownThroughEditor(testOut)).toBe(testOut)
 	})
+	test('guest comment with multi-word name', ({ markdownThroughEditor }) => {
+		const test = 'Foo[^comment-1]\n\n'
+			+ '[^comment-1]:\n'
+			+ '    - @Alma Lauer *(2026-09-14T12:51:39.978Z)*\n'
+			+ '      Guest reply'
+		expect(markdownThroughEditor(test)).toBe(test)
+	})
 })
diff --git a/src/tests/nodes/Footnotes.spec.ts b/src/tests/nodes/Footnotes.spec.ts
index 90836ec1d28..267071b54c8 100644
--- a/src/tests/nodes/Footnotes.spec.ts
+++ b/src/tests/nodes/Footnotes.spec.ts
@@ -120,6 +120,56 @@ describe('insertFootnote command', () => {
 		const footnote = editor.state.doc.lastChild!.firstChild!
 		expect(footnote.attrs.referenceId).toBe('custom')
 	})
+
+	test('inserts the reference after a selected range and keeps the text', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world</p>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		const result = editor.commands.insertFootnote()
+		expect(result).toBe(true)
+
+		const paragraph = editor.state.doc.firstChild!
+		expect(paragraph.textContent).toBe('Hello world')
+		expect(paragraph.child(0).text).toBe('Hello')
+		expect(paragraph.child(1).type.name).toBe('footnoteReference')
+		expect(paragraph.child(2).text).toBe(' world')
+
+		expect(editor.state.doc.childCount).toBe(2)
+		expect(editor.state.doc.lastChild!.type.name).toBe('footnotes')
+	})
+
+	test('places the cursor inside the new footnote', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world</p>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		editor.commands.insertFootnote()
+
+		const $from = editor.state.selection.$from
+		expect(editor.state.selection.empty).toBe(true)
+		expect($from.node(1).type.name).toBe('footnotes')
+		expect($from.node(2).type.name).toBe('footnote')
+		expect($from.node(2).attrs.referenceId).toBe('1')
+	})
+
+	test('appends into existing footnotes container with a selected range', ({ editor }) => {
+		editor.commands.setContent('<p>Hello world<sup data-type="footnote-reference" data-reference-id="1"></sup></p>'
+			+ '<section data-type="footnotes">'
+			+ '<div data-type="footnote" data-reference-id="1"><p>x</p></div>'
+			+ '</section>')
+		editor.commands.setTextSelection({ from: 1, to: 6 })
+
+		editor.commands.insertFootnote()
+
+		const paragraph = editor.state.doc.firstChild!
+		expect(paragraph.textContent).toBe('Hello world')
+		expect(paragraph.child(1).attrs.referenceId).toBe('2')
+
+		expect(editor.state.doc.childCount).toBe(2)
+		const footnotes = editor.state.doc.lastChild!
+		expect(footnotes.type.name).toBe('footnotes')
+		expect(footnotes.childCount).toBe(2)
+		expect(footnotes.lastChild!.attrs.referenceId).toBe('2')
+	})
 })
 
 describe('Footnotes cleanup', () => {
@@ -157,7 +207,7 @@ describe('Footnotes cleanup', () => {
 
 	test('removes footnotes when last reference is deleted', ({ editor }) => {
 		editor.commands.setContent('<p>Foo<sup data-type="footnote-reference" data-reference-id="1"></sup></p>'
-			+ '<section> data-type="footnotes">'
+			+ '<section data-type="footnotes">'
 			+ '<div data-type="footnote" data-reference-id="1"><p>x</p></div>'
 			+ '</section>')
 		deleteFirstReference(editor)