Phase 10: hardening and ops

Implements PLAN.md Phase 10.

Simplified Sliding Sync (MSC4186) is served at the unstable
org.matrix.simplified_msc3575 endpoint and advertised in /versions. Lists
are sorted by activity and filtered by DM, invite, encryption, room type,
space and tag; room subscriptions, required_state with wildcards, $ME and
$LAZY, and the to_device, e2ee, account_data, receipts and typing
extensions are supported. Per-connection state is kept in memory and an
unknown pos answers M_UNKNOWN_POS.

Threads and relations: m.relates_to is indexed on roomserver_events
(migration 0012), /relations (with recursion) and /threads are served, and
every event a timeline read returns carries its m.thread, m.replace and
m.reference summaries in unsigned.m.relations. Notifications carry a
thread ID (migration 0013): threaded receipts clear only their thread, and
sync reports unread_thread_notifications when the filter asks.

Spaces: /hierarchy walks a space breadth first, asking other servers about
rooms this one is not in through the new federation hierarchy endpoint;
room_summary describes one room. /search runs on FTS5 (sqlite, pocketbase)
or tsvector (postgres), bounded to what each user may see, with context,
profiles, state, grouping and paging.

The PocketBase driver is real: the sqlite schema and store on an embedded
PocketBase app's database, with media in its filesystem, local or S3
(database.pocketbase.s3). It runs the full storage test suite.

Ops: OpenTelemetry tracing over OTLP/HTTP (tracing.*), with server spans
per route, component spans, and trace propagation on federation, push and
application service calls. New metrics for persisted events, waiting
syncs, sliding sync connections and the database pool, with a Grafana
dashboard. deploy/ adds a Compose setup (PostgreSQL, Prometheus, Grafana,
Jaeger) and a Helm chart; cmd/warp-loadtest loads a server and reports
request and delivery latencies.

The load tester found a long-standing bug, fixed here: on a server where
no account data had been written, every incremental /sync re-sent the push
rules and returned at once, and an all-zero token was taken for an initial
sync, so long polls became busy loops.

The PostgreSQL migrations and search dialect compile but were not run
against a live PostgreSQL in this change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/internal/storage/sqlstore/push.go

@@ -143,8 +143,8 @@ func (s *Push) DeletePushersForDevices(ctx context.Context, localpart string, de
 // to NUMERIC, which does not scan into an int64.
 const (
 	insertNotificationSQL = `INSERT INTO push_notifications
-		(id, user_id, room_id, event_id, event_pos, ts_ms, highlight, actions, is_read)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		(id, user_id, room_id, event_id, event_pos, thread_id, ts_ms, highlight, actions, is_read)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 
 	bumpRoomCountsSQL = `INSERT INTO push_room_counts
 		(user_id, room_id, notification_count, highlight_count, stream_pos)
@@ -157,6 +157,10 @@ const (
 	markReadSQL = `UPDATE push_notifications SET is_read = ?
 		WHERE user_id = ? AND room_id = ? AND is_read = ? AND event_pos <= ?`
 
+	// markThreadReadSQL is markReadSQL for one thread, or for the main
+	// timeline as thread ''.
+	markThreadReadSQL = markReadSQL + ` AND thread_id = ?`
+
 	countUnreadSQL = `SELECT COUNT(*), CAST(COALESCE(SUM(CASE WHEN highlight THEN 1 ELSE 0 END), 0) AS BIGINT)
 		FROM push_notifications WHERE user_id = ? AND room_id = ? AND is_read = ?`
 
@@ -174,7 +178,7 @@ const (
 	selectUnreadTotalSQL = `SELECT CAST(COALESCE(SUM(notification_count), 0) AS BIGINT)
 		FROM push_room_counts WHERE user_id = ?`
 
-	notificationColumns = `id, user_id, room_id, event_id, event_pos, ts_ms, highlight, actions, is_read`
+	notificationColumns = `id, user_id, room_id, event_id, event_pos, thread_id, ts_ms, highlight, actions, is_read`
 
 	pruneNotificationsSQL = `DELETE FROM push_notifications WHERE is_read = ? AND ts_ms < ?`
 )
@@ -196,7 +200,7 @@ func (s *Push) AddNotifications(ctx context.Context, ns []storage.NewNotificatio
 				return err
 			}
 			if _, err := tx.ExecContext(ctx, s.q(insertNotificationSQL), pos, n.UserID, n.RoomID, n.EventID,
-				n.EventPos, n.TimestampMS, n.Highlight, string(n.Actions), false); err != nil {
+				n.EventPos, n.ThreadID, n.TimestampMS, n.Highlight, string(n.Actions), false); err != nil {
 				return fmt.Errorf("write a notification for %q: %w", n.UserID, err)
 			}
 			highlight := 0
@@ -218,14 +222,19 @@ func (s *Push) AddNotifications(ctx context.Context, ns []storage.NewNotificatio
 // The counts are recounted from the rows that are still unread rather than
 // decremented, so that whatever got them out of step — a crash between
 // two writes of an older version, a row pruned by hand — is put right by
-// the next receipt.
-func (s *Push) MarkNotificationsRead(ctx context.Context, userID, roomID string, upTo int64) (int64, bool, error) {
+// the next receipt. The room's counts stay the room's total across every
+// thread whichever thread the receipt read.
+func (s *Push) MarkNotificationsRead(ctx context.Context, userID, roomID, thread string, upTo int64) (int64, bool, error) {
 	var (
 		pos   int64
 		moved bool
 	)
 	err := s.tx(ctx, func(tx *sql.Tx) error {
-		res, err := tx.ExecContext(ctx, s.q(markReadSQL), true, userID, roomID, false, upTo)
+		query, args := markReadSQL, []any{true, userID, roomID, false, upTo}
+		if thread != storage.AllThreads {
+			query, args = markThreadReadSQL, append(args, thread)
+		}
+		res, err := tx.ExecContext(ctx, s.q(query), args...)
 		if err != nil {
 			return fmt.Errorf("mark %q's notifications read: %w", userID, err)
 		}
@@ -291,6 +300,53 @@ func (s *Push) NotificationCounts(ctx context.Context, userID string, roomIDs []
 	return out, nil
 }
 
+// ThreadNotificationCounts implements storage.PushStore.
+//
+// These are counted from the unread rows rather than kept like the room
+// totals: a room has few unread notifications at a time, they are a range
+// of an index, and a table of per-thread counts would be one more thing
+// every write and every receipt has to keep in step.
+func (s *Push) ThreadNotificationCounts(ctx context.Context, userID string, roomIDs []string) (map[string]map[string]storage.NotificationCounts, error) {
+	out := make(map[string]map[string]storage.NotificationCounts, len(roomIDs))
+	if len(roomIDs) == 0 {
+		return out, nil
+	}
+
+	query := `SELECT room_id, thread_id, COUNT(*),
+			CAST(COALESCE(SUM(CASE WHEN highlight THEN 1 ELSE 0 END), 0) AS BIGINT)
+		FROM push_notifications
+		WHERE user_id = ? AND is_read = ? AND room_id IN (` + placeholders(len(roomIDs)) + `)
+		GROUP BY room_id, thread_id`
+	args := make([]any, 0, len(roomIDs)+2)
+	args = append(args, userID, false)
+	for _, id := range roomIDs {
+		args = append(args, id)
+	}
+	rows, err := s.db.QueryContext(ctx, s.q(query), args...)
+	if err != nil {
+		return nil, fmt.Errorf("read %q's thread notification counts: %w", userID, err)
+	}
+	defer func() { _ = rows.Close() }()
+	for rows.Next() {
+		var roomID, thread string
+		var notifications, highlights int64
+		if err := rows.Scan(&roomID, &thread, &notifications, &highlights); err != nil {
+			return nil, fmt.Errorf("read %q's thread notification counts: %w", userID, err)
+		}
+		if out[roomID] == nil {
+			out[roomID] = map[string]storage.NotificationCounts{}
+		}
+		out[roomID][thread] = storage.NotificationCounts{
+			Notifications: int(notifications),
+			Highlights:    int(highlights),
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("read %q's thread notification counts: %w", userID, err)
+	}
+	return out, nil
+}
+
 // NotificationCountChanges implements storage.PushStore.
 func (s *Push) NotificationCountChanges(ctx context.Context, userID string, from, to int64) ([]string, error) {
 	rows, err := s.db.QueryContext(ctx, s.q(selectCountChangesSQL), userID, from, to)
@@ -345,7 +401,7 @@ func (s *Push) Notifications(ctx context.Context, userID string, before int64, l
 	for rows.Next() {
 		var n storage.Notification
 		var actions string
-		if err := rows.Scan(&n.ID, &n.UserID, &n.RoomID, &n.EventID, &n.EventPos, &n.TimestampMS,
+		if err := rows.Scan(&n.ID, &n.UserID, &n.RoomID, &n.EventID, &n.EventPos, &n.ThreadID, &n.TimestampMS,
 			&n.Highlight, &actions, &n.Read); err != nil {
 			return nil, fmt.Errorf("read %q's notifications: %w", userID, err)
 		}