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/sqlite/sqlite.go

@@ -49,6 +49,56 @@ var settingsQueries = sqlstore.SettingsQueries{
 	Delete: `DELETE FROM server_settings WHERE setting_key = ?`,
 }
 
+// searchDialect is the full-text index on FTS5. The table cannot be
+// aliased — MATCH and bm25() take its own name — and its rowid is the
+// event's stream ordering. bm25() scores better matches lower, so the rank
+// is its negation.
+var searchDialect = &sqlstore.SearchDialect{
+	Insert: `INSERT INTO roomserver_event_search (rowid, room_id, event_id, search_key, sender, event_type, body)
+		VALUES (?, ?, ?, ?, ?, ?, ?)`,
+	DeleteEvent: `DELETE FROM roomserver_event_search WHERE rowid IN (
+		SELECT stream_ordering FROM roomserver_events WHERE room_id = ? AND event_id = ?)`,
+	DeleteRoom: `DELETE FROM roomserver_event_search WHERE room_id = ?`,
+	From:       `roomserver_event_search`,
+	Name:       `roomserver_event_search`,
+	Position:   `roomserver_event_search.rowid`,
+	Match:      `roomserver_event_search MATCH ?`,
+	Rank:       `-bm25(roomserver_event_search)`,
+	Query:      ftsQuery,
+}
+
+// ftsQuery builds an FTS5 query from a search term: every word, quoted so
+// that nothing in it is read as an operator, and matched as a prefix so
+// that a user who has typed "hel" already finds "hello". Words side by
+// side are ANDed.
+func ftsQuery(term string) string {
+	words := storage.SearchWords(term)
+	for i, w := range words {
+		words[i] = `"` + strings.ReplaceAll(w, `"`, `""`) + `"*`
+	}
+	return strings.Join(words, " ")
+}
+
+// StoreOptions are the sqlstore options for a SQLite database already
+// opened on db: the migrations, statements and error recognition every
+// SQLite-backed driver shares. The PocketBase driver runs on a SQLite file
+// of its own and uses them as they are.
+func StoreOptions(db *sql.DB, log *slog.Logger) sqlstore.Options {
+	return sqlstore.Options{
+		DriverName:    storage.DriverSQLite,
+		DB:            db,
+		Dialect:       dialect,
+		MigrationsFS:  migrationFiles,
+		MigrationsDir: "migrations",
+		Settings:      settingsQueries,
+		// SQLite already uses the `?` placeholders the shared component
+		// stores are written with, so there is nothing to rebind.
+		IsUniqueViolation: isUniqueViolation,
+		Search:            searchDialect,
+		Logger:            log,
+	}
+}
+
 // Database is the SQLite implementation of storage.Database.
 type Database struct {
 	*sqlstore.Store
@@ -86,18 +136,7 @@ func Open(ctx context.Context, cfg storage.Config, log *slog.Logger) (storage.Da
 		return nil, fmt.Errorf("sqlite: connect: %w", err)
 	}
 
-	store, err := sqlstore.New(sqlstore.Options{
-		DriverName:    storage.DriverSQLite,
-		DB:            db,
-		Dialect:       dialect,
-		MigrationsFS:  migrationFiles,
-		MigrationsDir: "migrations",
-		Settings:      settingsQueries,
-		// SQLite already uses the `?` placeholders the shared component
-		// stores are written with, so there is nothing to rebind.
-		IsUniqueViolation: isUniqueViolation,
-		Logger:            log,
-	})
+	store, err := sqlstore.New(StoreOptions(db, log))
 	if err != nil {
 		_ = db.Close()
 		return nil, err