diff --git a/src/wp-admin/css/dashboard.css b/src/wp-admin/css/dashboard.css
index 7b0d0fe01c493..fecfa17f5506e 100644
--- a/src/wp-admin/css/dashboard.css
+++ b/src/wp-admin/css/dashboard.css
@@ -937,12 +937,14 @@ body #dashboard-widgets .postbox form .submit {
 }
 
 #future-posts ul,
-#published-posts ul {
+#published-posts ul,
+#latest-notes ul {
 	margin: 8px -12px 0 -12px;
 }
 
 #future-posts li,
-#published-posts li {
+#published-posts li,
+#latest-notes li {
 	display: grid;
 	grid-template-columns: clamp(160px, calc(2vw + 140px), 200px) auto;
 	column-gap: 10px;
@@ -950,8 +952,14 @@ body #dashboard-widgets .postbox form .submit {
 	padding: 4px 12px;
 }
 
+/* Recent Notes rows add a third column for the number of open notes. */
+#latest-notes li {
+	grid-template-columns: clamp(160px, calc(2vw + 140px), 200px) auto max-content;
+}
+
 #future-posts li:nth-child(odd),
-#published-posts li:nth-child(odd) {
+#published-posts li:nth-child(odd),
+#latest-notes li:nth-child(odd) {
 	background-color: #f6f7f7;
 }
 
diff --git a/src/wp-admin/includes/dashboard.php b/src/wp-admin/includes/dashboard.php
index 488e01aa92481..a0b302e113152 100644
--- a/src/wp-admin/includes/dashboard.php
+++ b/src/wp-admin/includes/dashboard.php
@@ -935,6 +935,47 @@ function _wp_dashboard_recent_comments_row( &$comment, $show_date = true ) {
 	$GLOBALS['comment'] = null;
 }
 
+/**
+ * Outputs a row for the Recent Notes widget. Notes are implemented as a type of comment.
+ *
+ * Each row represents a post with open notes, not an individual note.
+ *
+ * @access private
+ * @since 7.2.0
+ *
+ * @param WP_Comment $note       The most recent open note of the post.
+ * @param int        $open_notes Optional. Number of open notes the post has. Default 1.
+ */
+function _wp_dashboard_recent_notes_row( $note, $open_notes = 1 ) {
+	$note_post_id = (int) $note->comment_post_ID;
+
+	$time = strtotime( $note->comment_date_gmt . ' +0000' );
+
+	$note_post_title = _draft_or_post_title( $note_post_id );
+
+	// The post may have been deleted since the note was queried.
+	$note_post_link = get_edit_post_link( $note_post_id );
+
+	if ( ! $note_post_link ) {
+		return;
+	}
+
+	printf(
+		'<li><span>%1$s</span> <a href="%2$s" aria-label="%3$s">%4$s</a> <span class="open-notes-count">%5$s</span></li>',
+		/* translators: %s: Human-readable time difference. */
+		sprintf( __( '%s ago' ), human_time_diff( $time ) ),
+		esc_url( $note_post_link ),
+		/* translators: %s: Post title. */
+		esc_attr( sprintf( __( 'Edit &#8220;%s&#8221;' ), $note_post_title ) ),
+		$note_post_title,
+		sprintf(
+			/* translators: %s: Number of open notes. */
+			_n( '%s open note', '%s open notes', $open_notes ),
+			number_format_i18n( $open_notes )
+		)
+	);
+}
+
 /**
  * Outputs the Activity widget.
  *
@@ -967,7 +1008,9 @@ function wp_dashboard_site_activity() {
 
 	$recent_comments = wp_dashboard_recent_comments();
 
-	if ( ! $future_posts && ! $recent_posts && ! $recent_comments ) {
+	$recent_notes = wp_dashboard_recent_notes();
+
+	if ( ! $future_posts && ! $recent_posts && ! $recent_comments && ! $recent_notes ) {
 		echo '<div class="no-activity">';
 		echo '<p>' . __( 'No activity yet!' ) . '</p>';
 		echo '</div>';
@@ -1152,6 +1195,145 @@ function wp_dashboard_recent_comments( $total_items = 5 ) {
 	return true;
 }
 
+/**
+ * Show Notes section.
+ *
+ * Lists the posts the current user can edit that have at least one open note,
+ * ordered by the note or reply most recently added to them.
+ *
+ * @since 7.2.0
+ *
+ * @param int $total_items Optional. Number of posts to display. Default 5.
+ * @return bool False if no posts with open notes were found. True otherwise.
+ */
+function wp_dashboard_recent_notes( $total_items = 5 ) {
+	/*
+	 * Replies are queried alongside the notes that start a thread, so that a
+	 * thread someone replied to counts as added to when it was replied to.
+	 * Resolving a thread approves the note that starts it, while the replies
+	 * stay on hold, so a reply is only recent activity while its thread is.
+	 */
+	$notes_query = array(
+		'type'                      => 'note',
+		'status'                    => 'hold',
+		'orderby'                   => 'comment_date_gmt',
+		'order'                     => 'DESC',
+		'number'                    => $total_items * 5,
+		'offset'                    => 0,
+		// The posts are needed for the capability checks below, the note meta is not.
+		'update_comment_post_cache' => true,
+		'update_comment_meta_cache' => false,
+	);
+
+	// The most recent open note or reply of each post, keyed by post ID.
+	$latest_notes = array();
+
+	/*
+	 * Only notes on posts the current user can edit are listed, and a user who
+	 * can edit none of them would otherwise page through every open note on the
+	 * site. Paging stops once a hundred notes per row have been looked at, so
+	 * that the section costs a bounded number of queries however many notes the
+	 * site has.
+	 */
+	$max_notes_examined = $total_items * 100;
+	$notes_examined     = 0;
+
+	do {
+		$possible = get_comments( $notes_query );
+
+		if ( empty( $possible ) || ! is_array( $possible ) ) {
+			break;
+		}
+
+		$notes_examined += count( $possible );
+
+		/*
+		 * Prime the threads the replies belong to, so that they are not
+		 * queried for one at a time below.
+		 */
+		$thread_ids = array();
+
+		foreach ( $possible as $note ) {
+			if ( $note->comment_parent ) {
+				$thread_ids[] = (int) $note->comment_parent;
+			}
+		}
+
+		if ( $thread_ids ) {
+			_prime_comment_caches( array_unique( $thread_ids ), false );
+		}
+
+		foreach ( $possible as $note ) {
+			$note_post_id = (int) $note->comment_post_ID;
+
+			// Only the first note of a post is kept, as notes are ordered by date.
+			if ( isset( $latest_notes[ $note_post_id ] ) ) {
+				continue;
+			}
+
+			// A reply is resolved along with the thread it belongs to.
+			if ( $note->comment_parent ) {
+				$thread = get_comment( (int) $note->comment_parent );
+
+				if ( ! $thread || '0' !== $thread->comment_approved ) {
+					continue;
+				}
+			}
+
+			// Notes are only visible to users who can edit the post they belong to.
+			if ( ! current_user_can( 'edit_post', $note_post_id ) ) {
+				continue;
+			}
+
+			$latest_notes[ $note_post_id ] = $note;
+
+			if ( count( $latest_notes ) === $total_items ) {
+				break 2;
+			}
+		}
+
+		$notes_query['offset'] += $notes_query['number'];
+		$notes_query['number']  = min( $total_items * 10, $max_notes_examined - $notes_examined );
+	} while ( count( $latest_notes ) < $total_items && $notes_examined < $max_notes_examined );
+
+	if ( ! $latest_notes ) {
+		return false;
+	}
+
+	/*
+	 * Count the open notes of each of the posts about to be displayed. A count
+	 * query per post is cheaper than one query for every open note on them: the
+	 * count is a single value, so the notes themselves are never loaded.
+	 */
+	$open_notes = array();
+
+	foreach ( array_keys( $latest_notes ) as $note_post_id ) {
+		$open_notes[ $note_post_id ] = (int) get_comments(
+			array(
+				'type'    => 'note',
+				'parent'  => 0,
+				'status'  => 'hold',
+				'post_id' => $note_post_id,
+				'count'   => true,
+				'orderby' => 'none',
+			)
+		);
+	}
+
+	echo '<div id="latest-notes" class="activity-block">';
+	echo '<h3>' . __( 'Recent Notes' ) . '</h3>';
+
+	echo '<ul>';
+	foreach ( $latest_notes as $note_post_id => $note ) {
+		_wp_dashboard_recent_notes_row( $note, $open_notes[ $note_post_id ] );
+	}
+	echo '</ul>';
+
+	echo '</div>';
+
+	return true;
+}
+
 /**
  * Display generic dashboard RSS widget feed.
  *
diff --git a/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotesRow_Test.php b/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotesRow_Test.php
new file mode 100644
index 0000000000000..5e53c62bc0627
--- /dev/null
+++ b/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotesRow_Test.php
@@ -0,0 +1,358 @@
+<?php
+
+/**
+ * @group admin
+ * @group dashboard
+ * @group notes
+ *
+ * @covers ::_wp_dashboard_recent_notes_row
+ */
+class Admin_Includes_Dashboard_WpDashboardRecentNotesRow_Test extends WP_UnitTestCase {
+
+	/**
+	 * An administrator, who can edit the post the notes belong to.
+	 *
+	 * @var int
+	 */
+	public static $admin_id;
+
+	/**
+	 * The post the notes belong to.
+	 *
+	 * @var int
+	 */
+	public static $post_id;
+
+	/**
+	 * Creates the user and post shared by the tests.
+	 *
+	 * @param WP_UnitTest_Factory $factory Factory instance.
+	 */
+	public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
+		self::$admin_id = $factory->user->create( array( 'role' => 'administrator' ) );
+
+		self::$post_id = $factory->post->create(
+			array(
+				'post_title'  => 'A post with notes',
+				'post_status' => 'draft',
+				'post_author' => self::$admin_id,
+			)
+		);
+	}
+
+	public function set_up() {
+		parent::set_up();
+
+		require_once ABSPATH . 'wp-admin/includes/dashboard.php';
+
+		// Notes are only shown to users who can edit the post they belong to.
+		wp_set_current_user( self::$admin_id );
+	}
+
+	/**
+	 * Creates an open note on the shared post.
+	 *
+	 * @param string $date Optional. Local date for the note, in MySQL format.
+	 *                     Default is the current local time.
+	 * @return WP_Comment The note.
+	 */
+	private function create_note( $date = '' ) {
+		if ( '' === $date ) {
+			$date = current_time( 'mysql' );
+		}
+
+		$note_id = self::factory()->comment->create(
+			array(
+				'comment_post_ID'  => self::$post_id,
+				'comment_type'     => 'note',
+				'comment_content'  => 'A note.',
+				// A note is created on hold, and is approved once it is resolved.
+				'comment_approved' => '0',
+				'comment_date'     => $date,
+				'comment_date_gmt' => get_gmt_from_date( $date ),
+			)
+		);
+
+		return get_comment( $note_id );
+	}
+
+	/**
+	 * Renders a row and returns its markup.
+	 *
+	 * @param WP_Comment $note       The note to render.
+	 * @param int|null   $open_notes Optional. Open note count. Default null, to
+	 *                               call the function without the argument.
+	 * @return string The rendered row.
+	 */
+	private function render( $note, $open_notes = null ) {
+		ob_start();
+
+		if ( null === $open_notes ) {
+			_wp_dashboard_recent_notes_row( $note );
+		} else {
+			_wp_dashboard_recent_notes_row( $note, $open_notes );
+		}
+
+		return ob_get_clean();
+	}
+
+	/**
+	 * Returns the relative time a rendered row starts with.
+	 *
+	 * @param string $output The rendered row.
+	 * @return string The contents of the date element.
+	 */
+	private function get_rendered_date( $output ) {
+		preg_match( '#<li><span>([^<]*)</span>#', $output, $matches );
+
+		$this->assertNotEmpty( $matches, 'The row did not render a date.' );
+
+		return $matches[1];
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_link_to_the_post_edit_screen() {
+		$output = $this->render( $this->create_note() );
+
+		$this->assertStringContainsString(
+			'href="' . esc_url( get_edit_post_link( self::$post_id ) ) . '"',
+			$output,
+			'The row did not link to the edit screen of the post.'
+		);
+	}
+
+	/**
+	 * A post can be deleted between the moment its notes are queried and the
+	 * moment the row is rendered.
+	 *
+	 * @ticket 65890
+	 */
+	public function test_should_render_nothing_for_a_post_without_an_edit_link() {
+		$note = $this->create_note();
+
+		wp_delete_post( self::$post_id, true );
+
+		$this->assertSame(
+			'',
+			$this->render( $note ),
+			'A note whose post has no edit link rendered a row.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_use_the_post_title_as_the_link_text() {
+		$output = $this->render( $this->create_note() );
+
+		$this->assertStringContainsString(
+			'>A post with notes</a>',
+			$output,
+			'The link text was not the post title.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_label_the_link_with_the_post_title() {
+		$output = $this->render( $this->create_note() );
+
+		$this->assertStringContainsString(
+			'aria-label="Edit &#8220;A post with notes&#8221;"',
+			$output,
+			'The link was not labelled with the post title.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_use_the_placeholder_title_for_an_untitled_post() {
+		$post_id = self::factory()->post->create(
+			array(
+				'post_title'  => '',
+				'post_status' => 'draft',
+				'post_author' => self::$admin_id,
+			)
+		);
+
+		$note_id = self::factory()->comment->create(
+			array(
+				'comment_post_ID'  => $post_id,
+				'comment_type'     => 'note',
+				'comment_approved' => '0',
+			)
+		);
+
+		$output = $this->render( get_comment( $note_id ) );
+
+		$this->assertStringContainsString(
+			'>(no title)</a>',
+			$output,
+			'An untitled post did not fall back to the placeholder title.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_escape_the_post_title() {
+		$post_id = self::factory()->post->create(
+			array(
+				'post_title'  => '<script>alert(1)</script>',
+				'post_status' => 'draft',
+				'post_author' => self::$admin_id,
+			)
+		);
+
+		$note_id = self::factory()->comment->create(
+			array(
+				'comment_post_ID'  => $post_id,
+				'comment_type'     => 'note',
+				'comment_approved' => '0',
+			)
+		);
+
+		$output = $this->render( get_comment( $note_id ) );
+
+		$this->assertStringNotContainsString(
+			'<script>',
+			$output,
+			'The post title was not escaped.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_default_to_a_single_open_note() {
+		$output = $this->render( $this->create_note() );
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">1 open note</span>',
+			$output,
+			'The row did not default to a single open note.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 *
+	 * @dataProvider data_open_note_counts
+	 *
+	 * @param int    $open_notes The number of open notes.
+	 * @param string $expected   The expected count text.
+	 */
+	public function test_should_render_the_open_note_count( $open_notes, $expected ) {
+		$output = $this->render( $this->create_note(), $open_notes );
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">' . $expected . '</span>',
+			$output,
+			'The open note count was not rendered as expected.'
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array[]
+	 */
+	public function data_open_note_counts() {
+		return array(
+			'a single note'    => array( 1, '1 open note' ),
+			'two notes'        => array( 2, '2 open notes' ),
+			'no notes'         => array( 0, '0 open notes' ),
+			'a thousand notes' => array( 1000, '1,000 open notes' ),
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 *
+	 * @dataProvider data_note_ages
+	 *
+	 * @param string $modifier A relative date modifier, as accepted by strtotime().
+	 * @param string $expected The expected relative time.
+	 */
+	public function test_should_render_the_age_of_the_note( $modifier, $expected ) {
+		$date = current_datetime()->modify( $modifier )->format( 'Y-m-d H:i:s' );
+
+		$output = $this->render( $this->create_note( $date ) );
+
+		$this->assertSame(
+			$expected,
+			$this->get_rendered_date( $output ),
+			'The age of the note was not rendered as expected.'
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array[]
+	 */
+	public function data_note_ages() {
+		return array(
+			'minutes ago' => array( '-5 minutes', '5 minutes ago' ),
+			'hours ago'   => array( '-3 hours', '3 hours ago' ),
+			'days ago'    => array( '-2 days', '2 days ago' ),
+			'weeks ago'   => array( '-3 weeks', '3 weeks ago' ),
+			'a year ago'  => array( '-1 year', '1 year ago' ),
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_render_the_age_of_a_new_note_in_seconds() {
+		$output = $this->render( $this->create_note() );
+
+		$this->assertMatchesRegularExpression(
+			'/^\d+ seconds? ago$/',
+			$this->get_rendered_date( $output ),
+			'A note added just now was not rendered as seconds ago.'
+		);
+	}
+
+	/**
+	 * The relative time is computed from the GMT date of the note, so it does
+	 * not change with the timezone of the site.
+	 *
+	 * @ticket 65890
+	 *
+	 * @dataProvider data_timezones_away_from_utc
+	 *
+	 * @param string $timezone The timezone of the site.
+	 */
+	public function test_should_not_change_with_the_timezone_of_the_site( $timezone ) {
+		update_option( 'timezone_string', $timezone );
+
+		$date = current_datetime()->modify( '-3 hours' )->format( 'Y-m-d H:i:s' );
+
+		$note = $this->create_note( $date );
+
+		$this->assertSame(
+			'3 hours ago',
+			$this->get_rendered_date( $this->render( $note ) ),
+			'The age of the note changed with the timezone of the site.'
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array[]
+	 */
+	public function data_timezones_away_from_utc() {
+		return array(
+			// 14 hours ahead of UTC.
+			'ahead of UTC' => array( 'Pacific/Kiritimati' ),
+			// 11 hours behind UTC.
+			'behind UTC'   => array( 'Pacific/Niue' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotes_Test.php b/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotes_Test.php
new file mode 100644
index 0000000000000..ec68527011d8f
--- /dev/null
+++ b/tests/phpunit/tests/admin/includes/dashboard/WpDashboardRecentNotes_Test.php
@@ -0,0 +1,491 @@
+<?php
+
+/**
+ * @group admin
+ * @group dashboard
+ * @group notes
+ *
+ * @covers ::wp_dashboard_recent_notes
+ */
+class Admin_Includes_Dashboard_WpDashboardRecentNotes_Test extends WP_UnitTestCase {
+
+	/**
+	 * An administrator, who can edit every post.
+	 *
+	 * @var int
+	 */
+	public static $admin_id;
+
+	/**
+	 * An author, who can only edit their own posts.
+	 *
+	 * @var int
+	 */
+	public static $author_id;
+
+	/**
+	 * Creates the users shared by the tests.
+	 *
+	 * @param WP_UnitTest_Factory $factory Factory instance.
+	 */
+	public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
+		self::$admin_id  = $factory->user->create( array( 'role' => 'administrator' ) );
+		self::$author_id = $factory->user->create( array( 'role' => 'author' ) );
+	}
+
+	public function set_up() {
+		parent::set_up();
+
+		require_once ABSPATH . 'wp-admin/includes/dashboard.php';
+
+		wp_set_current_user( self::$admin_id );
+	}
+
+	/**
+	 * Creates a post.
+	 *
+	 * @param string $title  The post title.
+	 * @param int    $author Optional. The post author. Default is the administrator.
+	 * @return int The post ID.
+	 */
+	private function create_post( $title, $author = 0 ) {
+		return self::factory()->post->create(
+			array(
+				'post_title'  => $title,
+				'post_status' => 'draft',
+				'post_author' => $author ? $author : self::$admin_id,
+			)
+		);
+	}
+
+	/**
+	 * Creates a note.
+	 *
+	 * @param int    $post_id  The post to add the note to.
+	 * @param string $approved Optional. '0' for an open note, '1' for a resolved
+	 *                         one. Default '0'.
+	 * @param int    $parent_id Optional. The note this one replies to. Default 0.
+	 * @param string $date     Optional. Local date, in MySQL format. Default is
+	 *                         the current local time.
+	 * @return int The note ID.
+	 */
+	private function create_note( $post_id, $approved = '0', $parent_id = 0, $date = '' ) {
+		if ( '' === $date ) {
+			$date = current_time( 'mysql' );
+		}
+
+		return self::factory()->comment->create(
+			array(
+				'comment_post_ID'  => $post_id,
+				'comment_type'     => 'note',
+				'comment_content'  => 'A note.',
+				'comment_approved' => $approved,
+				'comment_parent'   => $parent_id,
+				'comment_date'     => $date,
+				'comment_date_gmt' => get_gmt_from_date( $date ),
+			)
+		);
+	}
+
+	/**
+	 * Renders the section and returns its markup.
+	 *
+	 * @param int $total_items Optional. Number of posts to display. Default 5.
+	 * @return array The return value of the function, and the rendered markup.
+	 */
+	private function render( $total_items = 5 ) {
+		ob_start();
+		$returned = wp_dashboard_recent_notes( $total_items );
+		$output   = ob_get_clean();
+
+		return array( $returned, $output );
+	}
+
+	/**
+	 * Returns the post titles the rendered section links to, in order.
+	 *
+	 * @param string $output The rendered section.
+	 * @return string[] The linked post titles.
+	 */
+	private function get_linked_titles( $output ) {
+		preg_match_all( '#<a [^>]*>([^<]*)</a>#', $output, $matches );
+
+		return $matches[1];
+	}
+
+	/**
+	 * Returns the relative times the rendered section starts each row with, in
+	 * order.
+	 *
+	 * @param string $output The rendered section.
+	 * @return string[] The rendered relative times.
+	 */
+	private function get_rendered_dates( $output ) {
+		preg_match_all( '#<li><span>([^<]*)</span>#', $output, $matches );
+
+		return $matches[1];
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_return_false_when_there_are_no_notes() {
+		$this->create_post( 'A post without notes' );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertFalse( $returned, 'The function did not return false.' );
+		$this->assertSame( '', $output, 'The function rendered a section anyway.' );
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_return_false_when_every_note_is_resolved() {
+		$post_id = $this->create_post( 'A post with resolved notes' );
+		$this->create_note( $post_id, '1' );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertFalse( $returned, 'The function did not return false.' );
+		$this->assertSame( '', $output, 'The function rendered a section anyway.' );
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_render_one_row_per_post() {
+		$post_id = $this->create_post( 'A post with several notes' );
+		$this->create_note( $post_id );
+		$this->create_note( $post_id );
+		$this->create_note( $post_id );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertTrue( $returned, 'The function did not return true.' );
+		$this->assertSame(
+			1,
+			substr_count( $output, '<li>' ),
+			'A post with several notes was not rendered as a single row.'
+		);
+	}
+
+	/**
+	 * The count is of the open notes of the post, not of the notes that were
+	 * queried to build the section.
+	 *
+	 * @ticket 65890
+	 */
+	public function test_should_count_the_open_notes_of_the_post() {
+		$post_id = $this->create_post( 'A post with several notes' );
+		$this->create_note( $post_id );
+		$this->create_note( $post_id );
+		$this->create_note( $post_id );
+
+		list( , $output ) = $this->render();
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">3 open notes</span>',
+			$output,
+			'The open notes of the post were not counted.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_not_count_resolved_notes() {
+		$post_id = $this->create_post( 'A post with a resolved note' );
+		$this->create_note( $post_id );
+		$this->create_note( $post_id, '1' );
+
+		list( , $output ) = $this->render();
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">1 open note</span>',
+			$output,
+			'A resolved note was counted as open.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_not_count_replies() {
+		$post_id = $this->create_post( 'A post with a reply' );
+		$note_id = $this->create_note( $post_id );
+		$this->create_note( $post_id, '0', $note_id );
+
+		list( , $output ) = $this->render();
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">1 open note</span>',
+			$output,
+			'A reply was counted as an open note.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_not_count_regular_comments() {
+		$post_id = $this->create_post( 'A post with a comment' );
+		$this->create_note( $post_id );
+
+		self::factory()->comment->create(
+			array(
+				'comment_post_ID'  => $post_id,
+				'comment_content'  => 'A regular comment.',
+				'comment_approved' => '0',
+			)
+		);
+
+		list( , $output ) = $this->render();
+
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">1 open note</span>',
+			$output,
+			'A regular comment was counted as an open note.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_count_the_notes_of_each_post_separately() {
+		$first_id = $this->create_post( 'A post with one note' );
+		$this->create_note( $first_id, '0', 0, '2026-01-02 10:00:00' );
+
+		$second_id = $this->create_post( 'A post with two notes' );
+		$this->create_note( $second_id, '0', 0, '2026-01-01 10:00:00' );
+		$this->create_note( $second_id, '0', 0, '2026-01-01 11:00:00' );
+
+		list( , $output ) = $this->render();
+
+		$this->assertSame(
+			1,
+			substr_count( $output, '<span class="open-notes-count">1 open note</span>' ),
+			'The post with one note was not counted on its own.'
+		);
+		$this->assertSame(
+			1,
+			substr_count( $output, '<span class="open-notes-count">2 open notes</span>' ),
+			'The post with two notes was not counted on its own.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_order_posts_by_their_most_recent_open_note() {
+		$older_id = $this->create_post( 'An older post' );
+		$this->create_note( $older_id, '0', 0, '2026-01-01 10:00:00' );
+
+		$newer_id = $this->create_post( 'A newer post' );
+		$this->create_note( $newer_id, '0', 0, '2026-01-03 10:00:00' );
+
+		list( , $output ) = $this->render();
+
+		$this->assertSame(
+			array( 'A newer post', 'An older post' ),
+			$this->get_linked_titles( $output ),
+			'The posts were not ordered by their most recent open note.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_limit_the_number_of_posts() {
+		for ( $i = 0; $i < 4; $i++ ) {
+			$post_id = $this->create_post( 'Post ' . $i );
+			$this->create_note( $post_id, '0', 0, '2026-01-0' . ( $i + 1 ) . ' 10:00:00' );
+		}
+
+		list( , $output ) = $this->render( 2 );
+
+		$this->assertSame(
+			2,
+			substr_count( $output, '<li>' ),
+			'The section was not limited to the requested number of posts.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_exclude_posts_the_user_cannot_edit() {
+		$own_id = $this->create_post( 'A post of their own', self::$author_id );
+		$this->create_note( $own_id );
+
+		$other_id = $this->create_post( 'A post of somebody else' );
+		$this->create_note( $other_id );
+
+		wp_set_current_user( self::$author_id );
+
+		list( , $output ) = $this->render();
+
+		$this->assertSame(
+			array( 'A post of their own' ),
+			$this->get_linked_titles( $output ),
+			'A post the user cannot edit was listed.'
+		);
+	}
+
+	/**
+	 * Resolving a note approves the thread it starts, so a thread whose replies
+	 * are still on hold is resolved too.
+	 *
+	 * @ticket 65890
+	 */
+	public function test_should_exclude_a_resolved_thread_with_open_replies() {
+		$post_id = $this->create_post( 'A post with a resolved thread' );
+		$note_id = $this->create_note( $post_id, '1' );
+		$this->create_note( $post_id, '0', $note_id );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertFalse( $returned, 'The function did not return false.' );
+		$this->assertSame( '', $output, 'A resolved thread was listed.' );
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_list_a_post_whose_only_open_thread_has_replies_once() {
+		$post_id  = $this->create_post( 'A post with an open thread' );
+		$resolved = $this->create_note( $post_id, '1' );
+		$this->create_note( $post_id, '0', $resolved );
+
+		$open = $this->create_note( $post_id );
+		$this->create_note( $post_id, '0', $open );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertTrue( $returned, 'The function did not return true.' );
+		$this->assertSame(
+			1,
+			substr_count( $output, '<li>' ),
+			'The post was not listed exactly once.'
+		);
+		$this->assertStringContainsString(
+			'<span class="open-notes-count">1 open note</span>',
+			$output,
+			'Only the open thread should have been counted.'
+		);
+	}
+
+	/**
+	 * The date is the last time the thread was added to, which is the date of
+	 * its most recent reply when it has one.
+	 *
+	 * @ticket 65890
+	 */
+	public function test_should_show_the_date_of_the_most_recent_reply() {
+		$opened  = current_datetime()->modify( '-13 days' );
+		$replied = $opened->modify( '+10 days' );
+
+		$post_id = $this->create_post( 'A post with a reply' );
+		$note_id = $this->create_note( $post_id, '0', 0, $opened->format( 'Y-m-d H:i:s' ) );
+		$this->create_note( $post_id, '0', $note_id, $replied->format( 'Y-m-d H:i:s' ) );
+
+		list( , $output ) = $this->render();
+
+		$this->assertSame(
+			array( '3 days ago' ),
+			$this->get_rendered_dates( $output ),
+			'The date was not the date of the most recent reply.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_order_posts_by_their_most_recent_reply() {
+		$opened  = current_datetime()->modify( '-13 days' );
+		$replied = $opened->modify( '+10 days' );
+
+		$replied_to_id = $this->create_post( 'A post replied to recently' );
+		$note_id       = $this->create_note( $replied_to_id, '0', 0, $opened->format( 'Y-m-d H:i:s' ) );
+		$this->create_note( $replied_to_id, '0', $note_id, $replied->format( 'Y-m-d H:i:s' ) );
+
+		// Opened after the other thread started, but not added to since.
+		$quiet_id = $this->create_post( 'A post left alone since' );
+		$this->create_note( $quiet_id, '0', 0, $opened->modify( '+1 day' )->format( 'Y-m-d H:i:s' ) );
+
+		list( , $output ) = $this->render();
+
+		$this->assertSame(
+			array( 'A post replied to recently', 'A post left alone since' ),
+			$this->get_linked_titles( $output ),
+			'The posts were not ordered by their most recent reply.'
+		);
+	}
+
+	/**
+	 * Notes the current user cannot see are paged past, but only up to a point,
+	 * so that a site with a large number of them does not have every dashboard
+	 * load walk the whole comments table.
+	 *
+	 * @ticket 65890
+	 */
+	public function test_should_stop_paging_past_notes_the_user_cannot_see() {
+		$other_id = $this->create_post( 'A post of somebody else' );
+
+		// One more note than a single row is allowed to look at.
+		for ( $i = 0; $i <= 100; $i++ ) {
+			$this->create_note( $other_id, '0', 0, '2026-01-02 10:00:00' );
+		}
+
+		// Older than all of them, so it is only reached by paging past them.
+		$own_id = $this->create_post( 'A post of their own', self::$author_id );
+		$this->create_note( $own_id, '0', 0, '2026-01-01 10:00:00' );
+
+		wp_set_current_user( self::$author_id );
+
+		list( $returned, $output ) = $this->render( 1 );
+
+		$this->assertFalse( $returned, 'The function did not return false.' );
+		$this->assertSame( '', $output, 'The function kept paging past the limit.' );
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_page_past_notes_the_user_cannot_see() {
+		$other_id = $this->create_post( 'A post of somebody else' );
+
+		// More notes than the first page of the query holds.
+		for ( $i = 0; $i < 20; $i++ ) {
+			$this->create_note( $other_id, '0', 0, '2026-01-02 10:00:00' );
+		}
+
+		$own_id = $this->create_post( 'A post of their own', self::$author_id );
+		$this->create_note( $own_id, '0', 0, '2026-01-01 10:00:00' );
+
+		wp_set_current_user( self::$author_id );
+
+		list( , $output ) = $this->render( 1 );
+
+		$this->assertSame(
+			array( 'A post of their own' ),
+			$this->get_linked_titles( $output ),
+			'The post was not found past the notes the user cannot see.'
+		);
+	}
+
+	/**
+	 * @ticket 65890
+	 */
+	public function test_should_return_false_when_the_user_can_edit_none_of_the_posts() {
+		$post_id = $this->create_post( 'A post of somebody else' );
+		$this->create_note( $post_id );
+
+		wp_set_current_user( self::$author_id );
+
+		list( $returned, $output ) = $this->render();
+
+		$this->assertFalse( $returned, 'The function did not return false.' );
+		$this->assertSame( '', $output, 'The function rendered a section anyway.' );
+	}
+}