init moderation

backend/internal/api/annotations.go

···
 	Selector json.RawMessage `json:"selector,omitempty"`
 	Title    string          `json:"title,omitempty"`
 	Tags     []string        `json:"tags,omitempty"`
+	Labels   []string        `json:"labels,omitempty"`
 }
 
 type CreateAnnotationResponse struct {
···
 		record.Facets = facets
 	}
 
+	validSelfLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+	var validLabels []string
+	for _, l := range req.Labels {
+		if validSelfLabels[l] {
+			validLabels = append(validLabels, l)
+		}
+	}
+	record.Labels = xrpc.NewSelfLabels(validLabels)
+
 	var result *xrpc.CreateRecordOutput
 
 	if existing, err := s.checkDuplicateAnnotation(session.DID, req.URL, req.Text); err == nil && existing != nil {
···
 		log.Printf("Warning: failed to index annotation in local DB: %v", err)
 	}
 
+	for _, label := range validLabels {
+		if err := s.db.CreateContentLabel(session.DID, result.URI, label, session.DID); err != nil {
+			log.Printf("Warning: failed to create self-label %s: %v", label, err)
+		}
+	}
+
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(CreateAnnotationResponse{
 		URI: result.URI,
···
 }
 
 type UpdateAnnotationRequest struct {
-	Text string   `json:"text"`
-	Tags []string `json:"tags"`
+	Text   string   `json:"text"`
+	Tags   []string `json:"tags"`
+	Labels []string `json:"labels,omitempty"`
 }
 
 func (s *AnnotationService) UpdateAnnotation(w http.ResponseWriter, r *http.Request) {
···
 			record.Tags = nil
 		}
 
+		updateValidLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+		var updateLabels []string
+		for _, l := range req.Labels {
+			if updateValidLabels[l] {
+				updateLabels = append(updateLabels, l)
+			}
+		}
+		record.Labels = xrpc.NewSelfLabels(updateLabels)
+
 		if err := record.Validate(); err != nil {
 			return fmt.Errorf("validation failed: %w", err)
 		}
···
 	})
 
 	if err != nil {
+		log.Printf("[UpdateAnnotation] Failed: %v", err)
 		http.Error(w, "Failed to update record: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
 	s.db.UpdateAnnotation(uri, req.Text, tagsJSON, result.CID)
+
+	validSelfLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+	var validLabels []string
+	for _, l := range req.Labels {
+		if validSelfLabels[l] {
+			validLabels = append(validLabels, l)
+		}
+	}
+	if err := s.db.SyncSelfLabels(session.DID, uri, validLabels); err != nil {
+		log.Printf("Warning: failed to sync self-labels: %v", err)
+	}
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 	Selector json.RawMessage `json:"selector"`
 	Color    string          `json:"color,omitempty"`
 	Tags     []string        `json:"tags,omitempty"`
+	Labels   []string        `json:"labels,omitempty"`
 }
 
 func (s *AnnotationService) CreateHighlight(w http.ResponseWriter, r *http.Request) {
···
 
 	urlHash := db.HashURL(req.URL)
 	record := xrpc.NewHighlightRecord(req.URL, urlHash, req.Selector, req.Color, req.Tags)
+
+	validSelfLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+	var validLabels []string
+	for _, l := range req.Labels {
+		if validSelfLabels[l] {
+			validLabels = append(validLabels, l)
+		}
+	}
+	record.Labels = xrpc.NewSelfLabels(validLabels)
 
 	if err := record.Validate(); err != nil {
 		http.Error(w, "Validation error: "+err.Error(), http.StatusBadRequest)
···
 		return
 	}
 
+	for _, label := range validLabels {
+		if err := s.db.CreateContentLabel(session.DID, result.URI, label, session.DID); err != nil {
+			log.Printf("Warning: failed to create self-label %s: %v", label, err)
+		}
+	}
+
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{"uri": result.URI, "cid": result.CID})
 }
···
 }
 
 type UpdateHighlightRequest struct {
-	Color string   `json:"color"`
-	Tags  []string `json:"tags,omitempty"`
+	Color  string   `json:"color"`
+	Tags   []string `json:"tags,omitempty"`
+	Labels []string `json:"labels,omitempty"`
 }
 
 func (s *AnnotationService) UpdateHighlight(w http.ResponseWriter, r *http.Request) {
···
 			record.Tags = req.Tags
 		}
 
+		updateValidLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+		var updateLabels []string
+		for _, l := range req.Labels {
+			if updateValidLabels[l] {
+				updateLabels = append(updateLabels, l)
+			}
+		}
+		record.Labels = xrpc.NewSelfLabels(updateLabels)
+
 		if err := record.Validate(); err != nil {
 			return fmt.Errorf("validation failed: %w", err)
 		}
···
 	}
 	s.db.UpdateHighlight(uri, req.Color, tagsJSON, result.CID)
 
+	validSelfLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+	var validLabels []string
+	for _, l := range req.Labels {
+		if validSelfLabels[l] {
+			validLabels = append(validLabels, l)
+		}
+	}
+	if err := s.db.SyncSelfLabels(session.DID, uri, validLabels); err != nil {
+		log.Printf("Warning: failed to sync self-labels: %v", err)
+	}
+
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{"success": true, "uri": result.URI, "cid": result.CID})
 }
···
 	Title       string   `json:"title"`
 	Description string   `json:"description"`
 	Tags        []string `json:"tags,omitempty"`
+	Labels      []string `json:"labels,omitempty"`
 }
 
 func (s *AnnotationService) UpdateBookmark(w http.ResponseWriter, r *http.Request) {
···
 			record.Tags = req.Tags
 		}
 
+		updateValidLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+		var updateLabels []string
+		for _, l := range req.Labels {
+			if updateValidLabels[l] {
+				updateLabels = append(updateLabels, l)
+			}
+		}
+		record.Labels = xrpc.NewSelfLabels(updateLabels)
+
 		if err := record.Validate(); err != nil {
 			return fmt.Errorf("validation failed: %w", err)
 		}
···
 		tagsJSON = string(b)
 	}
 	s.db.UpdateBookmark(uri, req.Title, req.Description, tagsJSON, result.CID)
+
+	validSelfLabels := map[string]bool{"sexual": true, "nudity": true, "violence": true, "gore": true, "spam": true, "misleading": true}
+	var validLabels []string
+	for _, l := range req.Labels {
+		if validSelfLabels[l] {
+			validLabels = append(validLabels, l)
+		}
+	}
+	if err := s.db.SyncSelfLabels(session.DID, uri, validLabels); err != nil {
+		log.Printf("Warning: failed to sync self-labels: %v", err)
+	}
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{"success": true, "uri": result.URI, "cid": result.CID})

backend/internal/api/handler.go

···
 	refresher         *TokenRefresher
 	apiKeys           *APIKeyHandler
 	syncService       *internal_sync.Service
+	moderation        *ModerationHandler
 }
 
 func NewHandler(database *db.DB, annotationService *AnnotationService, refresher *TokenRefresher, syncService *internal_sync.Service) *Handler {
···
 		refresher:         refresher,
 		apiKeys:           NewAPIKeyHandler(database, refresher),
 		syncService:       syncService,
+		moderation:        NewModerationHandler(database, refresher),
 	}
 }
 
···
 
 		r.Get("/preferences", h.GetPreferences)
 		r.Put("/preferences", h.UpdatePreferences)
+
+		r.Post("/moderation/block", h.moderation.BlockUser)
+		r.Delete("/moderation/block", h.moderation.UnblockUser)
+		r.Get("/moderation/blocks", h.moderation.GetBlocks)
+		r.Post("/moderation/mute", h.moderation.MuteUser)
+		r.Delete("/moderation/mute", h.moderation.UnmuteUser)
+		r.Get("/moderation/mutes", h.moderation.GetMutes)
+		r.Get("/moderation/relationship", h.moderation.GetRelationship)
+		r.Post("/moderation/report", h.moderation.CreateReport)
+		r.Get("/moderation/admin/check", h.moderation.AdminCheckAccess)
+		r.Get("/moderation/admin/reports", h.moderation.AdminGetReports)
+		r.Get("/moderation/admin/report", h.moderation.AdminGetReport)
+		r.Post("/moderation/admin/action", h.moderation.AdminTakeAction)
+		r.Post("/moderation/admin/label", h.moderation.AdminCreateLabel)
+		r.Delete("/moderation/admin/label", h.moderation.AdminDeleteLabel)
+		r.Get("/moderation/admin/labels", h.moderation.AdminGetLabels)
+		r.Get("/moderation/labeler", h.moderation.GetLabelerInfo)
 	})
 }
 
···
 		feed = filtered
 	}
 
-	// ...
+	feed = h.filterFeedByModeration(feed, viewerDID)
+
 	switch feedType {
 	case "popular":
 		sortFeedByPopularity(feed)
···
 	} else {
 		feed = []interface{}{}
 	}
-	// ...
 
 	if len(feed) > limit {
 		feed = feed[:limit]
···
 	}
 	return did
 }
+
+func getItemAuthorDID(item interface{}) string {
+	switch v := item.(type) {
+	case APIAnnotation:
+		return v.Author.DID
+	case APIHighlight:
+		return v.Author.DID
+	case APIBookmark:
+		return v.Author.DID
+	case APICollectionItem:
+		return v.Author.DID
+	default:
+		return ""
+	}
+}
+
+func (h *Handler) filterFeedByModeration(feed []interface{}, viewerDID string) []interface{} {
+	if viewerDID == "" {
+		return feed
+	}
+
+	hiddenDIDs, err := h.db.GetAllHiddenDIDs(viewerDID)
+	if err != nil || len(hiddenDIDs) == 0 {
+		return feed
+	}
+
+	var filtered []interface{}
+	for _, item := range feed {
+		authorDID := getItemAuthorDID(item)
+		if authorDID != "" && hiddenDIDs[authorDID] {
+			continue
+		}
+		filtered = append(filtered, item)
+	}
+	return filtered
+}

backend/internal/api/hydration.go

···
 	Name string `json:"name"`
 }
 
+type APILabel struct {
+	Val   string `json:"val"`
+	Src   string `json:"src"`
+	Scope string `json:"scope"`
+}
+
 type APIAnnotation struct {
 	ID             string        `json:"id"`
 	CID            string        `json:"cid"`
···
 	LikeCount      int           `json:"likeCount"`
 	ReplyCount     int           `json:"replyCount"`
 	ViewerHasLiked bool          `json:"viewerHasLiked"`
+	Labels         []APILabel    `json:"labels,omitempty"`
 }
 
 type APIHighlight struct {
-	ID             string    `json:"id"`
-	Type           string    `json:"type"`
-	Motivation     string    `json:"motivation"`
-	Author         Author    `json:"creator"`
-	Target         APITarget `json:"target"`
-	Color          string    `json:"color,omitempty"`
-	Tags           []string  `json:"tags,omitempty"`
-	CreatedAt      time.Time `json:"created"`
-	CID            string    `json:"cid,omitempty"`
-	LikeCount      int       `json:"likeCount"`
-	ReplyCount     int       `json:"replyCount"`
-	ViewerHasLiked bool      `json:"viewerHasLiked"`
+	ID             string     `json:"id"`
+	Type           string     `json:"type"`
+	Motivation     string     `json:"motivation"`
+	Author         Author     `json:"creator"`
+	Target         APITarget  `json:"target"`
+	Color          string     `json:"color,omitempty"`
+	Tags           []string   `json:"tags,omitempty"`
+	CreatedAt      time.Time  `json:"created"`
+	CID            string     `json:"cid,omitempty"`
+	LikeCount      int        `json:"likeCount"`
+	ReplyCount     int        `json:"replyCount"`
+	ViewerHasLiked bool       `json:"viewerHasLiked"`
+	Labels         []APILabel `json:"labels,omitempty"`
 }
 
 type APIBookmark struct {
-	ID             string    `json:"id"`
-	Type           string    `json:"type"`
-	Motivation     string    `json:"motivation"`
-	Author         Author    `json:"creator"`
-	Source         string    `json:"source"`
-	Title          string    `json:"title,omitempty"`
-	Description    string    `json:"description,omitempty"`
-	Tags           []string  `json:"tags,omitempty"`
-	CreatedAt      time.Time `json:"created"`
-	CID            string    `json:"cid,omitempty"`
-	LikeCount      int       `json:"likeCount"`
-	ReplyCount     int       `json:"replyCount"`
-	ViewerHasLiked bool      `json:"viewerHasLiked"`
+	ID             string     `json:"id"`
+	Type           string     `json:"type"`
+	Motivation     string     `json:"motivation"`
+	Author         Author     `json:"creator"`
+	Source         string     `json:"source"`
+	Title          string     `json:"title,omitempty"`
+	Description    string     `json:"description,omitempty"`
+	Tags           []string   `json:"tags,omitempty"`
+	CreatedAt      time.Time  `json:"created"`
+	CID            string     `json:"cid,omitempty"`
+	LikeCount      int        `json:"likeCount"`
+	ReplyCount     int        `json:"replyCount"`
+	ViewerHasLiked bool       `json:"viewerHasLiked"`
+	Labels         []APILabel `json:"labels,omitempty"`
 }
 
 type APIReply struct {
···
 	defer cancel()
 	likeCounts, replyCounts, viewerLikes := fetchCounts(ctx, database, uris, viewerDID)
 
+	subscribedLabelers := getSubscribedLabelers(database, viewerDID)
+	authorDIDs := collectDIDs(annotations, func(a db.Annotation) string { return a.AuthorDID })
+	labelerDIDs := appendUnique(subscribedLabelers, authorDIDs)
+	uriLabels, _ := database.GetContentLabelsForURIs(uris, labelerDIDs)
+	didLabels, _ := database.GetContentLabelsForDIDs(authorDIDs, labelerDIDs)
+
 	result := make([]APIAnnotation, len(annotations))
 	for i, a := range annotations {
 		var body *APIBody
···
 			},
 			CreatedAt: a.CreatedAt,
 			IndexedAt: a.IndexedAt,
+			Labels:    mergeLabels(uriLabels[a.URI], didLabels[a.AuthorDID]),
 		}
 
 		result[i].LikeCount = likeCounts[a.URI]
···
 	defer cancel()
 	likeCounts, replyCounts, viewerLikes := fetchCounts(ctx, database, uris, viewerDID)
 
+	subscribedLabelers := getSubscribedLabelers(database, viewerDID)
+	authorDIDs := collectDIDs(highlights, func(h db.Highlight) string { return h.AuthorDID })
+	labelerDIDs := appendUnique(subscribedLabelers, authorDIDs)
+	uriLabels, _ := database.GetContentLabelsForURIs(uris, labelerDIDs)
+	didLabels, _ := database.GetContentLabelsForDIDs(authorDIDs, labelerDIDs)
+
 	result := make([]APIHighlight, len(highlights))
 	for i, h := range highlights {
 		var selector *APISelector
···
 			Tags:      tags,
 			CreatedAt: h.CreatedAt,
 			CID:       cid,
+			Labels:    mergeLabels(uriLabels[h.URI], didLabels[h.AuthorDID]),
 		}
 
 		result[i].LikeCount = likeCounts[h.URI]
···
 	defer cancel()
 	likeCounts, replyCounts, viewerLikes := fetchCounts(ctx, database, uris, viewerDID)
 
+	subscribedLabelers := getSubscribedLabelers(database, viewerDID)
+	authorDIDs := collectDIDs(bookmarks, func(b db.Bookmark) string { return b.AuthorDID })
+	labelerDIDs := appendUnique(subscribedLabelers, authorDIDs)
+	uriLabels, _ := database.GetContentLabelsForURIs(uris, labelerDIDs)
+	didLabels, _ := database.GetContentLabelsForDIDs(authorDIDs, labelerDIDs)
+
 	result := make([]APIBookmark, len(bookmarks))
 	for i, b := range bookmarks {
 		var tags []string
···
 			Tags:        tags,
 			CreatedAt:   b.CreatedAt,
 			CID:         cid,
+			Labels:      mergeLabels(uriLabels[b.URI], didLabels[b.AuthorDID]),
 		}
 		result[i].LikeCount = likeCounts[b.URI]
 		result[i].ReplyCount = replyCounts[b.URI]
···
 
 	return result, nil
 }
+
+func mergeLabels(uriLabels []db.ContentLabel, didLabels []db.ContentLabel) []APILabel {
+	seen := make(map[string]bool)
+	var labels []APILabel
+	for _, l := range uriLabels {
+		key := l.Val + ":" + l.Src
+		if !seen[key] {
+			labels = append(labels, APILabel{Val: l.Val, Src: l.Src, Scope: "content"})
+			seen[key] = true
+		}
+	}
+	for _, l := range didLabels {
+		key := l.Val + ":" + l.Src
+		if !seen[key] {
+			labels = append(labels, APILabel{Val: l.Val, Src: l.Src, Scope: "account"})
+			seen[key] = true
+		}
+	}
+	return labels
+}
+
+func appendUnique(base []string, extra []string) []string {
+	if base == nil {
+		return nil
+	}
+	seen := make(map[string]bool, len(base))
+	for _, s := range base {
+		seen[s] = true
+	}
+	result := make([]string, len(base))
+	copy(result, base)
+	for _, s := range extra {
+		if !seen[s] {
+			result = append(result, s)
+			seen[s] = true
+		}
+	}
+	return result
+}
+
+func getSubscribedLabelers(database *db.DB, viewerDID string) []string {
+	serviceDID := config.Get().ServiceDID
+
+	if viewerDID == "" {
+		if serviceDID != "" {
+			return []string{serviceDID}
+		}
+		return nil
+	}
+
+	prefs, err := database.GetPreferences(viewerDID)
+	if err != nil || prefs == nil || prefs.SubscribedLabelers == nil {
+		if serviceDID != "" {
+			return []string{serviceDID}
+		}
+		return nil
+	}
+
+	type sub struct {
+		DID string `json:"did"`
+	}
+	var subs []sub
+	if err := json.Unmarshal([]byte(*prefs.SubscribedLabelers), &subs); err != nil || len(subs) == 0 {
+		if serviceDID != "" {
+			return []string{serviceDID}
+		}
+		return nil
+	}
+
+	dids := make([]string, len(subs))
+	for i, s := range subs {
+		dids[i] = s.DID
+	}
+	return dids
+}

backend/internal/api/moderation.go

···
+package api
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"strconv"
+
+	"margin.at/internal/config"
+	"margin.at/internal/db"
+)
+
+type ModerationHandler struct {
+	db        *db.DB
+	refresher *TokenRefresher
+}
+
+func NewModerationHandler(database *db.DB, refresher *TokenRefresher) *ModerationHandler {
+	return &ModerationHandler{db: database, refresher: refresher}
+}
+
+func (m *ModerationHandler) BlockUser(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		DID string `json:"did"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.DID == "" {
+		http.Error(w, "did is required", http.StatusBadRequest)
+		return
+	}
+
+	if req.DID == session.DID {
+		http.Error(w, "Cannot block yourself", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.CreateBlock(session.DID, req.DID); err != nil {
+		log.Printf("Failed to create block: %v", err)
+		http.Error(w, "Failed to block user", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) UnblockUser(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	did := r.URL.Query().Get("did")
+	if did == "" {
+		http.Error(w, "did query parameter required", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.DeleteBlock(session.DID, did); err != nil {
+		log.Printf("Failed to delete block: %v", err)
+		http.Error(w, "Failed to unblock user", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) GetBlocks(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	blocks, err := m.db.GetBlocks(session.DID)
+	if err != nil {
+		http.Error(w, "Failed to fetch blocks", http.StatusInternalServerError)
+		return
+	}
+
+	dids := make([]string, len(blocks))
+	for i, b := range blocks {
+		dids[i] = b.SubjectDID
+	}
+	profiles := fetchProfilesForDIDs(m.db, dids)
+
+	type BlockedUser struct {
+		DID       string `json:"did"`
+		Author    Author `json:"author"`
+		CreatedAt string `json:"createdAt"`
+	}
+
+	items := make([]BlockedUser, len(blocks))
+	for i, b := range blocks {
+		items[i] = BlockedUser{
+			DID:       b.SubjectDID,
+			Author:    profiles[b.SubjectDID],
+			CreatedAt: b.CreatedAt.Format("2006-01-02T15:04:05Z"),
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{"items": items})
+}
+
+
+func (m *ModerationHandler) MuteUser(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		DID string `json:"did"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.DID == "" {
+		http.Error(w, "did is required", http.StatusBadRequest)
+		return
+	}
+
+	if req.DID == session.DID {
+		http.Error(w, "Cannot mute yourself", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.CreateMute(session.DID, req.DID); err != nil {
+		log.Printf("Failed to create mute: %v", err)
+		http.Error(w, "Failed to mute user", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) UnmuteUser(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	did := r.URL.Query().Get("did")
+	if did == "" {
+		http.Error(w, "did query parameter required", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.DeleteMute(session.DID, did); err != nil {
+		log.Printf("Failed to delete mute: %v", err)
+		http.Error(w, "Failed to unmute user", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) GetMutes(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	mutes, err := m.db.GetMutes(session.DID)
+	if err != nil {
+		http.Error(w, "Failed to fetch mutes", http.StatusInternalServerError)
+		return
+	}
+
+	dids := make([]string, len(mutes))
+	for i, mu := range mutes {
+		dids[i] = mu.SubjectDID
+	}
+	profiles := fetchProfilesForDIDs(m.db, dids)
+
+	type MutedUser struct {
+		DID       string `json:"did"`
+		Author    Author `json:"author"`
+		CreatedAt string `json:"createdAt"`
+	}
+
+	items := make([]MutedUser, len(mutes))
+	for i, mu := range mutes {
+		items[i] = MutedUser{
+			DID:       mu.SubjectDID,
+			Author:    profiles[mu.SubjectDID],
+			CreatedAt: mu.CreatedAt.Format("2006-01-02T15:04:05Z"),
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{"items": items})
+}
+
+func (m *ModerationHandler) GetRelationship(w http.ResponseWriter, r *http.Request) {
+	viewerDID := m.getViewerDID(r)
+	subjectDID := r.URL.Query().Get("did")
+
+	if subjectDID == "" {
+		http.Error(w, "did query parameter required", http.StatusBadRequest)
+		return
+	}
+
+	blocked, muted, blockedBy, err := m.db.GetViewerRelationship(viewerDID, subjectDID)
+	if err != nil {
+		http.Error(w, "Failed to get relationship", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"blocking":  blocked,
+		"muting":    muted,
+		"blockedBy": blockedBy,
+	})
+}
+
+
+func (m *ModerationHandler) CreateReport(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		SubjectDID string  `json:"subjectDid"`
+		SubjectURI *string `json:"subjectUri,omitempty"`
+		ReasonType string  `json:"reasonType"`
+		ReasonText *string `json:"reasonText,omitempty"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.SubjectDID == "" || req.ReasonType == "" {
+		http.Error(w, "subjectDid and reasonType are required", http.StatusBadRequest)
+		return
+	}
+
+	validReasons := map[string]bool{
+		"spam":        true,
+		"violation":   true,
+		"misleading":  true,
+		"sexual":      true,
+		"rude":        true,
+		"other":       true,
+	}
+
+	if !validReasons[req.ReasonType] {
+		http.Error(w, "Invalid reasonType", http.StatusBadRequest)
+		return
+	}
+
+	id, err := m.db.CreateReport(session.DID, req.SubjectDID, req.SubjectURI, req.ReasonType, req.ReasonText)
+	if err != nil {
+		log.Printf("Failed to create report: %v", err)
+		http.Error(w, "Failed to submit report", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{"id": id, "status": "ok"})
+}
+
+
+func (m *ModerationHandler) AdminGetReports(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	status := r.URL.Query().Get("status")
+	limit := parseIntParam(r, "limit", 50)
+	offset := parseIntParam(r, "offset", 0)
+
+	reports, err := m.db.GetReports(status, limit, offset)
+	if err != nil {
+		http.Error(w, "Failed to fetch reports", http.StatusInternalServerError)
+		return
+	}
+
+	uniqueDIDs := make(map[string]bool)
+	for _, rpt := range reports {
+		uniqueDIDs[rpt.ReporterDID] = true
+		uniqueDIDs[rpt.SubjectDID] = true
+	}
+	dids := make([]string, 0, len(uniqueDIDs))
+	for did := range uniqueDIDs {
+		dids = append(dids, did)
+	}
+	profiles := fetchProfilesForDIDs(m.db, dids)
+
+	type HydratedReport struct {
+		ID         int     `json:"id"`
+		Reporter   Author  `json:"reporter"`
+		Subject    Author  `json:"subject"`
+		SubjectURI *string `json:"subjectUri,omitempty"`
+		ReasonType string  `json:"reasonType"`
+		ReasonText *string `json:"reasonText,omitempty"`
+		Status     string  `json:"status"`
+		CreatedAt  string  `json:"createdAt"`
+		ResolvedAt *string `json:"resolvedAt,omitempty"`
+		ResolvedBy *string `json:"resolvedBy,omitempty"`
+	}
+
+	items := make([]HydratedReport, len(reports))
+	for i, rpt := range reports {
+		items[i] = HydratedReport{
+			ID:         rpt.ID,
+			Reporter:   profiles[rpt.ReporterDID],
+			Subject:    profiles[rpt.SubjectDID],
+			SubjectURI: rpt.SubjectURI,
+			ReasonType: rpt.ReasonType,
+			ReasonText: rpt.ReasonText,
+			Status:     rpt.Status,
+			CreatedAt:  rpt.CreatedAt.Format("2006-01-02T15:04:05Z"),
+		}
+		if rpt.ResolvedAt != nil {
+			resolved := rpt.ResolvedAt.Format("2006-01-02T15:04:05Z")
+			items[i].ResolvedAt = &resolved
+		}
+		items[i].ResolvedBy = rpt.ResolvedBy
+	}
+
+	pendingCount, _ := m.db.GetReportCount("pending")
+	totalCount, _ := m.db.GetReportCount("")
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"items":        items,
+		"totalItems":   totalCount,
+		"pendingCount": pendingCount,
+	})
+}
+
+func (m *ModerationHandler) AdminTakeAction(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	var req struct {
+		ReportID int     `json:"reportId"`
+		Action   string  `json:"action"`
+		Comment  *string `json:"comment,omitempty"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	validActions := map[string]bool{
+		"acknowledge": true,
+		"escalate":    true,
+		"takedown":    true,
+		"dismiss":     true,
+	}
+
+	if !validActions[req.Action] {
+		http.Error(w, "Invalid action", http.StatusBadRequest)
+		return
+	}
+
+	report, err := m.db.GetReport(req.ReportID)
+	if err != nil {
+		http.Error(w, "Report not found", http.StatusNotFound)
+		return
+	}
+
+	if err := m.db.CreateModerationAction(req.ReportID, session.DID, req.Action, req.Comment); err != nil {
+		log.Printf("Failed to create moderation action: %v", err)
+		http.Error(w, "Failed to take action", http.StatusInternalServerError)
+		return
+	}
+
+	resolveStatus := "resolved"
+	switch req.Action {
+	case "dismiss":
+		resolveStatus = "dismissed"
+	case "escalate":
+		resolveStatus = "escalated"
+	case "takedown":
+		resolveStatus = "resolved"
+		if report.SubjectURI != nil && *report.SubjectURI != "" {
+			m.deleteContent(*report.SubjectURI)
+		}
+	case "acknowledge":
+		resolveStatus = "acknowledged"
+	}
+
+	if err := m.db.ResolveReport(req.ReportID, session.DID, resolveStatus); err != nil {
+		log.Printf("Failed to resolve report: %v", err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) AdminGetReport(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	idStr := r.URL.Query().Get("id")
+	id, err := strconv.Atoi(idStr)
+	if err != nil {
+		http.Error(w, "Invalid report ID", http.StatusBadRequest)
+		return
+	}
+
+	report, err := m.db.GetReport(id)
+	if err != nil {
+		http.Error(w, "Report not found", http.StatusNotFound)
+		return
+	}
+
+	actions, _ := m.db.GetReportActions(id)
+
+	profiles := fetchProfilesForDIDs(m.db, []string{report.ReporterDID, report.SubjectDID})
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"report":   report,
+		"reporter": profiles[report.ReporterDID],
+		"subject":  profiles[report.SubjectDID],
+		"actions":  actions,
+	})
+}
+
+func (m *ModerationHandler) AdminCheckAccess(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]bool{"isAdmin": false})
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]bool{"isAdmin": config.Get().IsAdmin(session.DID)})
+}
+
+func (m *ModerationHandler) deleteContent(uri string) {
+	m.db.Exec("DELETE FROM annotations WHERE uri = $1", uri)
+	m.db.Exec("DELETE FROM highlights WHERE uri = $1", uri)
+	m.db.Exec("DELETE FROM bookmarks WHERE uri = $1", uri)
+	m.db.Exec("DELETE FROM replies WHERE uri = $1", uri)
+}
+
+
+func (m *ModerationHandler) AdminCreateLabel(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	var req struct {
+		Src string `json:"src"`
+		URI string `json:"uri"`
+		Val string `json:"val"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.Val == "" {
+		http.Error(w, "val is required", http.StatusBadRequest)
+		return
+	}
+
+	labelerDID := config.Get().ServiceDID
+	if labelerDID == "" {
+		http.Error(w, "SERVICE_DID not configured — cannot issue labels", http.StatusInternalServerError)
+		return
+	}
+
+	targetURI := req.URI
+	if targetURI == "" {
+		targetURI = req.Src
+	}
+	if targetURI == "" {
+		http.Error(w, "src or uri is required", http.StatusBadRequest)
+		return
+	}
+
+	validLabels := map[string]bool{
+		"sexual":     true,
+		"nudity":     true,
+		"violence":   true,
+		"gore":       true,
+		"spam":       true,
+		"misleading": true,
+	}
+
+	if !validLabels[req.Val] {
+		http.Error(w, "Invalid label value. Must be one of: sexual, nudity, violence, gore, spam, misleading", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.CreateContentLabel(labelerDID, targetURI, req.Val, session.DID); err != nil {
+		log.Printf("Failed to create content label: %v", err)
+		http.Error(w, "Failed to create label", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) AdminDeleteLabel(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	idStr := r.URL.Query().Get("id")
+	id, err := strconv.Atoi(idStr)
+	if err != nil {
+		http.Error(w, "Invalid label ID", http.StatusBadRequest)
+		return
+	}
+
+	if err := m.db.DeleteContentLabel(id); err != nil {
+		http.Error(w, "Failed to delete label", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+}
+
+func (m *ModerationHandler) AdminGetLabels(w http.ResponseWriter, r *http.Request) {
+	session, err := m.refresher.GetSessionWithAutoRefresh(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if !config.Get().IsAdmin(session.DID) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	limit := parseIntParam(r, "limit", 50)
+	offset := parseIntParam(r, "offset", 0)
+
+	labels, err := m.db.GetAllContentLabels(limit, offset)
+	if err != nil {
+		http.Error(w, "Failed to fetch labels", http.StatusInternalServerError)
+		return
+	}
+
+	uniqueDIDs := make(map[string]bool)
+	for _, l := range labels {
+		uniqueDIDs[l.CreatedBy] = true
+		if len(l.Src) > 4 && l.Src[:4] == "did:" {
+			uniqueDIDs[l.Src] = true
+		}
+	}
+	dids := make([]string, 0, len(uniqueDIDs))
+	for did := range uniqueDIDs {
+		dids = append(dids, did)
+	}
+	profiles := fetchProfilesForDIDs(m.db, dids)
+
+	type HydratedLabel struct {
+		ID        int    `json:"id"`
+		Src       string `json:"src"`
+		URI       string `json:"uri"`
+		Val       string `json:"val"`
+		CreatedBy Author `json:"createdBy"`
+		CreatedAt string `json:"createdAt"`
+		Subject   *Author `json:"subject,omitempty"`
+	}
+
+	items := make([]HydratedLabel, len(labels))
+	for i, l := range labels {
+		items[i] = HydratedLabel{
+			ID:        l.ID,
+			Src:       l.Src,
+			URI:       l.URI,
+			Val:       l.Val,
+			CreatedBy: profiles[l.CreatedBy],
+			CreatedAt: l.CreatedAt.Format("2006-01-02T15:04:05Z"),
+		}
+		if len(l.Src) > 4 && l.Src[:4] == "did:" {
+			subj := profiles[l.Src]
+			items[i].Subject = &subj
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{"items": items})
+}
+
+func (m *ModerationHandler) getViewerDID(r *http.Request) string {
+	cookie, err := r.Cookie("margin_session")
+	if err != nil {
+		return ""
+	}
+	did, _, _, _, _, err := m.db.GetSession(cookie.Value)
+	if err != nil {
+		return ""
+	}
+	return did
+}
+
+func (m *ModerationHandler) GetLabelerInfo(w http.ResponseWriter, r *http.Request) {
+	serviceDID := config.Get().ServiceDID
+
+	type LabelDefinition struct {
+		Identifier  string `json:"identifier"`
+		Severity    string `json:"severity"`
+		Blurs       string `json:"blurs"`
+		Description string `json:"description"`
+	}
+
+	labels := []LabelDefinition{
+		{Identifier: "sexual", Severity: "inform", Blurs: "content", Description: "Sexual content"},
+		{Identifier: "nudity", Severity: "inform", Blurs: "content", Description: "Nudity"},
+		{Identifier: "violence", Severity: "inform", Blurs: "content", Description: "Violence"},
+		{Identifier: "gore", Severity: "alert", Blurs: "content", Description: "Graphic/gory content"},
+		{Identifier: "spam", Severity: "inform", Blurs: "content", Description: "Spam or unwanted content"},
+		{Identifier: "misleading", Severity: "inform", Blurs: "content", Description: "Misleading information"},
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"did":    serviceDID,
+		"name":   "Margin Moderation",
+		"labels": labels,
+	})
+}

backend/internal/api/preferences.go

···
 package api
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 
+	"margin.at/internal/config"
 	"margin.at/internal/db"
 	"margin.at/internal/xrpc"
 )
 
+type LabelerSubscription struct {
+	DID string `json:"did"`
+}
+
+type LabelPreference struct {
+	LabelerDID string `json:"labelerDid"`
+	Label      string `json:"label"`
+	Visibility string `json:"visibility"`
+}
+
 type PreferencesResponse struct {
-	ExternalLinkSkippedHostnames []string `json:"externalLinkSkippedHostnames"`
+	ExternalLinkSkippedHostnames []string              `json:"externalLinkSkippedHostnames"`
+	SubscribedLabelers           []LabelerSubscription  `json:"subscribedLabelers"`
+	LabelPreferences             []LabelPreference      `json:"labelPreferences"`
 }
 
 func (h *Handler) GetPreferences(w http.ResponseWriter, r *http.Request) {
···
 		json.Unmarshal([]byte(*prefs.ExternalLinkSkippedHostnames), &hostnames)
 	}
 
+	var labelers []LabelerSubscription
+	if prefs != nil && prefs.SubscribedLabelers != nil {
+		json.Unmarshal([]byte(*prefs.SubscribedLabelers), &labelers)
+	}
+	if labelers == nil {
+		labelers = []LabelerSubscription{}
+		serviceDID := config.Get().ServiceDID
+		if serviceDID != "" {
+			labelers = append(labelers, LabelerSubscription{DID: serviceDID})
+		}
+	}
+
+	var labelPrefs []LabelPreference
+	if prefs != nil && prefs.LabelPreferences != nil {
+		json.Unmarshal([]byte(*prefs.LabelPreferences), &labelPrefs)
+	}
+	if labelPrefs == nil {
+		labelPrefs = []LabelPreference{}
+	}
+
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(PreferencesResponse{
 		ExternalLinkSkippedHostnames: hostnames,
+		SubscribedLabelers:           labelers,
+		LabelPreferences:             labelPrefs,
 	})
 }
 
···
 		return
 	}
 
-	record := xrpc.NewPreferencesRecord(input.ExternalLinkSkippedHostnames)
+	var xrpcLabelers []xrpc.LabelerSubscription
+	for _, l := range input.SubscribedLabelers {
+		xrpcLabelers = append(xrpcLabelers, xrpc.LabelerSubscription{DID: l.DID})
+	}
+	var xrpcLabelPrefs []xrpc.LabelPreference
+	for _, lp := range input.LabelPreferences {
+		xrpcLabelPrefs = append(xrpcLabelPrefs, xrpc.LabelPreference{
+			LabelerDID: lp.LabelerDID,
+			Label:      lp.Label,
+			Visibility: lp.Visibility,
+		})
+	}
+
+	record := xrpc.NewPreferencesRecord(input.ExternalLinkSkippedHostnames, xrpcLabelers, xrpcLabelPrefs)
 	if err := record.Validate(); err != nil {
 		http.Error(w, fmt.Sprintf("Invalid record: %v", err), http.StatusBadRequest)
 		return
 	}
 
-	err = h.refresher.ExecuteWithAutoRefresh(r, session, func(client *xrpc.Client, _ string) error {
-		url := fmt.Sprintf("%s/xrpc/com.atproto.repo.putRecord", client.PDS)
-
-		body := map[string]interface{}{
-			"repo":       session.DID,
-			"collection": xrpc.CollectionPreferences,
-			"rkey":       "self",
-			"record":     record,
-		}
-
-		jsonBody, err := json.Marshal(body)
-		if err != nil {
-			return err
-		}
-
-		req, err := http.NewRequestWithContext(r.Context(), "POST", url, bytes.NewBuffer(jsonBody))
-		if err != nil {
-			return err
-		}
-		req.Header.Set("Authorization", "Bearer "+client.AccessToken)
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := http.DefaultClient.Do(req)
-		if err != nil {
-			return err
-		}
-		defer resp.Body.Close()
-
-		if resp.StatusCode != 200 {
-			var errResp struct {
-				Error   string `json:"error"`
-				Message string `json:"message"`
-			}
-			json.NewDecoder(resp.Body).Decode(&errResp)
-			return fmt.Errorf("XRPC error %d: %s - %s", resp.StatusCode, errResp.Error, errResp.Message)
-		}
-
-		return nil
+	err = h.refresher.ExecuteWithAutoRefresh(r, session, func(client *xrpc.Client, did string) error {
+		_, err := client.PutRecord(r.Context(), did, xrpc.CollectionPreferences, "self", record)
+		return err
 	})
 
 	if err != nil {
+		fmt.Printf("[UpdatePreferences] PDS write failed: %v\n", err)
 		http.Error(w, fmt.Sprintf("Failed to update preferences: %v", err), http.StatusInternalServerError)
 		return
 	}
···
 	createdAt, _ := time.Parse(time.RFC3339, record.CreatedAt)
 	hostnamesJSON, _ := json.Marshal(input.ExternalLinkSkippedHostnames)
 	hostnamesStr := string(hostnamesJSON)
+
+	var subscribedLabelersPtr, labelPrefsPtr *string
+	if len(input.SubscribedLabelers) > 0 {
+		labelersJSON, _ := json.Marshal(input.SubscribedLabelers)
+		s := string(labelersJSON)
+		subscribedLabelersPtr = &s
+	}
+	if len(input.LabelPreferences) > 0 {
+		prefsJSON, _ := json.Marshal(input.LabelPreferences)
+		s := string(prefsJSON)
+		labelPrefsPtr = &s
+	}
+
 	uri := fmt.Sprintf("at://%s/%s/self", session.DID, xrpc.CollectionPreferences)
 
 	err = h.db.UpsertPreferences(&db.Preferences{
 		URI:                          uri,
 		AuthorDID:                    session.DID,
 		ExternalLinkSkippedHostnames: &hostnamesStr,
+		SubscribedLabelers:           subscribedLabelersPtr,
+		LabelPreferences:             labelPrefsPtr,
 		CreatedAt:                    createdAt,
 		IndexedAt:                    time.Now(),
 	})

backend/internal/api/profile.go

···
 
 	"github.com/go-chi/chi/v5"
 
+	"margin.at/internal/config"
 	"margin.at/internal/db"
 	"margin.at/internal/xrpc"
 )
···
 		Links       []string `json:"links"`
 		CreatedAt   string   `json:"createdAt"`
 		IndexedAt   string   `json:"indexedAt"`
+		Labels      []struct {
+			Val string `json:"val"`
+			Src string `json:"src"`
+		} `json:"labels,omitempty"`
+		Viewer *struct {
+			Blocking  bool `json:"blocking"`
+			Muting    bool `json:"muting"`
+			BlockedBy bool `json:"blockedBy"`
+		} `json:"viewer,omitempty"`
 	}{
 		URI:       profile.URI,
 		DID:       profile.AuthorDID,
···
 	}
 	if resp.Links == nil {
 		resp.Links = []string{}
+	}
+
+	viewerDID := h.getViewerDID(r)
+	if viewerDID != "" && viewerDID != profile.AuthorDID {
+		blocking, muting, blockedBy, err := h.db.GetViewerRelationship(viewerDID, profile.AuthorDID)
+		if err == nil {
+			resp.Viewer = &struct {
+				Blocking  bool `json:"blocking"`
+				Muting    bool `json:"muting"`
+				BlockedBy bool `json:"blockedBy"`
+			}{
+				Blocking:  blocking,
+				Muting:    muting,
+				BlockedBy: blockedBy,
+			}
+		}
+	}
+
+	subscribedLabelers := getSubscribedLabelers(h.db, viewerDID)
+	if subscribedLabelers == nil {
+		serviceDID := config.Get().ServiceDID
+		if serviceDID != "" {
+			subscribedLabelers = []string{serviceDID}
+		}
+	}
+	if didLabels, err := h.db.GetContentLabelsForDIDs([]string{profile.AuthorDID}, subscribedLabelers); err == nil {
+		if labels, ok := didLabels[profile.AuthorDID]; ok {
+			for _, l := range labels {
+				resp.Labels = append(resp.Labels, struct {
+					Val string `json:"val"`
+					Src string `json:"src"`
+				}{Val: l.Val, Src: l.Src})
+			}
+		}
 	}
 
 	w.Header().Set("Content-Type", "application/json")

backend/internal/config/config.go

···
 
 import (
 	"os"
+	"strings"
 	"sync"
 )
 
···
 	BskyPublicAPI string
 	PLCDirectory  string
 	BaseURL       string
+	AdminDIDs     []string
+	ServiceDID    string
 }
 
 var (
···
 
 func Get() *Config {
 	once.Do(func() {
+		adminDIDs := []string{}
+		if raw := os.Getenv("ADMIN_DIDS"); raw != "" {
+			for _, did := range strings.Split(raw, ",") {
+				did = strings.TrimSpace(did)
+				if did != "" {
+					adminDIDs = append(adminDIDs, did)
+				}
+			}
+		}
 		instance = &Config{
 			BskyPublicAPI: getEnvOrDefault("BSKY_PUBLIC_API", "https://public.api.bsky.app"),
 			PLCDirectory:  getEnvOrDefault("PLC_DIRECTORY_URL", "https://plc.directory"),
 			BaseURL:       os.Getenv("BASE_URL"),
+			AdminDIDs:     adminDIDs,
+			ServiceDID:    os.Getenv("SERVICE_DID"),
 		}
 	})
 	return instance
···
 func (c *Config) PLCResolveURL(did string) string {
 	return c.PLCDirectory + "/" + did
 }
+
+func (c *Config) IsAdmin(did string) bool {
+	for _, adminDID := range c.AdminDIDs {
+		if adminDID == did {
+			return true
+		}
+	}
+	return false
+}

backend/internal/db/db.go

···
 	URI                          string    `json:"uri"`
 	AuthorDID                    string    `json:"authorDid"`
 	ExternalLinkSkippedHostnames *string   `json:"externalLinkSkippedHostnames,omitempty"`
+	SubscribedLabelers           *string   `json:"subscribedLabelers,omitempty"`
+	LabelPreferences             *string   `json:"labelPreferences,omitempty"`
 	CreatedAt                    time.Time `json:"createdAt"`
 	IndexedAt                    time.Time `json:"indexedAt"`
 	CID                          *string   `json:"cid,omitempty"`
+}
+
+type Block struct {
+	ID         int       `json:"id"`
+	ActorDID   string    `json:"actorDid"`
+	SubjectDID string    `json:"subjectDid"`
+	CreatedAt  time.Time `json:"createdAt"`
+}
+
+type Mute struct {
+	ID         int       `json:"id"`
+	ActorDID   string    `json:"actorDid"`
+	SubjectDID string    `json:"subjectDid"`
+	CreatedAt  time.Time `json:"createdAt"`
+}
+
+type ModerationReport struct {
+	ID           int        `json:"id"`
+	ReporterDID  string     `json:"reporterDid"`
+	SubjectDID   string     `json:"subjectDid"`
+	SubjectURI   *string    `json:"subjectUri,omitempty"`
+	ReasonType   string     `json:"reasonType"`
+	ReasonText   *string    `json:"reasonText,omitempty"`
+	Status       string     `json:"status"`
+	CreatedAt    time.Time  `json:"createdAt"`
+	ResolvedAt   *time.Time `json:"resolvedAt,omitempty"`
+	ResolvedBy   *string    `json:"resolvedBy,omitempty"`
+}
+
+type ModerationAction struct {
+	ID         int       `json:"id"`
+	ReportID   int       `json:"reportId"`
+	ActorDID   string    `json:"actorDid"`
+	Action     string    `json:"action"`
+	Comment    *string   `json:"comment,omitempty"`
+	CreatedAt  time.Time `json:"createdAt"`
+}
+
+type ContentLabel struct {
+	ID        int       `json:"id"`
+	Src       string    `json:"src"`
+	URI       string    `json:"uri"`
+	Val       string    `json:"val"`
+	Neg       bool      `json:"neg"`
+	CreatedBy string    `json:"createdBy"`
+	CreatedAt time.Time `json:"createdAt"`
 }
 
 func New(dsn string) (*DB, error) {
···
 		updated_at ` + dateType + ` NOT NULL
 	)`)
 
+	db.Exec(`CREATE TABLE IF NOT EXISTS blocks (
+		id ` + autoInc + `,
+		actor_did TEXT NOT NULL,
+		subject_did TEXT NOT NULL,
+		created_at ` + dateType + ` NOT NULL,
+		UNIQUE(actor_did, subject_did)
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_blocks_actor ON blocks(actor_did)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_blocks_subject ON blocks(subject_did)`)
+
+	db.Exec(`CREATE TABLE IF NOT EXISTS mutes (
+		id ` + autoInc + `,
+		actor_did TEXT NOT NULL,
+		subject_did TEXT NOT NULL,
+		created_at ` + dateType + ` NOT NULL,
+		UNIQUE(actor_did, subject_did)
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mutes_actor ON mutes(actor_did)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mutes_subject ON mutes(subject_did)`)
+
+	db.Exec(`CREATE TABLE IF NOT EXISTS moderation_reports (
+		id ` + autoInc + `,
+		reporter_did TEXT NOT NULL,
+		subject_did TEXT NOT NULL,
+		subject_uri TEXT,
+		reason_type TEXT NOT NULL,
+		reason_text TEXT,
+		status TEXT NOT NULL DEFAULT 'pending',
+		created_at ` + dateType + ` NOT NULL,
+		resolved_at ` + dateType + `,
+		resolved_by TEXT
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_status ON moderation_reports(status)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_subject ON moderation_reports(subject_did)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_reporter ON moderation_reports(reporter_did)`)
+
+	db.Exec(`CREATE TABLE IF NOT EXISTS moderation_actions (
+		id ` + autoInc + `,
+		report_id INTEGER NOT NULL,
+		actor_did TEXT NOT NULL,
+		action TEXT NOT NULL,
+		comment TEXT,
+		created_at ` + dateType + ` NOT NULL
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_actions_report ON moderation_actions(report_id)`)
+
+	db.Exec(`CREATE TABLE IF NOT EXISTS content_labels (
+		id ` + autoInc + `,
+		src TEXT NOT NULL,
+		uri TEXT NOT NULL,
+		val TEXT NOT NULL,
+		neg INTEGER NOT NULL DEFAULT 0,
+		created_by TEXT NOT NULL,
+		created_at ` + dateType + ` NOT NULL
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_content_labels_uri ON content_labels(uri)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_content_labels_src ON content_labels(src)`)
+
 	db.runMigrations()
 
 	return nil
···
 
 func (db *DB) GetPreferences(did string) (*Preferences, error) {
 	var p Preferences
-	err := db.QueryRow("SELECT uri, author_did, external_link_skipped_hostnames, created_at, indexed_at, cid FROM preferences WHERE author_did = $1", did).Scan(
-		&p.URI, &p.AuthorDID, &p.ExternalLinkSkippedHostnames, &p.CreatedAt, &p.IndexedAt, &p.CID,
+	err := db.QueryRow("SELECT uri, author_did, external_link_skipped_hostnames, subscribed_labelers, label_preferences, created_at, indexed_at, cid FROM preferences WHERE author_did = $1", did).Scan(
+		&p.URI, &p.AuthorDID, &p.ExternalLinkSkippedHostnames, &p.SubscribedLabelers, &p.LabelPreferences, &p.CreatedAt, &p.IndexedAt, &p.CID,
 	)
 	if err == sql.ErrNoRows {
 		return nil, nil
···
 
 func (db *DB) UpsertPreferences(p *Preferences) error {
 	query := `
-		INSERT INTO preferences (uri, author_did, external_link_skipped_hostnames, created_at, indexed_at, cid) 
-		VALUES ($1, $2, $3, $4, $5, $6) 
+		INSERT INTO preferences (uri, author_did, external_link_skipped_hostnames, subscribed_labelers, label_preferences, created_at, indexed_at, cid) 
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
 		ON CONFLICT(uri) DO UPDATE SET 
 			external_link_skipped_hostnames = EXCLUDED.external_link_skipped_hostnames,
+			subscribed_labelers = EXCLUDED.subscribed_labelers,
+			label_preferences = EXCLUDED.label_preferences,
 			indexed_at = EXCLUDED.indexed_at,
 			cid = EXCLUDED.cid
 	`
-	_, err := db.Exec(db.Rebind(query), p.URI, p.AuthorDID, p.ExternalLinkSkippedHostnames, p.CreatedAt, p.IndexedAt, p.CID)
+	_, err := db.Exec(db.Rebind(query), p.URI, p.AuthorDID, p.ExternalLinkSkippedHostnames, p.SubscribedLabelers, p.LabelPreferences, p.CreatedAt, p.IndexedAt, p.CID)
 	return err
 }
 
+func (db *DB) DeleteAPIKeyByURI(uri string) error {
+	_, err := db.Exec("DELETE FROM api_keys WHERE uri = $1", uri)
+	return err
+}
+
+func (db *DB) DeletePreferences(uri string) error {
+	_, err := db.Exec("DELETE FROM preferences WHERE uri = $1", uri)
+	return err
+}
+
+func (db *DB) GetAPIKeyURIs(ownerDID string) ([]string, error) {
+	rows, err := db.Query(db.Rebind("SELECT uri FROM api_keys WHERE owner_did = ? AND uri IS NOT NULL AND uri != ''"), ownerDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var uris []string
+	for rows.Next() {
+		var uri string
+		if err := rows.Scan(&uri); err != nil {
+			return nil, err
+		}
+		uris = append(uris, uri)
+	}
+	return uris, nil
+}
+
+func (db *DB) GetPreferenceURIs(did string) ([]string, error) {
+	rows, err := db.Query(db.Rebind("SELECT uri FROM preferences WHERE author_did = ? AND uri IS NOT NULL AND uri != ''"), did)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var uris []string
+	for rows.Next() {
+		var uri string
+		if err := rows.Scan(&uri); err != nil {
+			return nil, err
+		}
+		uris = append(uris, uri)
+	}
+	return uris, nil
+}
+
 func (db *DB) runMigrations() {
 	dateType := "DATETIME"
 	if db.driver == "postgres" {
···
 	db.Exec(`ALTER TABLE api_keys ADD COLUMN uri TEXT`)
 	db.Exec(`ALTER TABLE api_keys ADD COLUMN cid TEXT`)
 	db.Exec(`ALTER TABLE api_keys ADD COLUMN indexed_at ` + dateType + ` DEFAULT CURRENT_TIMESTAMP`)
+
+	db.migrateModeration(dateType)
+
+	db.Exec(`ALTER TABLE preferences ADD COLUMN subscribed_labelers TEXT`)
+	db.Exec(`ALTER TABLE preferences ADD COLUMN label_preferences TEXT`)
+}
+
+func (db *DB) migrateModeration(dateType string) {
+	_, err := db.Exec(`SELECT subject_did FROM moderation_reports LIMIT 0`)
+	if err != nil {
+		db.Exec(`DROP TABLE IF EXISTS moderation_reports`)
+		db.Exec(`DROP TABLE IF EXISTS moderation_actions`)
+
+		autoInc := "INTEGER PRIMARY KEY AUTOINCREMENT"
+		if db.driver == "postgres" {
+			autoInc = "SERIAL PRIMARY KEY"
+		}
+
+		db.Exec(`CREATE TABLE IF NOT EXISTS moderation_reports (
+			id ` + autoInc + `,
+			reporter_did TEXT NOT NULL,
+			subject_did TEXT NOT NULL,
+			subject_uri TEXT,
+			reason_type TEXT NOT NULL,
+			reason_text TEXT,
+			status TEXT NOT NULL DEFAULT 'pending',
+			created_at ` + dateType + ` NOT NULL,
+			resolved_at ` + dateType + `,
+			resolved_by TEXT
+		)`)
+		db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_status ON moderation_reports(status)`)
+		db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_subject ON moderation_reports(subject_did)`)
+		db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_reports_reporter ON moderation_reports(reporter_did)`)
+
+		db.Exec(`CREATE TABLE IF NOT EXISTS moderation_actions (
+			id ` + autoInc + `,
+			report_id INTEGER NOT NULL,
+			actor_did TEXT NOT NULL,
+			action TEXT NOT NULL,
+			comment TEXT,
+			created_at ` + dateType + ` NOT NULL
+		)`)
+		db.Exec(`CREATE INDEX IF NOT EXISTS idx_mod_actions_report ON moderation_actions(report_id)`)
+	}
+
+	autoInc := "INTEGER PRIMARY KEY AUTOINCREMENT"
+	if db.driver == "postgres" {
+		autoInc = "SERIAL PRIMARY KEY"
+	}
+	db.Exec(`CREATE TABLE IF NOT EXISTS content_labels (
+		id ` + autoInc + `,
+		src TEXT NOT NULL,
+		uri TEXT NOT NULL,
+		val TEXT NOT NULL,
+		neg INTEGER NOT NULL DEFAULT 0,
+		created_by TEXT NOT NULL,
+		created_at ` + dateType + ` NOT NULL
+	)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_content_labels_uri ON content_labels(uri)`)
+	db.Exec(`CREATE INDEX IF NOT EXISTS idx_content_labels_src ON content_labels(src)`)
 }
 
 func (db *DB) Close() error {

backend/internal/db/queries_keys.go

···
 	_, err := db.Exec(db.Rebind(`
 		INSERT INTO api_keys (id, owner_did, name, key_hash, created_at, uri, cid)
 		VALUES (?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT (id) DO UPDATE SET
+			name = EXCLUDED.name,
+			key_hash = EXCLUDED.key_hash,
+			uri = EXCLUDED.uri,
+			cid = EXCLUDED.cid
 	`), key.ID, key.OwnerDID, key.Name, key.KeyHash, key.CreatedAt, key.URI, key.CID)
 	return err
 }

backend/internal/db/queries_moderation.go

···
+package db
+
+import "time"
+
+
+func (db *DB) CreateBlock(actorDID, subjectDID string) error {
+	query := `INSERT INTO blocks (actor_did, subject_did, created_at) VALUES (?, ?, ?)
+		ON CONFLICT(actor_did, subject_did) DO NOTHING`
+	_, err := db.Exec(db.Rebind(query), actorDID, subjectDID, time.Now())
+	return err
+}
+
+func (db *DB) DeleteBlock(actorDID, subjectDID string) error {
+	_, err := db.Exec(db.Rebind(`DELETE FROM blocks WHERE actor_did = ? AND subject_did = ?`), actorDID, subjectDID)
+	return err
+}
+
+func (db *DB) GetBlocks(actorDID string) ([]Block, error) {
+	rows, err := db.Query(db.Rebind(`SELECT id, actor_did, subject_did, created_at FROM blocks WHERE actor_did = ? ORDER BY created_at DESC`), actorDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var blocks []Block
+	for rows.Next() {
+		var b Block
+		if err := rows.Scan(&b.ID, &b.ActorDID, &b.SubjectDID, &b.CreatedAt); err != nil {
+			continue
+		}
+		blocks = append(blocks, b)
+	}
+	return blocks, nil
+}
+
+func (db *DB) IsBlocked(actorDID, subjectDID string) (bool, error) {
+	var count int
+	err := db.QueryRow(db.Rebind(`SELECT COUNT(*) FROM blocks WHERE actor_did = ? AND subject_did = ?`), actorDID, subjectDID).Scan(&count)
+	return count > 0, err
+}
+
+func (db *DB) IsBlockedEither(did1, did2 string) (bool, error) {
+	var count int
+	err := db.QueryRow(db.Rebind(`SELECT COUNT(*) FROM blocks WHERE (actor_did = ? AND subject_did = ?) OR (actor_did = ? AND subject_did = ?)`), did1, did2, did2, did1).Scan(&count)
+	return count > 0, err
+}
+
+func (db *DB) GetBlockedDIDs(actorDID string) ([]string, error) {
+	rows, err := db.Query(db.Rebind(`SELECT subject_did FROM blocks WHERE actor_did = ?`), actorDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var dids []string
+	for rows.Next() {
+		var did string
+		if err := rows.Scan(&did); err != nil {
+			continue
+		}
+		dids = append(dids, did)
+	}
+	return dids, nil
+}
+
+func (db *DB) GetBlockedByDIDs(actorDID string) ([]string, error) {
+	rows, err := db.Query(db.Rebind(`SELECT actor_did FROM blocks WHERE subject_did = ?`), actorDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var dids []string
+	for rows.Next() {
+		var did string
+		if err := rows.Scan(&did); err != nil {
+			continue
+		}
+		dids = append(dids, did)
+	}
+	return dids, nil
+}
+
+
+func (db *DB) CreateMute(actorDID, subjectDID string) error {
+	query := `INSERT INTO mutes (actor_did, subject_did, created_at) VALUES (?, ?, ?)
+		ON CONFLICT(actor_did, subject_did) DO NOTHING`
+	_, err := db.Exec(db.Rebind(query), actorDID, subjectDID, time.Now())
+	return err
+}
+
+func (db *DB) DeleteMute(actorDID, subjectDID string) error {
+	_, err := db.Exec(db.Rebind(`DELETE FROM mutes WHERE actor_did = ? AND subject_did = ?`), actorDID, subjectDID)
+	return err
+}
+
+func (db *DB) GetMutes(actorDID string) ([]Mute, error) {
+	rows, err := db.Query(db.Rebind(`SELECT id, actor_did, subject_did, created_at FROM mutes WHERE actor_did = ? ORDER BY created_at DESC`), actorDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var mutes []Mute
+	for rows.Next() {
+		var m Mute
+		if err := rows.Scan(&m.ID, &m.ActorDID, &m.SubjectDID, &m.CreatedAt); err != nil {
+			continue
+		}
+		mutes = append(mutes, m)
+	}
+	return mutes, nil
+}
+
+func (db *DB) IsMuted(actorDID, subjectDID string) (bool, error) {
+	var count int
+	err := db.QueryRow(db.Rebind(`SELECT COUNT(*) FROM mutes WHERE actor_did = ? AND subject_did = ?`), actorDID, subjectDID).Scan(&count)
+	return count > 0, err
+}
+
+func (db *DB) GetMutedDIDs(actorDID string) ([]string, error) {
+	rows, err := db.Query(db.Rebind(`SELECT subject_did FROM mutes WHERE actor_did = ?`), actorDID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var dids []string
+	for rows.Next() {
+		var did string
+		if err := rows.Scan(&did); err != nil {
+			continue
+		}
+		dids = append(dids, did)
+	}
+	return dids, nil
+}
+
+func (db *DB) GetAllHiddenDIDs(actorDID string) (map[string]bool, error) {
+	hidden := make(map[string]bool)
+	if actorDID == "" {
+		return hidden, nil
+	}
+
+	blocked, err := db.GetBlockedDIDs(actorDID)
+	if err != nil {
+		return hidden, err
+	}
+	for _, did := range blocked {
+		hidden[did] = true
+	}
+
+	blockedBy, err := db.GetBlockedByDIDs(actorDID)
+	if err != nil {
+		return hidden, err
+	}
+	for _, did := range blockedBy {
+		hidden[did] = true
+	}
+
+	muted, err := db.GetMutedDIDs(actorDID)
+	if err != nil {
+		return hidden, err
+	}
+	for _, did := range muted {
+		hidden[did] = true
+	}
+
+	return hidden, nil
+}
+
+func (db *DB) GetViewerRelationship(viewerDID, subjectDID string) (blocked bool, muted bool, blockedBy bool, err error) {
+	if viewerDID == "" || subjectDID == "" {
+		return false, false, false, nil
+	}
+
+	blocked, err = db.IsBlocked(viewerDID, subjectDID)
+	if err != nil {
+		return
+	}
+
+	muted, err = db.IsMuted(viewerDID, subjectDID)
+	if err != nil {
+		return
+	}
+
+	blockedBy, err = db.IsBlocked(subjectDID, viewerDID)
+	return
+}
+
+
+func (db *DB) CreateReport(reporterDID, subjectDID string, subjectURI *string, reasonType string, reasonText *string) (int, error) {
+	query := `INSERT INTO moderation_reports (reporter_did, subject_did, subject_uri, reason_type, reason_text, status, created_at)
+		VALUES (?, ?, ?, ?, ?, 'pending', ?)`
+
+	result, err := db.Exec(db.Rebind(query), reporterDID, subjectDID, subjectURI, reasonType, reasonText, time.Now())
+	if err != nil {
+		return 0, err
+	}
+
+	id, err := result.LastInsertId()
+	return int(id), err
+}
+
+func (db *DB) GetReports(status string, limit, offset int) ([]ModerationReport, error) {
+	query := `SELECT id, reporter_did, subject_did, subject_uri, reason_type, reason_text, status, created_at, resolved_at, resolved_by
+		FROM moderation_reports`
+	args := []interface{}{}
+
+	if status != "" {
+		query += ` WHERE status = ?`
+		args = append(args, status)
+	}
+
+	query += ` ORDER BY created_at DESC LIMIT ? OFFSET ?`
+	args = append(args, limit, offset)
+
+	rows, err := db.Query(db.Rebind(query), args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var reports []ModerationReport
+	for rows.Next() {
+		var r ModerationReport
+		if err := rows.Scan(&r.ID, &r.ReporterDID, &r.SubjectDID, &r.SubjectURI, &r.ReasonType, &r.ReasonText, &r.Status, &r.CreatedAt, &r.ResolvedAt, &r.ResolvedBy); err != nil {
+			continue
+		}
+		reports = append(reports, r)
+	}
+	return reports, nil
+}
+
+func (db *DB) GetReport(id int) (*ModerationReport, error) {
+	var r ModerationReport
+	err := db.QueryRow(db.Rebind(`SELECT id, reporter_did, subject_did, subject_uri, reason_type, reason_text, status, created_at, resolved_at, resolved_by FROM moderation_reports WHERE id = ?`), id).Scan(
+		&r.ID, &r.ReporterDID, &r.SubjectDID, &r.SubjectURI, &r.ReasonType, &r.ReasonText, &r.Status, &r.CreatedAt, &r.ResolvedAt, &r.ResolvedBy,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &r, nil
+}
+
+func (db *DB) ResolveReport(id int, resolvedBy string, status string) error {
+	_, err := db.Exec(db.Rebind(`UPDATE moderation_reports SET status = ?, resolved_at = ?, resolved_by = ? WHERE id = ?`), status, time.Now(), resolvedBy, id)
+	return err
+}
+
+func (db *DB) CreateModerationAction(reportID int, actorDID, action string, comment *string) error {
+	query := `INSERT INTO moderation_actions (report_id, actor_did, action, comment, created_at) VALUES (?, ?, ?, ?, ?)`
+	_, err := db.Exec(db.Rebind(query), reportID, actorDID, action, comment, time.Now())
+	return err
+}
+
+func (db *DB) GetReportActions(reportID int) ([]ModerationAction, error) {
+	rows, err := db.Query(db.Rebind(`SELECT id, report_id, actor_did, action, comment, created_at FROM moderation_actions WHERE report_id = ? ORDER BY created_at DESC`), reportID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var actions []ModerationAction
+	for rows.Next() {
+		var a ModerationAction
+		if err := rows.Scan(&a.ID, &a.ReportID, &a.ActorDID, &a.Action, &a.Comment, &a.CreatedAt); err != nil {
+			continue
+		}
+		actions = append(actions, a)
+	}
+	return actions, nil
+}
+
+func (db *DB) GetReportCount(status string) (int, error) {
+	query := `SELECT COUNT(*) FROM moderation_reports`
+	args := []interface{}{}
+	if status != "" {
+		query += ` WHERE status = ?`
+		args = append(args, status)
+	}
+	var count int
+	err := db.QueryRow(db.Rebind(query), args...).Scan(&count)
+	return count, err
+}
+
+
+func (db *DB) CreateContentLabel(src, uri, val, createdBy string) error {
+	query := `INSERT INTO content_labels (src, uri, val, neg, created_by, created_at) VALUES (?, ?, ?, 0, ?, ?)`
+	_, err := db.Exec(db.Rebind(query), src, uri, val, createdBy, time.Now())
+	return err
+}
+
+func (db *DB) SyncSelfLabels(authorDID, uri string, labels []string) error {
+	_, err := db.Exec(db.Rebind(`DELETE FROM content_labels WHERE src = ? AND uri = ? AND created_by = ?`), authorDID, uri, authorDID)
+	if err != nil {
+		return err
+	}
+	for _, val := range labels {
+		if err := db.CreateContentLabel(authorDID, uri, val, authorDID); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (db *DB) NegateContentLabel(id int) error {
+	_, err := db.Exec(db.Rebind(`UPDATE content_labels SET neg = 1 WHERE id = ?`), id)
+	return err
+}
+
+func (db *DB) DeleteContentLabel(id int) error {
+	_, err := db.Exec(db.Rebind(`DELETE FROM content_labels WHERE id = ?`), id)
+	return err
+}
+
+func (db *DB) GetContentLabelsForURIs(uris []string, labelerDIDs []string) (map[string][]ContentLabel, error) {
+	result := make(map[string][]ContentLabel)
+	if len(uris) == 0 {
+		return result, nil
+	}
+
+	placeholders := make([]string, len(uris))
+	args := make([]interface{}, len(uris))
+	for i, uri := range uris {
+		placeholders[i] = "?"
+		args[i] = uri
+	}
+
+	query := `SELECT id, src, uri, val, neg, created_by, created_at FROM content_labels
+		WHERE uri IN (` + joinStrings(placeholders, ",") + `) AND neg = 0`
+
+	if len(labelerDIDs) > 0 {
+		srcPlaceholders := make([]string, len(labelerDIDs))
+		for i, did := range labelerDIDs {
+			srcPlaceholders[i] = "?"
+			args = append(args, did)
+		}
+		query += ` AND src IN (` + joinStrings(srcPlaceholders, ",") + `)`
+	}
+
+	query += ` ORDER BY created_at DESC`
+
+	rows, err := db.Query(db.Rebind(query), args...)
+	if err != nil {
+		return result, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var l ContentLabel
+		if err := rows.Scan(&l.ID, &l.Src, &l.URI, &l.Val, &l.Neg, &l.CreatedBy, &l.CreatedAt); err != nil {
+			continue
+		}
+		result[l.URI] = append(result[l.URI], l)
+	}
+	return result, nil
+}
+
+func (db *DB) GetContentLabelsForDIDs(dids []string, labelerDIDs []string) (map[string][]ContentLabel, error) {
+	result := make(map[string][]ContentLabel)
+	if len(dids) == 0 {
+		return result, nil
+	}
+
+	placeholders := make([]string, len(dids))
+	args := make([]interface{}, len(dids))
+	for i, did := range dids {
+		placeholders[i] = "?"
+		args[i] = did
+	}
+
+	query := `SELECT id, src, uri, val, neg, created_by, created_at FROM content_labels
+		WHERE uri IN (` + joinStrings(placeholders, ",") + `) AND neg = 0`
+
+	if len(labelerDIDs) > 0 {
+		srcPlaceholders := make([]string, len(labelerDIDs))
+		for i, did := range labelerDIDs {
+			srcPlaceholders[i] = "?"
+			args = append(args, did)
+		}
+		query += ` AND src IN (` + joinStrings(srcPlaceholders, ",") + `)`
+	}
+
+	query += ` ORDER BY created_at DESC`
+
+	rows, err := db.Query(db.Rebind(query), args...)
+	if err != nil {
+		return result, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var l ContentLabel
+		if err := rows.Scan(&l.ID, &l.Src, &l.URI, &l.Val, &l.Neg, &l.CreatedBy, &l.CreatedAt); err != nil {
+			continue
+		}
+		result[l.URI] = append(result[l.URI], l)
+	}
+	return result, nil
+}
+
+func (db *DB) GetAllContentLabels(limit, offset int) ([]ContentLabel, error) {
+	rows, err := db.Query(db.Rebind(`SELECT id, src, uri, val, neg, created_by, created_at FROM content_labels ORDER BY created_at DESC LIMIT ? OFFSET ?`), limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var labels []ContentLabel
+	for rows.Next() {
+		var l ContentLabel
+		if err := rows.Scan(&l.ID, &l.Src, &l.URI, &l.Val, &l.Neg, &l.CreatedBy, &l.CreatedAt); err != nil {
+			continue
+		}
+		labels = append(labels, l)
+	}
+	return labels, nil
+}
+
+func joinStrings(strs []string, sep string) string {
+	result := ""
+	for i, s := range strs {
+		if i > 0 {
+			result += sep
+		}
+		result += s
+	}
+	return result
+}

backend/internal/firehose/ingester.go

···
 	CollectionCollection       = "at.margin.collection"
 	CollectionCollectionItem   = "at.margin.collectionItem"
 	CollectionProfile          = "at.margin.profile"
+	CollectionAPIKey           = "at.margin.apikey"
+	CollectionPreferences      = "at.margin.preferences"
 	CollectionSembleCard       = "network.cosmik.card"
 	CollectionSembleCollection = "network.cosmik.collection"
 )
···
 	i.RegisterHandler(CollectionCollection, i.handleCollection)
 	i.RegisterHandler(CollectionCollectionItem, i.handleCollectionItem)
 	i.RegisterHandler(CollectionProfile, i.handleProfile)
+	i.RegisterHandler(CollectionAPIKey, i.handleAPIKey)
+	i.RegisterHandler(CollectionPreferences, i.handlePreferences)
 	i.RegisterHandler(CollectionSembleCard, i.handleSembleCard)
 	i.RegisterHandler(CollectionSembleCollection, i.handleSembleCollection)
 	i.RegisterHandler(xrpc.CollectionSembleCollectionLink, i.handleSembleCollectionLink)
···
 		i.db.RemoveFromCollection(uri)
 	case CollectionProfile:
 		i.db.DeleteProfile(uri)
+	case CollectionAPIKey:
+		i.db.DeleteAPIKeyByURI(uri)
+	case CollectionPreferences:
+		i.db.DeletePreferences(uri)
 	case CollectionSembleCard:
 		i.db.DeleteAnnotation(uri)
 		i.db.DeleteBookmark(uri)
···
 		log.Printf("Failed to index profile: %v", err)
 	} else {
 		log.Printf("Indexed profile from %s", event.Repo)
+	}
+}
+
+func (i *Ingester) handleAPIKey(event *FirehoseEvent) {
+	var record struct {
+		Name      string `json:"name"`
+		KeyHash   string `json:"keyHash"`
+		CreatedAt string `json:"createdAt"`
+	}
+
+	if err := json.Unmarshal(event.Record, &record); err != nil {
+		return
+	}
+
+	uri := fmt.Sprintf("at://%s/%s/%s", event.Repo, event.Collection, event.Rkey)
+
+	createdAt, err := time.Parse(time.RFC3339, record.CreatedAt)
+	if err != nil {
+		createdAt = time.Now()
+	}
+
+	var cidPtr *string
+	if event.CID != "" {
+		cidPtr = &event.CID
+	}
+
+	apiKey := &db.APIKey{
+		ID:        event.Rkey,
+		OwnerDID:  event.Repo,
+		Name:      record.Name,
+		KeyHash:   record.KeyHash,
+		CreatedAt: createdAt,
+		URI:       uri,
+		CID:       cidPtr,
+		IndexedAt: time.Now(),
+	}
+
+	if err := i.db.CreateAPIKey(apiKey); err != nil {
+		log.Printf("Failed to index API key: %v", err)
+	} else {
+		log.Printf("Indexed API key from %s: %s", event.Repo, record.Name)
+	}
+}
+
+func (i *Ingester) handlePreferences(event *FirehoseEvent) {
+	if event.Rkey != "self" {
+		return
+	}
+
+	var record struct {
+		ExternalLinkSkippedHostnames []string        `json:"externalLinkSkippedHostnames"`
+		SubscribedLabelers           json.RawMessage `json:"subscribedLabelers"`
+		LabelPreferences             json.RawMessage `json:"labelPreferences"`
+		CreatedAt                    string          `json:"createdAt"`
+	}
+
+	if err := json.Unmarshal(event.Record, &record); err != nil {
+		return
+	}
+
+	uri := fmt.Sprintf("at://%s/%s/%s", event.Repo, event.Collection, event.Rkey)
+
+	createdAt, err := time.Parse(time.RFC3339, record.CreatedAt)
+	if err != nil {
+		createdAt = time.Now()
+	}
+
+	var cidPtr *string
+	if event.CID != "" {
+		cidPtr = &event.CID
+	}
+
+	var skippedHostnamesPtr *string
+	if len(record.ExternalLinkSkippedHostnames) > 0 {
+		hostnamesBytes, _ := json.Marshal(record.ExternalLinkSkippedHostnames)
+		hostnamesStr := string(hostnamesBytes)
+		skippedHostnamesPtr = &hostnamesStr
+	}
+
+	var subscribedLabelersPtr *string
+	if len(record.SubscribedLabelers) > 0 && string(record.SubscribedLabelers) != "null" {
+		s := string(record.SubscribedLabelers)
+		subscribedLabelersPtr = &s
+	}
+
+	var labelPrefsPtr *string
+	if len(record.LabelPreferences) > 0 && string(record.LabelPreferences) != "null" {
+		s := string(record.LabelPreferences)
+		labelPrefsPtr = &s
+	}
+
+	prefs := &db.Preferences{
+		URI:                          uri,
+		AuthorDID:                    event.Repo,
+		ExternalLinkSkippedHostnames: skippedHostnamesPtr,
+		SubscribedLabelers:           subscribedLabelersPtr,
+		LabelPreferences:             labelPrefsPtr,
+		CreatedAt:                    createdAt,
+		IndexedAt:                    time.Now(),
+		CID:                          cidPtr,
+	}
+
+	if err := i.db.UpsertPreferences(prefs); err != nil {
+		log.Printf("Failed to index preferences: %v", err)
+	} else {
+		log.Printf("Indexed preferences from %s", event.Repo)
 	}
 }
 

backend/internal/sync/service.go

···
 		xrpc.CollectionLike,
 		xrpc.CollectionCollection,
 		xrpc.CollectionCollectionItem,
+		xrpc.CollectionAPIKey,
+		xrpc.CollectionPreferences,
 		xrpc.CollectionSembleCard,
 		xrpc.CollectionSembleCollection,
 		xrpc.CollectionSembleCollectionLink,
···
 				} else {
 					err = e
 				}
-			case xrpc.CollectionSembleCollectionLink:
+				case xrpc.CollectionAPIKey:
+					localURIs, err = s.db.GetAPIKeyURIs(did)
+					localURIs = filterURIsByCollection(localURIs, xrpc.CollectionAPIKey)
+				case xrpc.CollectionPreferences:
+					localURIs, err = s.db.GetPreferenceURIs(did)
+					localURIs = filterURIsByCollection(localURIs, xrpc.CollectionPreferences)
+				case xrpc.CollectionSembleCollectionLink:
 				items, e := s.db.GetCollectionItemsByAuthor(did)
 				if e == nil {
 					for _, item := range items {
···
 							_ = s.db.DeleteCollection(uri)
 						case xrpc.CollectionSembleCollectionLink:
 							_ = s.db.RemoveFromCollection(uri)
+						case xrpc.CollectionAPIKey:
+							_ = s.db.DeleteAPIKeyByURI(uri)
+						case xrpc.CollectionPreferences:
+							_ = s.db.DeletePreferences(uri)
 						}
 						deletedCount++
 					}
···
 			Position:      0,
 			CreatedAt:     createdAt,
 			IndexedAt:     time.Now(),
+		})
+
+	case xrpc.CollectionAPIKey:
+		var record xrpc.APIKeyRecord
+		if err := json.Unmarshal(value, &record); err != nil {
+			return err
+		}
+		createdAt, _ := time.Parse(time.RFC3339, record.CreatedAt)
+
+		parts := strings.Split(uri, "/")
+		rkey := parts[len(parts)-1]
+
+		return s.db.CreateAPIKey(&db.APIKey{
+			ID:        rkey,
+			OwnerDID:  did,
+			Name:      record.Name,
+			KeyHash:   record.KeyHash,
+			CreatedAt: createdAt,
+			URI:       uri,
+			CID:       cidPtr,
+			IndexedAt: time.Now(),
+		})
+
+	case xrpc.CollectionPreferences:
+		var record xrpc.PreferencesRecord
+		if err := json.Unmarshal(value, &record); err != nil {
+			return err
+		}
+		createdAt, _ := time.Parse(time.RFC3339, record.CreatedAt)
+
+		var skippedHostnamesPtr *string
+		if len(record.ExternalLinkSkippedHostnames) > 0 {
+			hostnamesBytes, _ := json.Marshal(record.ExternalLinkSkippedHostnames)
+			hostnamesStr := string(hostnamesBytes)
+			skippedHostnamesPtr = &hostnamesStr
+		}
+
+		var subscribedLabelersPtr *string
+		if len(record.SubscribedLabelers) > 0 {
+			labelersBytes, _ := json.Marshal(record.SubscribedLabelers)
+			s := string(labelersBytes)
+			subscribedLabelersPtr = &s
+		}
+
+		var labelPrefsPtr *string
+		if len(record.LabelPreferences) > 0 {
+			prefsBytes, _ := json.Marshal(record.LabelPreferences)
+			s := string(prefsBytes)
+			labelPrefsPtr = &s
+		}
+
+		return s.db.UpsertPreferences(&db.Preferences{
+			URI:                          uri,
+			AuthorDID:                    did,
+			ExternalLinkSkippedHostnames: skippedHostnamesPtr,
+			SubscribedLabelers:           subscribedLabelersPtr,
+			LabelPreferences:             labelPrefsPtr,
+			CreatedAt:                    createdAt,
+			IndexedAt:                    time.Now(),
+			CID:                          cidPtr,
 		})
 	}
 	return nil

backend/internal/xrpc/records.go

···
 	SelectorTypePosition = "TextPositionSelector"
 )
 
+type SelfLabel struct {
+	Val string `json:"val"`
+}
+
+type SelfLabels struct {
+	Type   string      `json:"$type"`
+	Values []SelfLabel `json:"values"`
+}
+
+func NewSelfLabels(vals []string) *SelfLabels {
+	if len(vals) == 0 {
+		return nil
+	}
+	labels := make([]SelfLabel, len(vals))
+	for i, v := range vals {
+		labels[i] = SelfLabel{Val: v}
+	}
+	return &SelfLabels{
+		Type:   "com.atproto.label.defs#selfLabels",
+		Values: labels,
+	}
+}
+
 type Selector struct {
 	Type string `json:"type"`
 }
···
 	Facets     []Facet          `json:"facets,omitempty"`
 	Generator  *Generator       `json:"generator,omitempty"`
 	Rights     string           `json:"rights,omitempty"`
+	Labels     *SelfLabels      `json:"labels,omitempty"`
 	CreatedAt  string           `json:"createdAt"`
 }
 
···
 	Tags      []string         `json:"tags,omitempty"`
 	Generator *Generator       `json:"generator,omitempty"`
 	Rights    string           `json:"rights,omitempty"`
+	Labels    *SelfLabels      `json:"labels,omitempty"`
 	CreatedAt string           `json:"createdAt"`
 }
 
···
 	Tags        []string   `json:"tags,omitempty"`
 	Generator   *Generator `json:"generator,omitempty"`
 	Rights      string     `json:"rights,omitempty"`
+	Labels      *SelfLabels `json:"labels,omitempty"`
 	CreatedAt   string     `json:"createdAt"`
 }
 
···
 	return nil
 }
 
+type LabelerSubscription struct {
+	DID string `json:"did"`
+}
+
+type LabelPreference struct {
+	LabelerDID string `json:"labelerDid"`
+	Label      string `json:"label"`
+	Visibility string `json:"visibility"`
+}
+
 type PreferencesRecord struct {
-	Type                         string   `json:"$type"`
-	ExternalLinkSkippedHostnames []string `json:"externalLinkSkippedHostnames,omitempty"`
-	CreatedAt                    string   `json:"createdAt"`
+	Type                         string                `json:"$type"`
+	ExternalLinkSkippedHostnames []string              `json:"externalLinkSkippedHostnames,omitempty"`
+	SubscribedLabelers           []LabelerSubscription  `json:"subscribedLabelers,omitempty"`
+	LabelPreferences             []LabelPreference      `json:"labelPreferences,omitempty"`
+	CreatedAt                    string                `json:"createdAt"`
 }
 
 func (r *PreferencesRecord) Validate() error {
···
 			return fmt.Errorf("hostname too long: %s", host)
 		}
 	}
+	if len(r.SubscribedLabelers) > 50 {
+		return fmt.Errorf("too many subscribed labelers")
+	}
+	if len(r.LabelPreferences) > 500 {
+		return fmt.Errorf("too many label preferences")
+	}
 	return nil
 }
 
-func NewPreferencesRecord(skippedHostnames []string) *PreferencesRecord {
-	return &PreferencesRecord{
+func NewPreferencesRecord(skippedHostnames []string, labelers interface{}, labelPrefs interface{}) *PreferencesRecord {
+	record := &PreferencesRecord{
 		Type:                         CollectionPreferences,
 		ExternalLinkSkippedHostnames: skippedHostnames,
 		CreatedAt:                    time.Now().UTC().Format(time.RFC3339),
 	}
+
+	if labelers != nil {
+		switch v := labelers.(type) {
+		case []LabelerSubscription:
+			record.SubscribedLabelers = v
+		}
+	}
+
+	if labelPrefs != nil {
+		switch v := labelPrefs.(type) {
+		case []LabelPreference:
+			record.LabelPreferences = v
+		}
+	}
+
+	return record
 }
 
 type APIKeyRecord struct {

lexicons/at/margin/annotation.json

···
             "format": "uri",
             "description": "License URI (e.g., https://creativecommons.org/licenses/by/4.0/)"
           },
+          "labels": {
+            "type": "ref",
+            "ref": "com.atproto.label.defs#selfLabels",
+            "description": "Self-applied content labels for this annotation"
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

lexicons/at/margin/bookmark.json

···
             "format": "uri",
             "description": "License URI (e.g., https://creativecommons.org/licenses/by/4.0/)"
           },
+          "labels": {
+            "type": "ref",
+            "ref": "com.atproto.label.defs#selfLabels",
+            "description": "Self-applied content labels for this bookmark"
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

lexicons/at/margin/highlight.json

···
             "format": "uri",
             "description": "License URI (e.g., https://creativecommons.org/licenses/by/4.0/)"
           },
+          "labels": {
+            "type": "ref",
+            "ref": "com.atproto.label.defs#selfLabels",
+            "description": "Self-applied content labels for this highlight"
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

lexicons/at/margin/preferences.json

···
             },
             "maxLength": 100
           },
+          "subscribedLabelers": {
+            "type": "array",
+            "description": "List of labeler services the user subscribes to for content moderation.",
+            "items": {
+              "type": "object",
+              "required": ["did"],
+              "properties": {
+                "did": {
+                  "type": "string",
+                  "description": "DID of the labeler service."
+                }
+              }
+            },
+            "maxLength": 50
+          },
+          "labelPreferences": {
+            "type": "array",
+            "description": "Per-label visibility preferences for subscribed labelers.",
+            "items": {
+              "type": "object",
+              "required": ["labelerDid", "label", "visibility"],
+              "properties": {
+                "labelerDid": {
+                  "type": "string",
+                  "description": "DID of the labeler service."
+                },
+                "label": {
+                  "type": "string",
+                  "description": "The label identifier (e.g. sexual, violence, spam)."
+                },
+                "visibility": {
+                  "type": "string",
+                  "description": "How to handle content with this label: hide, warn, or ignore.",
+                  "knownValues": ["hide", "warn", "ignore"]
+                }
+              }
+            },
+            "maxLength": 500
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

web/src/App.tsx

···
   UserUrlWrapper,
 } from "./routes/wrappers";
 import About from "./views/About";
+import AdminModeration from "./views/core/AdminModeration";
 
 export default function App() {
   React.useEffect(() => {
···
           element={
             <AppLayout>
               <UserUrlWrapper />
+            </AppLayout>
+          }
+        />
+
+        <Route
+          path="/admin/moderation"
+          element={
+            <AppLayout>
+              <AdminModeration />
             </AppLayout>
           }
         />

web/src/api/client.ts

···
   title?: string;
   selector?: { exact: string; prefix?: string; suffix?: string };
   tags?: string[];
+  labels?: string[];
 }
 
 export async function createAnnotation({
···
   title,
   selector,
   tags,
+  labels,
 }: CreateAnnotationParams) {
   try {
     const res = await apiRequest("/api/annotations", {
       method: "POST",
-      body: JSON.stringify({ url, text, title, selector, tags }),
+      body: JSON.stringify({ url, text, title, selector, tags, labels }),
     });
     if (!res.ok) throw new Error(await res.text());
     const raw = await res.json();
···
   color?: string;
   tags?: string[];
   title?: string;
+  labels?: string[];
 }
 
 export async function createHighlight({
···
   color,
   tags,
   title,
+  labels,
 }: CreateHighlightParams) {
   try {
     const res = await apiRequest("/api/highlights", {
       method: "POST",
-      body: JSON.stringify({ url, selector, color, tags, title }),
+      body: JSON.stringify({ url, selector, color, tags, title, labels }),
     });
     if (!res.ok) throw new Error(await res.text());
     const raw = await res.json();
···
   uri: string,
   text: string,
   tags?: string[],
+  labels?: string[],
 ): Promise<boolean> {
   try {
     const res = await apiRequest(
       `/api/annotations?uri=${encodeURIComponent(uri)}`,
       {
         method: "PUT",
-        body: JSON.stringify({ text, tags }),
+        body: JSON.stringify({ text, tags, labels }),
       },
     );
     return res.ok;
···
   uri: string,
   color: string,
   tags?: string[],
+  labels?: string[],
 ): Promise<boolean> {
   try {
     const res = await apiRequest(
       `/api/highlights?uri=${encodeURIComponent(uri)}`,
       {
         method: "PUT",
-        body: JSON.stringify({ color, tags }),
+        body: JSON.stringify({ color, tags, labels }),
       },
     );
     return res.ok;
···
   title?: string,
   description?: string,
   tags?: string[],
+  labels?: string[],
 ): Promise<boolean> {
   try {
     const res = await apiRequest(
       `/api/bookmarks?uri=${encodeURIComponent(uri)}`,
       {
         method: "PUT",
-        body: JSON.stringify({ title, description, tags }),
+        body: JSON.stringify({ title, description, tags, labels }),
       },
     );
     return res.ok;
···
     return { annotations: [], highlights: [] };
   }
 }
-export async function getPreferences(): Promise<{
+import type {
+  LabelerSubscription,
+  LabelPreference,
+  LabelerInfo,
+} from "../types";
+
+export interface PreferencesResponse {
   externalLinkSkippedHostnames?: string[];
-}> {
+  subscribedLabelers?: LabelerSubscription[];
+  labelPreferences?: LabelPreference[];
+}
+
+export async function getPreferences(): Promise<PreferencesResponse> {
   try {
     const res = await apiRequest("/api/preferences", {
       skipAuthRedirect: true,
···
 
 export async function updatePreferences(prefs: {
   externalLinkSkippedHostnames?: string[];
+  subscribedLabelers?: LabelerSubscription[];
+  labelPreferences?: LabelPreference[];
 }): Promise<boolean> {
   try {
     const res = await apiRequest("/api/preferences", {
···
     return false;
   }
 }
+
+export async function getLabelerInfo(): Promise<LabelerInfo | null> {
+  try {
+    const res = await apiRequest("/moderation/labeler", {
+      skipAuthRedirect: true,
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch (e) {
+    console.error("Failed to fetch labeler info:", e);
+    return null;
+  }
+}
+
+import type {
+  ModerationRelationship,
+  BlockedUser,
+  MutedUser,
+  ModerationReport,
+  ReportReasonType,
+} from "../types";
+
+export async function blockUser(did: string): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/block", {
+      method: "POST",
+      body: JSON.stringify({ did }),
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to block user:", e);
+    return false;
+  }
+}
+
+export async function unblockUser(did: string): Promise<boolean> {
+  try {
+    const res = await apiRequest(
+      `/api/moderation/block?did=${encodeURIComponent(did)}`,
+      { method: "DELETE" },
+    );
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to unblock user:", e);
+    return false;
+  }
+}
+
+export async function getBlocks(): Promise<BlockedUser[]> {
+  try {
+    const res = await apiRequest("/api/moderation/blocks");
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.items || [];
+  } catch (e) {
+    console.error("Failed to fetch blocks:", e);
+    return [];
+  }
+}
+
+export async function muteUser(did: string): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/mute", {
+      method: "POST",
+      body: JSON.stringify({ did }),
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to mute user:", e);
+    return false;
+  }
+}
+
+export async function unmuteUser(did: string): Promise<boolean> {
+  try {
+    const res = await apiRequest(
+      `/api/moderation/mute?did=${encodeURIComponent(did)}`,
+      { method: "DELETE" },
+    );
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to unmute user:", e);
+    return false;
+  }
+}
+
+export async function getMutes(): Promise<MutedUser[]> {
+  try {
+    const res = await apiRequest("/api/moderation/mutes");
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.items || [];
+  } catch (e) {
+    console.error("Failed to fetch mutes:", e);
+    return [];
+  }
+}
+
+export async function getModerationRelationship(
+  did: string,
+): Promise<ModerationRelationship> {
+  try {
+    const res = await apiRequest(
+      `/api/moderation/relationship?did=${encodeURIComponent(did)}`,
+      { skipAuthRedirect: true },
+    );
+    if (!res.ok) return { blocking: false, muting: false, blockedBy: false };
+    return await res.json();
+  } catch (e) {
+    console.error("Failed to get moderation relationship:", e);
+    return { blocking: false, muting: false, blockedBy: false };
+  }
+}
+
+export async function reportUser(params: {
+  subjectDid: string;
+  subjectUri?: string;
+  reasonType: ReportReasonType;
+  reasonText?: string;
+}): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/report", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to submit report:", e);
+    return false;
+  }
+}
+
+export async function checkAdminAccess(): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/admin/check", {
+      skipAuthRedirect: true,
+    });
+    if (!res.ok) return false;
+    const data = await res.json();
+    return data.isAdmin || false;
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function getAdminReports(
+  status?: string,
+  limit = 50,
+  offset = 0,
+): Promise<{
+  items: ModerationReport[];
+  totalItems: number;
+  pendingCount: number;
+}> {
+  try {
+    const params = new URLSearchParams();
+    if (status) params.append("status", status);
+    params.append("limit", limit.toString());
+    params.append("offset", offset.toString());
+    const res = await apiRequest(
+      `/api/moderation/admin/reports?${params.toString()}`,
+    );
+    if (!res.ok) return { items: [], totalItems: 0, pendingCount: 0 };
+    return await res.json();
+  } catch (e) {
+    console.error("Failed to fetch admin reports:", e);
+    return { items: [], totalItems: 0, pendingCount: 0 };
+  }
+}
+
+export async function adminTakeAction(params: {
+  reportId: number;
+  action: string;
+  comment?: string;
+}): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/admin/action", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to take moderation action:", e);
+    return false;
+  }
+}
+
+export async function adminCreateLabel(params: {
+  src: string;
+  uri?: string;
+  val: string;
+}): Promise<boolean> {
+  try {
+    const res = await apiRequest("/api/moderation/admin/label", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to create label:", e);
+    return false;
+  }
+}
+
+export async function adminDeleteLabel(id: number): Promise<boolean> {
+  try {
+    const res = await apiRequest(`/api/moderation/admin/label?id=${id}`, {
+      method: "DELETE",
+    });
+    return res.ok;
+  } catch (e) {
+    console.error("Failed to delete label:", e);
+    return false;
+  }
+}
+
+export async function adminGetLabels(
+  limit = 50,
+  offset = 0,
+): Promise<{ items: any[] }> {
+  try {
+    const res = await apiRequest(
+      `/api/moderation/admin/labels?limit=${limit}&offset=${offset}`,
+    );
+    if (!res.ok) return { items: [] };
+    return await res.json();
+  } catch (e) {
+    console.error("Failed to fetch labels:", e);
+    return { items: [] };
+  }
+}

web/src/components/common/Card.tsx

···
 import React, { useState } from "react";
 import { formatDistanceToNow } from "date-fns";
 import RichText from "./RichText";
+import MoreMenu from "./MoreMenu";
+import type { MoreMenuItem } from "./MoreMenu";
 import {
   MessageSquare,
   Heart,
···
   Trash2,
   Edit3,
   Globe,
+  ShieldBan,
+  VolumeX,
+  Flag,
+  EyeOff,
+  Eye,
 } from "lucide-react";
 import ShareMenu from "../modals/ShareMenu";
 import AddToCollectionModal from "../modals/AddToCollectionModal";
 import ExternalLinkModal from "../modals/ExternalLinkModal";
+import ReportModal from "../modals/ReportModal";
+import EditItemModal from "../modals/EditItemModal";
 import { clsx } from "clsx";
-import { likeItem, unlikeItem, deleteItem } from "../../api/client";
+import {
+  likeItem,
+  unlikeItem,
+  deleteItem,
+  blockUser,
+  muteUser,
+} from "../../api/client";
 import { $user } from "../../store/auth";
 import { $preferences } from "../../store/preferences";
 import { useStore } from "@nanostores/react";
-import type { AnnotationItem } from "../../types";
+import type {
+  AnnotationItem,
+  ContentLabel,
+  LabelVisibility,
+} from "../../types";
 import { Link } from "react-router-dom";
 import { Avatar } from "../ui";
 import CollectionIcon from "./CollectionIcon";
 import ProfileHoverCard from "./ProfileHoverCard";
 
+const LABEL_DESCRIPTIONS: Record<string, string> = {
+  sexual: "Sexual Content",
+  nudity: "Nudity",
+  violence: "Violence",
+  gore: "Graphic Content",
+  spam: "Spam",
+  misleading: "Misleading",
+};
+
+function getContentWarning(
+  labels?: ContentLabel[],
+  prefs?: {
+    labelPreferences: {
+      labelerDid: string;
+      label: string;
+      visibility: LabelVisibility;
+    }[];
+  },
+): {
+  label: string;
+  description: string;
+  visibility: LabelVisibility;
+  isAccountWide: boolean;
+} | null {
+  if (!labels || labels.length === 0) return null;
+  const priority = [
+    "gore",
+    "violence",
+    "nudity",
+    "sexual",
+    "misleading",
+    "spam",
+  ];
+  for (const p of priority) {
+    const match = labels.find((l) => l.val === p);
+    if (match) {
+      const pref = prefs?.labelPreferences.find(
+        (lp) => lp.label === p && lp.labelerDid === match.src,
+      );
+      const visibility: LabelVisibility = pref?.visibility || "warn";
+      if (visibility === "ignore") continue;
+      return {
+        label: p,
+        description: LABEL_DESCRIPTIONS[p] || p,
+        visibility,
+        isAccountWide: match.scope === "account",
+      };
+    }
+  }
+  return null;
+}
+
 interface CardProps {
   item: AnnotationItem;
   onDelete?: (uri: string) => void;
+  onUpdate?: (item: AnnotationItem) => void;
   hideShare?: boolean;
 }
 
-export default function Card({ item, onDelete, hideShare }: CardProps) {
+export default function Card({
+  item: initialItem,
+  onDelete,
+  onUpdate,
+  hideShare,
+}: CardProps) {
+  const [item, setItem] = useState(initialItem);
   const user = useStore($user);
+  const preferences = useStore($preferences);
   const isAuthor = user && item.author?.did === user.did;
 
   const [liked, setLiked] = useState(!!item.viewer?.like);
···
   const [showCollectionModal, setShowCollectionModal] = useState(false);
   const [showExternalLinkModal, setShowExternalLinkModal] = useState(false);
   const [externalLinkUrl, setExternalLinkUrl] = useState<string | null>(null);
+  const [showReportModal, setShowReportModal] = useState(false);
+  const [showEditModal, setShowEditModal] = useState(false);
+  const [contentRevealed, setContentRevealed] = useState(false);
+
+  const contentWarning = getContentWarning(item.labels, preferences);
+
+  if (contentWarning?.visibility === "hide") return null;
+
+  React.useEffect(() => {
+    setItem(initialItem);
+  }, [initialItem]);
 
   React.useEffect(() => {
     setLiked(!!item.viewer?.like);
···
   const displayImage = ogData?.image;
 
   return (
-    <article className="card p-4 hover:ring-black/10 dark:hover:ring-white/10 transition-all">
+    <article className="card p-4 hover:ring-black/10 dark:hover:ring-white/10 transition-all relative">
       {item.collection && (
         <div className="flex items-center gap-1.5 text-xs text-surface-400 dark:text-surface-500 mb-2">
           {item.addedBy && item.addedBy.did !== item.author?.did ? (
···
       <div className="flex items-start gap-3">
         <ProfileHoverCard did={item.author?.did}>
           <Link to={`/profile/${item.author?.did}`} className="shrink-0">
-            <Avatar
-              did={item.author?.did}
-              avatar={item.author?.avatar}
-              size="md"
-            />
+            <div className="rounded-full overflow-hidden">
+              <div
+                className={clsx(
+                  "transition-all",
+                  contentWarning?.isAccountWide &&
+                    !contentRevealed &&
+                    "blur-md",
+                )}
+              >
+                <Avatar
+                  did={item.author?.did}
+                  avatar={item.author?.avatar}
+                  size="md"
+                />
+              </div>
+            </div>
           </Link>
         </ProfileHoverCard>
 
···
               })()}
           </div>
 
-          {pageUrl && !isBookmark && (
+          {pageUrl && !isBookmark && !(contentWarning && !contentRevealed) && (
             <a
               href={pageUrl}
               target="_blank"
···
         </div>
       </div>
 
-      <div className="mt-3 ml-[52px]">
+      <div className="mt-3 ml-[52px] relative">
+        {contentWarning && !contentRevealed && (
+          <div className="absolute inset-0 z-10 rounded-lg bg-surface-100 dark:bg-surface-800 flex flex-col items-center justify-center gap-2 py-4">
+            <div className="flex items-center gap-2 text-surface-500 dark:text-surface-400">
+              <EyeOff size={16} />
+              <span className="text-sm font-medium">
+                {contentWarning.description}
+              </span>
+            </div>
+            <button
+              onClick={() => setContentRevealed(true)}
+              className="flex items-center gap-1.5 px-3 py-1 text-xs font-medium rounded-lg bg-surface-200 dark:bg-surface-700 text-surface-600 dark:text-surface-300 hover:bg-surface-300 dark:hover:bg-surface-600 transition-colors"
+            >
+              <Eye size={12} />
+              Show
+            </button>
+          </div>
+        )}
+        {contentWarning && contentRevealed && (
+          <button
+            onClick={() => setContentRevealed(false)}
+            className="flex items-center gap-1.5 mb-2 px-2.5 py-1 text-xs font-medium rounded-lg bg-surface-100 dark:bg-surface-800 text-surface-500 dark:text-surface-400 hover:bg-surface-200 dark:hover:bg-surface-700 transition-colors"
+          >
+            <EyeOff size={12} />
+            Hide Content
+          </button>
+        )}
         {isBookmark && (
           <a
             href={pageUrl || "#"}
···
           <>
             <div className="flex-1" />
             <button
+              onClick={() => setShowEditModal(true)}
               className="flex items-center px-2.5 py-1.5 rounded-lg text-surface-400 dark:text-surface-500 hover:text-surface-600 dark:hover:text-surface-300 hover:bg-surface-50 dark:hover:bg-surface-800 transition-all"
               title="Edit"
             >
···
             </button>
           </>
         )}
+
+        {!isAuthor && user && (
+          <>
+            <div className="flex-1" />
+            <MoreMenu
+              items={(() => {
+                const menuItems: MoreMenuItem[] = [
+                  {
+                    label: "Report",
+                    icon: <Flag size={14} />,
+                    onClick: () => setShowReportModal(true),
+                    variant: "danger",
+                  },
+                  {
+                    label: `Mute @${item.author?.handle || "user"}`,
+                    icon: <VolumeX size={14} />,
+                    onClick: async () => {
+                      if (item.author?.did) {
+                        await muteUser(item.author.did);
+                        onDelete?.(item.uri);
+                      }
+                    },
+                  },
+                  {
+                    label: `Block @${item.author?.handle || "user"}`,
+                    icon: <ShieldBan size={14} />,
+                    onClick: async () => {
+                      if (item.author?.did) {
+                        await blockUser(item.author.did);
+                        onDelete?.(item.uri);
+                      }
+                    },
+                    variant: "danger",
+                  },
+                ];
+                return menuItems;
+              })()}
+            />
+          </>
+        )}
       </div>
 
       <AddToCollectionModal
···
         isOpen={showExternalLinkModal}
         onClose={() => setShowExternalLinkModal(false)}
         url={externalLinkUrl}
+      />
+
+      <ReportModal
+        isOpen={showReportModal}
+        onClose={() => setShowReportModal(false)}
+        subjectDid={item.author?.did || ""}
+        subjectUri={item.uri}
+        subjectHandle={item.author?.handle}
+      />
+
+      <EditItemModal
+        isOpen={showEditModal}
+        onClose={() => setShowEditModal(false)}
+        item={item}
+        type={type}
+        onSaved={(updated) => {
+          setItem(updated);
+          onUpdate?.(updated);
+        }}
       />
     </article>
   );

web/src/components/common/MoreMenu.tsx

···
+import React, { useState, useRef, useEffect } from "react";
+import { MoreHorizontal } from "lucide-react";
+import { clsx } from "clsx";
+
+export interface MoreMenuItem {
+  label: string;
+  icon?: React.ReactNode;
+  onClick: () => void;
+  variant?: "default" | "danger";
+  disabled?: boolean;
+}
+
+interface MoreMenuProps {
+  items: MoreMenuItem[];
+  className?: string;
+}
+
+export default function MoreMenu({ items, className }: MoreMenuProps) {
+  const [isOpen, setIsOpen] = useState(false);
+  const buttonRef = useRef<HTMLButtonElement>(null);
+  const menuRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!isOpen) return;
+
+    const handleClickOutside = (e: MouseEvent) => {
+      if (
+        menuRef.current &&
+        !menuRef.current.contains(e.target as Node) &&
+        buttonRef.current &&
+        !buttonRef.current.contains(e.target as Node)
+      ) {
+        setIsOpen(false);
+      }
+    };
+
+    const handleScroll = () => setIsOpen(false);
+    const handleEscape = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setIsOpen(false);
+    };
+
+    document.addEventListener("mousedown", handleClickOutside);
+    document.addEventListener("scroll", handleScroll, true);
+    document.addEventListener("keydown", handleEscape);
+
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("scroll", handleScroll, true);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [isOpen]);
+
+  if (items.length === 0) return null;
+
+  return (
+    <div className={clsx("relative", className)}>
+      <button
+        ref={buttonRef}
+        onClick={() => setIsOpen(!isOpen)}
+        className="flex items-center px-2 py-1.5 rounded-lg text-surface-400 dark:text-surface-500 hover:text-surface-600 dark:hover:text-surface-300 hover:bg-surface-100 dark:hover:bg-surface-800 transition-all"
+        title="More options"
+      >
+        <MoreHorizontal size={16} />
+      </button>
+
+      {isOpen && (
+        <div
+          ref={menuRef}
+          className="absolute right-0 top-full mt-1 z-50 min-w-[180px] bg-white dark:bg-surface-900 border border-surface-200 dark:border-surface-700 rounded-xl shadow-lg py-1 animate-fade-in"
+        >
+          {items.map((item, i) => (
+            <button
+              key={i}
+              onClick={() => {
+                item.onClick();
+                setIsOpen(false);
+              }}
+              disabled={item.disabled}
+              className={clsx(
+                "w-full flex items-center gap-2.5 px-3.5 py-2 text-sm transition-colors text-left",
+                item.variant === "danger"
+                  ? "text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20"
+                  : "text-surface-700 dark:text-surface-300 hover:bg-surface-50 dark:hover:bg-surface-800",
+                item.disabled && "opacity-50 cursor-not-allowed",
+              )}
+            >
+              {item.icon && (
+                <span className="flex-shrink-0 w-4 h-4 flex items-center justify-center">
+                  {item.icon}
+                </span>
+              )}
+              {item.label}
+            </button>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

web/src/components/feed/Composer.tsx

···
 import React, { useState } from "react";
 import { createAnnotation, createHighlight } from "../../api/client";
-import type { Selector } from "../../types";
-import { X } from "lucide-react";
+import type { Selector, ContentLabelValue } from "../../types";
+import { X, ShieldAlert } from "lucide-react";
+
+const SELF_LABEL_OPTIONS: { value: ContentLabelValue; label: string }[] = [
+  { value: "sexual", label: "Sexual" },
+  { value: "nudity", label: "Nudity" },
+  { value: "violence", label: "Violence" },
+  { value: "gore", label: "Gore" },
+  { value: "spam", label: "Spam" },
+  { value: "misleading", label: "Misleading" },
+];
 
 interface ComposerProps {
   url: string;
···
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [showQuoteInput, setShowQuoteInput] = useState(false);
+  const [selfLabels, setSelfLabels] = useState<ContentLabelValue[]>([]);
+  const [showLabelPicker, setShowLabelPicker] = useState(false);
 
   const highlightedText =
     selector?.type === "TextQuoteSelector" ? selector.exact : null;
···
           },
           color: "yellow",
           tags: tagList,
+          labels: selfLabels.length > 0 ? selfLabels : undefined,
         });
       } else {
         await createAnnotation({
···
           text: text.trim(),
           selector: finalSelector || undefined,
           tags: tagList,
+          labels: selfLabels.length > 0 ? selfLabels : undefined,
         });
       }
 
···
         className="w-full p-2.5 bg-white dark:bg-surface-800 border border-surface-200 dark:border-surface-700 rounded-lg text-surface-900 dark:text-white placeholder:text-surface-400 dark:placeholder:text-surface-500 focus:ring-2 focus:ring-primary-500/20 focus:border-primary-500 dark:focus:border-primary-400 outline-none text-sm"
         disabled={loading}
       />
+
+      <div>
+        <button
+          type="button"
+          onClick={() => setShowLabelPicker(!showLabelPicker)}
+          className="flex items-center gap-1.5 text-sm text-surface-500 dark:text-surface-400 hover:text-surface-700 dark:hover:text-surface-200 transition-colors"
+        >
+          <ShieldAlert size={14} />
+          <span>
+            Content Warning
+            {selfLabels.length > 0 ? ` (${selfLabels.length})` : ""}
+          </span>
+        </button>
+
+        {showLabelPicker && (
+          <div className="mt-2 flex flex-wrap gap-1.5">
+            {SELF_LABEL_OPTIONS.map((opt) => (
+              <button
+                key={opt.value}
+                type="button"
+                onClick={() =>
+                  setSelfLabels((prev) =>
+                    prev.includes(opt.value)
+                      ? prev.filter((v) => v !== opt.value)
+                      : [...prev, opt.value],
+                  )
+                }
+                className={`px-2.5 py-1 text-xs font-medium rounded-lg transition-all ${
+                  selfLabels.includes(opt.value)
+                    ? "bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-400 ring-1 ring-amber-300 dark:ring-amber-700"
+                    : "bg-surface-100 dark:bg-surface-800 text-surface-500 dark:text-surface-400 hover:bg-surface-200 dark:hover:bg-surface-700"
+                }`}
+              >
+                {opt.label}
+              </button>
+            ))}
+          </div>
+        )}
+      </div>
 
       <div className="flex items-center justify-between pt-2">
         <span

web/src/components/modals/EditItemModal.tsx

···
+import React, { useState, useEffect } from "react";
+import { X, ShieldAlert } from "lucide-react";
+import {
+  updateAnnotation,
+  updateHighlight,
+  updateBookmark,
+} from "../../api/client";
+import type { AnnotationItem, ContentLabelValue } from "../../types";
+
+const SELF_LABEL_OPTIONS: { value: ContentLabelValue; label: string }[] = [
+  { value: "sexual", label: "Sexual" },
+  { value: "nudity", label: "Nudity" },
+  { value: "violence", label: "Violence" },
+  { value: "gore", label: "Gore" },
+  { value: "spam", label: "Spam" },
+  { value: "misleading", label: "Misleading" },
+];
+
+const HIGHLIGHT_COLORS = [
+  { value: "yellow", bg: "bg-yellow-400", ring: "ring-yellow-500" },
+  { value: "green", bg: "bg-green-400", ring: "ring-green-500" },
+  { value: "blue", bg: "bg-blue-400", ring: "ring-blue-500" },
+  { value: "red", bg: "bg-red-400", ring: "ring-red-500" },
+];
+
+interface EditItemModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  item: AnnotationItem;
+  type: "annotation" | "highlight" | "bookmark";
+  onSaved?: (item: AnnotationItem) => void;
+}
+
+export default function EditItemModal({
+  isOpen,
+  onClose,
+  item,
+  type,
+  onSaved,
+}: EditItemModalProps) {
+  const [text, setText] = useState(item.body?.value || "");
+  const [tags, setTags] = useState<string[]>(item.tags || []);
+  const [tagInput, setTagInput] = useState("");
+
+  const [color, setColor] = useState(item.color || "yellow");
+
+  const [title, setTitle] = useState(item.title || item.target?.title || "");
+  const [description, setDescription] = useState(item.description || "");
+
+  const existingLabels = (item.labels || [])
+    .filter((l) => l.src === item.author?.did)
+    .map((l) => l.val as ContentLabelValue);
+  const [selfLabels, setSelfLabels] =
+    useState<ContentLabelValue[]>(existingLabels);
+  const [showLabelPicker, setShowLabelPicker] = useState(
+    existingLabels.length > 0,
+  );
+
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (isOpen) {
+      setText(item.body?.value || "");
+      setTags(item.tags || []);
+      setTagInput("");
+      setColor(item.color || "yellow");
+      setTitle(item.title || item.target?.title || "");
+      setDescription(item.description || "");
+      const labels = (item.labels || [])
+        .filter((l) => l.src === item.author?.did)
+        .map((l) => l.val as ContentLabelValue);
+      setSelfLabels(labels);
+      setShowLabelPicker(labels.length > 0);
+    }
+  }, [isOpen, item]);
+
+  if (!isOpen) return null;
+
+  const addTag = () => {
+    const t = tagInput.trim().toLowerCase();
+    if (t && !tags.includes(t)) {
+      setTags([...tags, t]);
+    }
+    setTagInput("");
+  };
+
+  const removeTag = (tag: string) => {
+    setTags(tags.filter((t) => t !== tag));
+  };
+
+  const toggleLabel = (val: ContentLabelValue) => {
+    setSelfLabels((prev) =>
+      prev.includes(val) ? prev.filter((l) => l !== val) : [...prev, val],
+    );
+  };
+
+  const handleSave = async () => {
+    setSaving(true);
+    setError(null);
+    let success = false;
+    const labels = selfLabels.length > 0 ? selfLabels : [];
+
+    try {
+      if (type === "annotation") {
+        success = await updateAnnotation(
+          item.uri,
+          text,
+          tags.length > 0 ? tags : undefined,
+          labels,
+        );
+      } else if (type === "highlight") {
+        success = await updateHighlight(
+          item.uri,
+          color,
+          tags.length > 0 ? tags : undefined,
+          labels,
+        );
+      } else if (type === "bookmark") {
+        success = await updateBookmark(
+          item.uri,
+          title || undefined,
+          description || undefined,
+          tags.length > 0 ? tags : undefined,
+          labels,
+        );
+      }
+    } catch (e) {
+      console.error("Edit save error:", e);
+      setError(e instanceof Error ? e.message : "Failed to save");
+      setSaving(false);
+      return;
+    }
+
+    setSaving(false);
+    if (!success) {
+      setError("Failed to save changes. Please try again.");
+      return;
+    }
+    const updated = { ...item };
+    if (type === "annotation") {
+      updated.body = { type: "TextualBody", value: text, format: "text/plain" };
+    } else if (type === "highlight") {
+      updated.color = color;
+    } else if (type === "bookmark") {
+      updated.title = title;
+      updated.description = description;
+    }
+    updated.tags = tags;
+    const otherLabels = (item.labels || []).filter(
+      (l) => l.src !== item.author?.did,
+    );
+    const newSelfLabels = selfLabels.map((val) => ({
+      val,
+      src: item.author?.did || "",
+      scope: "content" as const,
+    }));
+    updated.labels = [...otherLabels, ...newSelfLabels];
+    onSaved?.(updated);
+    onClose();
+  };
+
+  return (
+    <div
+      className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 backdrop-blur-sm"
+      onClick={onClose}
+    >
+      <div
+        className="bg-white dark:bg-surface-900 rounded-2xl shadow-xl w-full max-w-lg mx-4 max-h-[80vh] overflow-y-auto"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="flex items-center justify-between px-5 py-4 border-b border-surface-200 dark:border-surface-700">
+          <h3 className="text-lg font-semibold text-surface-900 dark:text-surface-100">
+            Edit{" "}
+            {type === "annotation"
+              ? "Annotation"
+              : type === "highlight"
+                ? "Highlight"
+                : "Bookmark"}
+          </h3>
+          <button
+            onClick={onClose}
+            className="p-1.5 rounded-lg text-surface-400 hover:text-surface-600 dark:hover:text-surface-300 hover:bg-surface-100 dark:hover:bg-surface-800 transition-colors"
+          >
+            <X size={18} />
+          </button>
+        </div>
+
+        <div className="px-5 py-4 space-y-4">
+          {type === "annotation" && (
+            <div>
+              <label className="block text-sm font-medium text-surface-700 dark:text-surface-300 mb-1.5">
+                Text
+              </label>
+              <textarea
+                value={text}
+                onChange={(e) => setText(e.target.value)}
+                rows={4}
+                maxLength={3000}
+                className="w-full px-3 py-2 rounded-xl border border-surface-200 dark:border-surface-700 bg-surface-50 dark:bg-surface-800 text-surface-900 dark:text-surface-100 text-sm focus:outline-none focus:ring-2 focus:ring-primary-500 resize-none"
+                placeholder="Write your annotation..."
+              />
+              <p className="text-xs text-surface-400 mt-1">
+                {text.length}/3000
+              </p>
+            </div>
+          )}
+
+          {type === "highlight" && (
+            <div>
+              <label className="block text-sm font-medium text-surface-700 dark:text-surface-300 mb-2">
+                Color
+              </label>
+              <div className="flex gap-2">
+                {HIGHLIGHT_COLORS.map((c) => (
+                  <button
+                    key={c.value}
+                    onClick={() => setColor(c.value)}
+                    className={`w-8 h-8 rounded-full ${c.bg} transition-all ${
+                      color === c.value
+                        ? `ring-2 ${c.ring} ring-offset-2 dark:ring-offset-surface-900 scale-110`
+                        : "opacity-60 hover:opacity-100"
+                    }`}
+                    title={c.value}
+                  />
+                ))}
+              </div>
+              {item.target?.selector?.exact && (
+                <blockquote className="mt-3 pl-3 py-2 border-l-2 border-surface-300 dark:border-surface-600 text-sm italic text-surface-500 dark:text-surface-400">
+                  {item.target.selector.exact}
+                </blockquote>
+              )}
+            </div>
+          )}
+
+          {type === "bookmark" && (
+            <>
+              <div>
+                <label className="block text-sm font-medium text-surface-700 dark:text-surface-300 mb-1.5">
+                  Title
+                </label>
+                <input
+                  type="text"
+                  value={title}
+                  onChange={(e) => setTitle(e.target.value)}
+                  className="w-full px-3 py-2 rounded-xl border border-surface-200 dark:border-surface-700 bg-surface-50 dark:bg-surface-800 text-surface-900 dark:text-surface-100 text-sm focus:outline-none focus:ring-2 focus:ring-primary-500"
+                  placeholder="Bookmark title"
+                />
+              </div>
+              <div>
+                <label className="block text-sm font-medium text-surface-700 dark:text-surface-300 mb-1.5">
+                  Description
+                </label>
+                <textarea
+                  value={description}
+                  onChange={(e) => setDescription(e.target.value)}
+                  rows={3}
+                  className="w-full px-3 py-2 rounded-xl border border-surface-200 dark:border-surface-700 bg-surface-50 dark:bg-surface-800 text-surface-900 dark:text-surface-100 text-sm focus:outline-none focus:ring-2 focus:ring-primary-500 resize-none"
+                  placeholder="Optional description..."
+                />
+              </div>
+            </>
+          )}
+
+          <div>
+            <label className="block text-sm font-medium text-surface-700 dark:text-surface-300 mb-1.5">
+              Tags
+            </label>
+            <div className="flex flex-wrap gap-1.5 mb-2">
+              {tags.map((tag) => (
+                <span
+                  key={tag}
+                  className="inline-flex items-center gap-1 px-2.5 py-1 rounded-full bg-primary-50 dark:bg-primary-900/30 text-primary-700 dark:text-primary-300 text-xs font-medium"
+                >
+                  #{tag}
+                  <button
+                    onClick={() => removeTag(tag)}
+                    className="hover:text-red-500 transition-colors"
+                  >
+                    <X size={12} />
+                  </button>
+                </span>
+              ))}
+            </div>
+            <div className="flex gap-2">
+              <input
+                type="text"
+                value={tagInput}
+                onChange={(e) => setTagInput(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") {
+                    e.preventDefault();
+                    addTag();
+                  }
+                }}
+                className="flex-1 px-3 py-1.5 rounded-lg border border-surface-200 dark:border-surface-700 bg-surface-50 dark:bg-surface-800 text-surface-900 dark:text-surface-100 text-sm focus:outline-none focus:ring-2 focus:ring-primary-500"
+                placeholder="Add a tag..."
+              />
+              <button
+                onClick={addTag}
+                disabled={!tagInput.trim()}
+                className="px-3 py-1.5 rounded-lg bg-primary-500 text-white text-sm font-medium hover:bg-primary-600 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
+              >
+                Add
+              </button>
+            </div>
+          </div>
+
+          <div>
+            <button
+              onClick={() => setShowLabelPicker(!showLabelPicker)}
+              className={`flex items-center gap-2 text-sm font-medium transition-colors ${
+                showLabelPicker || selfLabels.length > 0
+                  ? "text-amber-600 dark:text-amber-400"
+                  : "text-surface-500 dark:text-surface-400 hover:text-surface-700 dark:hover:text-surface-200"
+              }`}
+            >
+              <ShieldAlert size={16} />
+              Content Warning
+              {selfLabels.length > 0 && (
+                <span className="text-xs bg-amber-100 dark:bg-amber-900/40 text-amber-700 dark:text-amber-300 px-1.5 py-0.5 rounded-full">
+                  {selfLabels.length}
+                </span>
+              )}
+            </button>
+            {showLabelPicker && (
+              <div className="flex flex-wrap gap-1.5 mt-2">
+                {SELF_LABEL_OPTIONS.map((opt) => (
+                  <button
+                    key={opt.value}
+                    onClick={() => toggleLabel(opt.value)}
+                    className={`px-3 py-1 rounded-full text-xs font-medium border transition-all ${
+                      selfLabels.includes(opt.value)
+                        ? "bg-amber-100 dark:bg-amber-900/40 border-amber-300 dark:border-amber-700 text-amber-800 dark:text-amber-200"
+                        : "bg-surface-50 dark:bg-surface-800 border-surface-200 dark:border-surface-700 text-surface-600 dark:text-surface-400 hover:border-amber-300 dark:hover:border-amber-700"
+                    }`}
+                  >
+                    {opt.label}
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+        </div>
+
+        <div className="px-5 py-4 border-t border-surface-200 dark:border-surface-700">
+          {error && <p className="text-sm text-red-500 mb-3">{error}</p>}
+          <div className="flex items-center justify-end gap-2">
+            <button
+              onClick={onClose}
+              className="px-4 py-2 rounded-xl text-sm font-medium text-surface-600 dark:text-surface-400 hover:bg-surface-100 dark:hover:bg-surface-800 transition-colors"
+            >
+              Cancel
+            </button>
+            <button
+              onClick={handleSave}
+              disabled={saving || (type === "annotation" && !text.trim())}
+              className="px-4 py-2 rounded-xl bg-primary-500 text-white text-sm font-medium hover:bg-primary-600 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
+            >
+              {saving ? "Saving..." : "Save"}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

web/src/components/modals/ReportModal.tsx

···
+import React, { useState } from "react";
+import { Flag, X } from "lucide-react";
+import { reportUser } from "../../api/client";
+import type { ReportReasonType } from "../../types";
+
+interface ReportModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  subjectDid: string;
+  subjectUri?: string;
+  subjectHandle?: string;
+}
+
+const REASONS: {
+  value: ReportReasonType;
+  label: string;
+  description: string;
+}[] = [
+  { value: "spam", label: "Spam", description: "Unwanted repetitive content" },
+  {
+    value: "violation",
+    label: "Rule violation",
+    description: "Violates community guidelines",
+  },
+  {
+    value: "misleading",
+    label: "Misleading",
+    description: "False or misleading information",
+  },
+  {
+    value: "rude",
+    label: "Rude or harassing",
+    description: "Targeting or harassing a user",
+  },
+  {
+    value: "sexual",
+    label: "Inappropriate content",
+    description: "Sexual or explicit material",
+  },
+  {
+    value: "other",
+    label: "Other",
+    description: "Something else not listed above",
+  },
+];
+
+export default function ReportModal({
+  isOpen,
+  onClose,
+  subjectDid,
+  subjectUri,
+  subjectHandle,
+}: ReportModalProps) {
+  const [selectedReason, setSelectedReason] = useState<ReportReasonType | null>(
+    null,
+  );
+  const [additionalText, setAdditionalText] = useState("");
+  const [submitting, setSubmitting] = useState(false);
+  const [submitted, setSubmitted] = useState(false);
+
+  if (!isOpen) return null;
+
+  const handleSubmit = async () => {
+    if (!selectedReason) return;
+
+    setSubmitting(true);
+    const success = await reportUser({
+      subjectDid: subjectDid,
+      subjectUri: subjectUri,
+      reasonType: selectedReason,
+      reasonText: additionalText || undefined,
+    });
+
+    setSubmitting(false);
+    if (success) {
+      setSubmitted(true);
+      setTimeout(() => {
+        onClose();
+        setSubmitted(false);
+        setSelectedReason(null);
+        setAdditionalText("");
+      }, 1500);
+    }
+  };
+
+  const handleClose = () => {
+    onClose();
+    setSelectedReason(null);
+    setAdditionalText("");
+    setSubmitted(false);
+  };
+
+  return (
+    <div
+      className="fixed inset-0 z-[200] flex items-center justify-center bg-black/50 backdrop-blur-sm animate-fade-in"
+      onClick={handleClose}
+    >
+      <div
+        className="bg-white dark:bg-surface-900 rounded-2xl shadow-2xl border border-surface-200 dark:border-surface-700 w-full max-w-md mx-4 overflow-hidden"
+        onClick={(e) => e.stopPropagation()}
+      >
+        {submitted ? (
+          <div className="p-8 text-center">
+            <div className="w-12 h-12 bg-green-100 dark:bg-green-900/30 rounded-full flex items-center justify-center mx-auto mb-3">
+              <Flag size={20} className="text-green-600 dark:text-green-400" />
+            </div>
+            <h3 className="text-lg font-semibold text-surface-900 dark:text-white">
+              Report submitted
+            </h3>
+            <p className="text-surface-500 dark:text-surface-400 text-sm mt-1">
+              Thank you. We'll review this shortly.
+            </p>
+          </div>
+        ) : (
+          <>
+            <div className="flex items-center justify-between p-4 border-b border-surface-200 dark:border-surface-700">
+              <div className="flex items-center gap-2.5">
+                <div className="w-8 h-8 bg-red-100 dark:bg-red-900/30 rounded-full flex items-center justify-center">
+                  <Flag size={16} className="text-red-600 dark:text-red-400" />
+                </div>
+                <div>
+                  <h3 className="text-base font-semibold text-surface-900 dark:text-white">
+                    Report {subjectHandle ? `@${subjectHandle}` : "user"}
+                  </h3>
+                  {subjectUri && (
+                    <p className="text-xs text-surface-400 dark:text-surface-500">
+                      Reporting specific content
+                    </p>
+                  )}
+                </div>
+              </div>
+              <button
+                onClick={handleClose}
+                className="p-1.5 text-surface-400 hover:text-surface-600 dark:hover:text-surface-300 rounded-lg hover:bg-surface-100 dark:hover:bg-surface-800 transition-colors"
+              >
+                <X size={18} />
+              </button>
+            </div>
+
+            <div className="p-4 space-y-2">
+              <p className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-3">
+                What's the issue?
+              </p>
+              {REASONS.map((reason) => (
+                <button
+                  key={reason.value}
+                  onClick={() => setSelectedReason(reason.value)}
+                  className={`w-full text-left px-3.5 py-2.5 rounded-xl border transition-all ${
+                    selectedReason === reason.value
+                      ? "border-primary-500 bg-primary-50 dark:bg-primary-900/20"
+                      : "border-surface-200 dark:border-surface-700 hover:border-surface-300 dark:hover:border-surface-600"
+                  }`}
+                >
+                  <span
+                    className={`text-sm font-medium ${
+                      selectedReason === reason.value
+                        ? "text-primary-700 dark:text-primary-300"
+                        : "text-surface-800 dark:text-surface-200"
+                    }`}
+                  >
+                    {reason.label}
+                  </span>
+                  <span
+                    className={`block text-xs mt-0.5 ${
+                      selectedReason === reason.value
+                        ? "text-primary-600/70 dark:text-primary-400/70"
+                        : "text-surface-400 dark:text-surface-500"
+                    }`}
+                  >
+                    {reason.description}
+                  </span>
+                </button>
+              ))}
+            </div>
+
+            {selectedReason && (
+              <div className="px-4 pb-2">
+                <textarea
+                  value={additionalText}
+                  onChange={(e) => setAdditionalText(e.target.value)}
+                  placeholder="Additional details (optional)"
+                  rows={2}
+                  className="w-full px-3.5 py-2.5 text-sm rounded-xl border border-surface-200 dark:border-surface-700 bg-white dark:bg-surface-800 text-surface-800 dark:text-surface-200 placeholder:text-surface-400 focus:outline-none focus:ring-2 focus:ring-primary-500/30 focus:border-primary-500 resize-none"
+                />
+              </div>
+            )}
+
+            <div className="flex items-center justify-end gap-2 p-4 border-t border-surface-200 dark:border-surface-700">
+              <button
+                onClick={handleClose}
+                className="px-4 py-2 text-sm font-medium text-surface-600 dark:text-surface-400 hover:text-surface-800 dark:hover:text-surface-200 rounded-xl hover:bg-surface-100 dark:hover:bg-surface-800 transition-colors"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleSubmit}
+                disabled={!selectedReason || submitting}
+                className="px-4 py-2 text-sm font-medium text-white bg-red-600 hover:bg-red-700 rounded-xl transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {submitting ? "Submitting…" : "Submit Report"}
+              </button>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}

web/src/store/preferences.ts

···
 import { atom } from "nanostores";
 import { getPreferences, updatePreferences } from "../api/client";
+import type {
+  LabelerSubscription,
+  LabelPreference,
+  LabelVisibility,
+} from "../types";
 
 export interface Preferences {
   externalLinkSkippedHostnames: string[];
+  subscribedLabelers: LabelerSubscription[];
+  labelPreferences: LabelPreference[];
 }
 
 export const $preferences = atom<Preferences>({
   externalLinkSkippedHostnames: [],
+  subscribedLabelers: [],
+  labelPreferences: [],
 });
 
 export async function loadPreferences() {
   const prefs = await getPreferences();
   $preferences.set({
     externalLinkSkippedHostnames: prefs.externalLinkSkippedHostnames || [],
+    subscribedLabelers: prefs.subscribedLabelers || [],
+    labelPreferences: prefs.labelPreferences || [],
   });
 }
 
···
   const current = $preferences.get();
   if (current.externalLinkSkippedHostnames.includes(hostname)) return;
 
-  const newHostnames = [...current.externalLinkSkippedHostnames, hostname];
-  $preferences.set({
+  const updated = {
     ...current,
-    externalLinkSkippedHostnames: newHostnames,
-  });
+    externalLinkSkippedHostnames: [
+      ...current.externalLinkSkippedHostnames,
+      hostname,
+    ],
+  };
+  $preferences.set(updated);
+  await updatePreferences(updated);
+}
 
-  await updatePreferences({
-    externalLinkSkippedHostnames: newHostnames,
-  });
+export async function addLabeler(did: string) {
+  const current = $preferences.get();
+  if (current.subscribedLabelers.some((l) => l.did === did)) return;
+
+  const updated = {
+    ...current,
+    subscribedLabelers: [...current.subscribedLabelers, { did }],
+  };
+  $preferences.set(updated);
+  await updatePreferences(updated);
+}
+
+export async function removeLabeler(did: string) {
+  const current = $preferences.get();
+  const updated = {
+    ...current,
+    subscribedLabelers: current.subscribedLabelers.filter((l) => l.did !== did),
+  };
+  $preferences.set(updated);
+  await updatePreferences(updated);
+}
+
+export async function setLabelVisibility(
+  labelerDid: string,
+  label: string,
+  visibility: LabelVisibility,
+) {
+  const current = $preferences.get();
+  const filtered = current.labelPreferences.filter(
+    (p) => !(p.labelerDid === labelerDid && p.label === label),
+  );
+  const newPrefs =
+    visibility === "warn"
+      ? filtered
+      : [...filtered, { labelerDid, label, visibility }];
+  const updated = { ...current, labelPreferences: newPrefs };
+  $preferences.set(updated);
+  await updatePreferences(updated);
+}
+
+export function getLabelVisibility(
+  labelerDid: string,
+  label: string,
+): LabelVisibility {
+  const prefs = $preferences.get();
+  const pref = prefs.labelPreferences.find(
+    (p) => p.labelerDid === labelerDid && p.label === label,
+  );
+  return pref?.visibility || "warn";
 }

web/src/types.ts

···
   followersCount?: number;
   followsCount?: number;
   postsCount?: number;
+  labels?: ContentLabel[];
 }
 
 export interface Selector {
···
     };
   };
   parentUri?: string;
+  labels?: ContentLabel[];
 }
 
 export type ActorSearchItem = UserProfile;
···
   text: string;
   createdAt: string;
 }
+
+export interface ModerationRelationship {
+  blocking: boolean;
+  muting: boolean;
+  blockedBy: boolean;
+}
+
+export interface BlockedUser {
+  did: string;
+  author: UserProfile;
+  createdAt: string;
+}
+
+export interface MutedUser {
+  did: string;
+  author: UserProfile;
+  createdAt: string;
+}
+
+export interface ModerationReport {
+  id: number;
+  reporter: UserProfile;
+  subject: UserProfile;
+  subjectUri?: string;
+  reasonType: string;
+  reasonText?: string;
+  status: string;
+  createdAt: string;
+  resolvedAt?: string;
+  resolvedBy?: string;
+}
+
+export type ReportReasonType =
+  | "spam"
+  | "violation"
+  | "misleading"
+  | "sexual"
+  | "rude"
+  | "other";
+
+export interface ContentLabel {
+  val: string;
+  src: string;
+  scope?: "account" | "content";
+}
+
+export type ContentLabelValue =
+  | "sexual"
+  | "nudity"
+  | "violence"
+  | "gore"
+  | "spam"
+  | "misleading";
+
+export type LabelVisibility = "hide" | "warn" | "ignore";
+
+export interface LabelerSubscription {
+  did: string;
+}
+
+export interface LabelPreference {
+  labelerDid: string;
+  label: string;
+  visibility: LabelVisibility;
+}
+
+export interface LabelDefinition {
+  identifier: string;
+  severity: string;
+  blurs: string;
+  description: string;
+}
+
+export interface LabelerInfo {
+  did: string;
+  name: string;
+  labels: LabelDefinition[];
+}

web/src/views/core/AdminModeration.tsx

···
+import React, { useEffect, useState } from "react";
+import { useStore } from "@nanostores/react";
+import { $user } from "../../store/auth";
+import {
+  checkAdminAccess,
+  getAdminReports,
+  adminTakeAction,
+  adminCreateLabel,
+  adminDeleteLabel,
+  adminGetLabels,
+} from "../../api/client";
+import type { ModerationReport } from "../../types";
+import {
+  Shield,
+  CheckCircle,
+  XCircle,
+  AlertTriangle,
+  Eye,
+  ChevronDown,
+  ChevronUp,
+  Tag,
+  FileText,
+  Plus,
+  Trash2,
+  EyeOff,
+} from "lucide-react";
+import { Avatar, EmptyState, Skeleton, Button } from "../../components/ui";
+import { Link } from "react-router-dom";
+
+const STATUS_COLORS: Record<string, string> = {
+  pending:
+    "bg-amber-100 text-amber-800 dark:bg-amber-900/30 dark:text-amber-300",
+  resolved:
+    "bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300",
+  dismissed:
+    "bg-surface-100 text-surface-600 dark:bg-surface-800 dark:text-surface-400",
+  escalated: "bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-300",
+  acknowledged:
+    "bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-300",
+};
+
+const REASON_LABELS: Record<string, string> = {
+  spam: "Spam",
+  violation: "Rule Violation",
+  misleading: "Misleading",
+  sexual: "Inappropriate",
+  rude: "Rude / Harassing",
+  other: "Other",
+};
+
+const LABEL_OPTIONS = [
+  { val: "sexual", label: "Sexual Content" },
+  { val: "nudity", label: "Nudity" },
+  { val: "violence", label: "Violence" },
+  { val: "gore", label: "Graphic Content" },
+  { val: "spam", label: "Spam" },
+  { val: "misleading", label: "Misleading" },
+];
+
+interface HydratedLabel {
+  id: number;
+  src: string;
+  uri: string;
+  val: string;
+  createdBy: {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+  };
+  createdAt: string;
+  subject?: {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+  };
+}
+
+type Tab = "reports" | "labels" | "actions";
+
+export default function AdminModeration() {
+  const user = useStore($user);
+  const [isAdmin, setIsAdmin] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [activeTab, setActiveTab] = useState<Tab>("reports");
+
+  const [reports, setReports] = useState<ModerationReport[]>([]);
+  const [pendingCount, setPendingCount] = useState(0);
+  const [totalCount, setTotalCount] = useState(0);
+  const [statusFilter, setStatusFilter] = useState<string>("pending");
+  const [expandedReport, setExpandedReport] = useState<number | null>(null);
+  const [actionLoading, setActionLoading] = useState<number | null>(null);
+
+  const [labels, setLabels] = useState<HydratedLabel[]>([]);
+
+  const [labelSrc, setLabelSrc] = useState("");
+  const [labelUri, setLabelUri] = useState("");
+  const [labelVal, setLabelVal] = useState("");
+  const [labelSubmitting, setLabelSubmitting] = useState(false);
+  const [labelSuccess, setLabelSuccess] = useState(false);
+
+  useEffect(() => {
+    const init = async () => {
+      const admin = await checkAdminAccess();
+      setIsAdmin(admin);
+      if (admin) await loadReports("pending");
+      setLoading(false);
+    };
+    init();
+  }, []);
+
+  const loadReports = async (status: string) => {
+    const data = await getAdminReports(status || undefined);
+    setReports(data.items);
+    setPendingCount(data.pendingCount);
+    setTotalCount(data.totalItems);
+  };
+
+  const loadLabels = async () => {
+    const data = await adminGetLabels();
+    setLabels(data.items || []);
+  };
+
+  const handleTabChange = async (tab: Tab) => {
+    setActiveTab(tab);
+    if (tab === "labels") await loadLabels();
+  };
+
+  const handleFilterChange = async (status: string) => {
+    setStatusFilter(status);
+    await loadReports(status);
+  };
+
+  const handleAction = async (reportId: number, action: string) => {
+    setActionLoading(reportId);
+    const success = await adminTakeAction({ reportId, action });
+    if (success) {
+      await loadReports(statusFilter);
+      setExpandedReport(null);
+    }
+    setActionLoading(null);
+  };
+
+  const handleCreateLabel = async () => {
+    if (!labelVal || (!labelSrc && !labelUri)) return;
+    setLabelSubmitting(true);
+    const success = await adminCreateLabel({
+      src: labelSrc || labelUri,
+      uri: labelUri || undefined,
+      val: labelVal,
+    });
+    if (success) {
+      setLabelSrc("");
+      setLabelUri("");
+      setLabelVal("");
+      setLabelSuccess(true);
+      setTimeout(() => setLabelSuccess(false), 2000);
+      if (activeTab === "labels") await loadLabels();
+    }
+    setLabelSubmitting(false);
+  };
+
+  const handleDeleteLabel = async (id: number) => {
+    if (!window.confirm("Remove this label?")) return;
+    const success = await adminDeleteLabel(id);
+    if (success) setLabels((prev) => prev.filter((l) => l.id !== id));
+  };
+
+  if (loading) {
+    return (
+      <div className="max-w-3xl mx-auto animate-slide-up">
+        <Skeleton className="h-8 w-48 mb-6" />
+        <div className="space-y-3">
+          <Skeleton className="h-24 rounded-xl" />
+          <Skeleton className="h-24 rounded-xl" />
+          <Skeleton className="h-24 rounded-xl" />
+        </div>
+      </div>
+    );
+  }
+
+  if (!user || !isAdmin) {
+    return (
+      <EmptyState
+        icon={<Shield size={40} />}
+        title="Access Denied"
+        message="You don't have permission to access the moderation dashboard."
+      />
+    );
+  }
+
+  return (
+    <div className="max-w-3xl mx-auto animate-slide-up">
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-2xl font-display font-bold text-surface-900 dark:text-white flex items-center gap-2.5">
+            <Shield
+              size={24}
+              className="text-primary-600 dark:text-primary-400"
+            />
+            Moderation
+          </h1>
+          <p className="text-sm text-surface-500 dark:text-surface-400 mt-1">
+            {pendingCount} pending · {totalCount} total reports
+          </p>
+        </div>
+      </div>
+
+      <div className="flex gap-1 mb-5 border-b border-surface-200 dark:border-surface-700">
+        {[
+          {
+            id: "reports" as Tab,
+            label: "Reports",
+            icon: <FileText size={15} />,
+          },
+          {
+            id: "actions" as Tab,
+            label: "Actions",
+            icon: <EyeOff size={15} />,
+          },
+          { id: "labels" as Tab, label: "Labels", icon: <Tag size={15} /> },
+        ].map((tab) => (
+          <button
+            key={tab.id}
+            onClick={() => handleTabChange(tab.id)}
+            className={`flex items-center gap-1.5 px-4 py-2.5 text-sm font-medium border-b-2 -mb-px transition-colors ${
+              activeTab === tab.id
+                ? "border-primary-600 text-primary-600 dark:border-primary-400 dark:text-primary-400"
+                : "border-transparent text-surface-500 dark:text-surface-400 hover:text-surface-700 dark:hover:text-surface-300"
+            }`}
+          >
+            {tab.icon}
+            {tab.label}
+          </button>
+        ))}
+      </div>
+
+      {activeTab === "reports" && (
+        <>
+          <div className="flex gap-2 mb-5">
+            {["pending", "resolved", "dismissed", "escalated", ""].map(
+              (status) => (
+                <button
+                  key={status || "all"}
+                  onClick={() => handleFilterChange(status)}
+                  className={`px-3.5 py-1.5 text-sm font-medium rounded-lg transition-colors ${
+                    statusFilter === status
+                      ? "bg-primary-100 text-primary-700 dark:bg-primary-900/30 dark:text-primary-300"
+                      : "text-surface-500 dark:text-surface-400 hover:bg-surface-100 dark:hover:bg-surface-800"
+                  }`}
+                >
+                  {status
+                    ? status.charAt(0).toUpperCase() + status.slice(1)
+                    : "All"}
+                </button>
+              ),
+            )}
+          </div>
+
+          {reports.length === 0 ? (
+            <EmptyState
+              icon={<CheckCircle size={40} />}
+              title="No reports"
+              message={
+                statusFilter === "pending"
+                  ? "No pending reports to review."
+                  : `No ${statusFilter || ""} reports found.`
+              }
+            />
+          ) : (
+            <div className="space-y-3">
+              {reports.map((report) => (
+                <div
+                  key={report.id}
+                  className="card overflow-hidden transition-all"
+                >
+                  <button
+                    onClick={() =>
+                      setExpandedReport(
+                        expandedReport === report.id ? null : report.id,
+                      )
+                    }
+                    className="w-full p-4 flex items-center gap-4 text-left hover:bg-surface-50 dark:hover:bg-surface-800/50 transition-colors"
+                  >
+                    <Avatar
+                      did={report.subject.did}
+                      avatar={report.subject.avatar}
+                      size="sm"
+                    />
+                    <div className="flex-1 min-w-0">
+                      <div className="flex items-center gap-2 mb-0.5">
+                        <span className="font-medium text-surface-900 dark:text-white text-sm truncate">
+                          {report.subject.displayName ||
+                            report.subject.handle ||
+                            report.subject.did}
+                        </span>
+                        <span
+                          className={`text-xs px-2 py-0.5 rounded-full font-medium ${STATUS_COLORS[report.status] || STATUS_COLORS.pending}`}
+                        >
+                          {report.status}
+                        </span>
+                      </div>
+                      <p className="text-xs text-surface-500 dark:text-surface-400">
+                        {REASON_LABELS[report.reasonType] || report.reasonType}{" "}
+                        · reported by @
+                        {report.reporter.handle || report.reporter.did} ·{" "}
+                        {new Date(report.createdAt).toLocaleDateString()}
+                      </p>
+                    </div>
+                    {expandedReport === report.id ? (
+                      <ChevronUp size={16} className="text-surface-400" />
+                    ) : (
+                      <ChevronDown size={16} className="text-surface-400" />
+                    )}
+                  </button>
+
+                  {expandedReport === report.id && (
+                    <div className="px-4 pb-4 border-t border-surface-100 dark:border-surface-800 pt-3 space-y-3">
+                      <div className="grid grid-cols-2 gap-3 text-sm">
+                        <div>
+                          <span className="text-surface-400 dark:text-surface-500 text-xs uppercase tracking-wider">
+                            Reported User
+                          </span>
+                          <Link
+                            to={`/profile/${report.subject.did}`}
+                            className="block mt-1 text-primary-600 dark:text-primary-400 hover:underline font-medium"
+                          >
+                            @{report.subject.handle || report.subject.did}
+                          </Link>
+                        </div>
+                        <div>
+                          <span className="text-surface-400 dark:text-surface-500 text-xs uppercase tracking-wider">
+                            Reporter
+                          </span>
+                          <Link
+                            to={`/profile/${report.reporter.did}`}
+                            className="block mt-1 text-primary-600 dark:text-primary-400 hover:underline font-medium"
+                          >
+                            @{report.reporter.handle || report.reporter.did}
+                          </Link>
+                        </div>
+                      </div>
+
+                      {report.reasonText && (
+                        <div>
+                          <span className="text-surface-400 dark:text-surface-500 text-xs uppercase tracking-wider">
+                            Details
+                          </span>
+                          <p className="text-sm text-surface-700 dark:text-surface-300 mt-1">
+                            {report.reasonText}
+                          </p>
+                        </div>
+                      )}
+
+                      {report.subjectUri && (
+                        <div>
+                          <span className="text-surface-400 dark:text-surface-500 text-xs uppercase tracking-wider">
+                            Content URI
+                          </span>
+                          <p className="text-xs text-surface-500 font-mono mt-1 break-all">
+                            {report.subjectUri}
+                          </p>
+                        </div>
+                      )}
+
+                      {report.status === "pending" && (
+                        <div className="flex items-center gap-2 pt-2">
+                          <Button
+                            size="sm"
+                            variant="secondary"
+                            onClick={() =>
+                              handleAction(report.id, "acknowledge")
+                            }
+                            loading={actionLoading === report.id}
+                            icon={<Eye size={14} />}
+                          >
+                            Acknowledge
+                          </Button>
+                          <Button
+                            size="sm"
+                            variant="secondary"
+                            onClick={() => handleAction(report.id, "dismiss")}
+                            loading={actionLoading === report.id}
+                            icon={<XCircle size={14} />}
+                          >
+                            Dismiss
+                          </Button>
+                          <Button
+                            size="sm"
+                            onClick={() => handleAction(report.id, "takedown")}
+                            loading={actionLoading === report.id}
+                            icon={<AlertTriangle size={14} />}
+                            className="!bg-red-600 hover:!bg-red-700 !text-white"
+                          >
+                            Takedown
+                          </Button>
+                        </div>
+                      )}
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+        </>
+      )}
+
+      {activeTab === "actions" && (
+        <div className="space-y-6">
+          <div className="card p-5">
+            <h3 className="text-base font-semibold text-surface-900 dark:text-white mb-1 flex items-center gap-2">
+              <Tag
+                size={16}
+                className="text-primary-600 dark:text-primary-400"
+              />
+              Apply Content Warning
+            </h3>
+            <p className="text-sm text-surface-500 dark:text-surface-400 mb-4">
+              Add a content warning label to a specific post or account. Users
+              will see a blur overlay with the option to reveal.
+            </p>
+
+            <div className="space-y-3">
+              <div>
+                <label className="block text-xs font-medium text-surface-600 dark:text-surface-400 mb-1.5">
+                  Account DID
+                </label>
+                <input
+                  type="text"
+                  value={labelSrc}
+                  onChange={(e) => setLabelSrc(e.target.value)}
+                  placeholder="did:plc:..."
+                  className="w-full px-3 py-2 text-sm rounded-lg border border-surface-200 dark:border-surface-700 bg-white dark:bg-surface-800 text-surface-900 dark:text-white placeholder:text-surface-400 focus:outline-none focus:ring-2 focus:ring-primary-500/20 focus:border-primary-500"
+                />
+              </div>
+
+              <div>
+                <label className="block text-xs font-medium text-surface-600 dark:text-surface-400 mb-1.5">
+                  Content URI{" "}
+                  <span className="text-surface-400">
+                    (optional — leave empty for account-level label)
+                  </span>
+                </label>
+                <input
+                  type="text"
+                  value={labelUri}
+                  onChange={(e) => setLabelUri(e.target.value)}
+                  placeholder="at://did:plc:.../at.margin.annotation/..."
+                  className="w-full px-3 py-2 text-sm rounded-lg border border-surface-200 dark:border-surface-700 bg-white dark:bg-surface-800 text-surface-900 dark:text-white placeholder:text-surface-400 focus:outline-none focus:ring-2 focus:ring-primary-500/20 focus:border-primary-500"
+                />
+              </div>
+
+              <div>
+                <label className="block text-xs font-medium text-surface-600 dark:text-surface-400 mb-1.5">
+                  Label Type
+                </label>
+                <div className="grid grid-cols-3 gap-2">
+                  {LABEL_OPTIONS.map((opt) => (
+                    <button
+                      key={opt.val}
+                      onClick={() => setLabelVal(opt.val)}
+                      className={`px-3 py-2 text-sm font-medium rounded-lg border transition-all ${
+                        labelVal === opt.val
+                          ? "border-primary-500 bg-primary-50 dark:bg-primary-900/20 text-primary-700 dark:text-primary-300 ring-2 ring-primary-500/20"
+                          : "border-surface-200 dark:border-surface-700 text-surface-600 dark:text-surface-400 hover:bg-surface-50 dark:hover:bg-surface-800"
+                      }`}
+                    >
+                      {opt.label}
+                    </button>
+                  ))}
+                </div>
+              </div>
+
+              <div className="flex items-center gap-3 pt-1">
+                <Button
+                  onClick={handleCreateLabel}
+                  loading={labelSubmitting}
+                  disabled={!labelVal || (!labelSrc && !labelUri)}
+                  icon={<Plus size={14} />}
+                  size="sm"
+                >
+                  Apply Label
+                </Button>
+                {labelSuccess && (
+                  <span className="text-sm text-green-600 dark:text-green-400 flex items-center gap-1.5">
+                    <CheckCircle size={14} /> Label applied
+                  </span>
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {activeTab === "labels" && (
+        <div>
+          {labels.length === 0 ? (
+            <EmptyState
+              icon={<Tag size={40} />}
+              title="No labels"
+              message="No content labels have been applied yet."
+            />
+          ) : (
+            <div className="space-y-2">
+              {labels.map((label) => (
+                <div
+                  key={label.id}
+                  className="card p-4 flex items-center gap-4"
+                >
+                  {label.subject && (
+                    <Avatar
+                      did={label.subject.did}
+                      avatar={label.subject.avatar}
+                      size="sm"
+                    />
+                  )}
+                  <div className="flex-1 min-w-0">
+                    <div className="flex items-center gap-2 mb-0.5">
+                      <span
+                        className={`text-xs px-2 py-0.5 rounded-full font-medium ${
+                          label.val === "sexual" || label.val === "nudity"
+                            ? "bg-pink-100 text-pink-800 dark:bg-pink-900/30 dark:text-pink-300"
+                            : label.val === "violence" || label.val === "gore"
+                              ? "bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-300"
+                              : "bg-amber-100 text-amber-800 dark:bg-amber-900/30 dark:text-amber-300"
+                        }`}
+                      >
+                        {label.val}
+                      </span>
+                      {label.subject && (
+                        <Link
+                          to={`/profile/${label.subject.did}`}
+                          className="text-sm font-medium text-surface-900 dark:text-white hover:text-primary-600 dark:hover:text-primary-400 truncate"
+                        >
+                          @{label.subject.handle || label.subject.did}
+                        </Link>
+                      )}
+                    </div>
+                    <p className="text-xs text-surface-500 dark:text-surface-400 truncate">
+                      {label.uri !== label.src
+                        ? label.uri
+                        : "Account-level label"}{" "}
+                      · {new Date(label.createdAt).toLocaleDateString()} · by @
+                      {label.createdBy.handle || label.createdBy.did}
+                    </p>
+                  </div>
+                  <button
+                    onClick={() => handleDeleteLabel(label.id)}
+                    className="p-2 rounded-lg text-surface-400 hover:text-red-500 hover:bg-red-50 dark:hover:bg-red-900/20 transition-colors"
+                    title="Remove label"
+                  >
+                    <Trash2 size={14} />
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

web/src/views/core/Settings.tsx

···
 import { $user, logout } from "../../store/auth";
 import { $theme, setTheme, type Theme } from "../../store/theme";
 import {
+  $preferences,
+  loadPreferences,
+  addLabeler,
+  removeLabeler,
+  setLabelVisibility,
+  getLabelVisibility,
+} from "../../store/preferences";
+import {
   getAPIKeys,
   createAPIKey,
   deleteAPIKey,
+  getBlocks,
+  getMutes,
+  unblockUser,
+  unmuteUser,
+  getLabelerInfo,
   type APIKey,
 } from "../../api/client";
+import type {
+  BlockedUser,
+  MutedUser,
+  LabelerInfo,
+  LabelVisibility as LabelVisibilityType,
+  ContentLabelValue,
+} from "../../types";
 import {
   Copy,
   Trash2,
···
   Monitor,
   LogOut,
   ChevronRight,
+  ShieldBan,
+  VolumeX,
+  ShieldOff,
+  Volume2,
+  Shield,
+  Eye,
+  EyeOff,
+  XCircle,
 } from "lucide-react";
 import {
   Avatar,
···
   EmptyState,
 } from "../../components/ui";
 import { AppleIcon } from "../../components/common/Icons";
+import { Link } from "react-router-dom";
 
 export default function Settings() {
   const user = useStore($user);
···
   const [createdKey, setCreatedKey] = useState<string | null>(null);
   const [justCopied, setJustCopied] = useState(false);
   const [creating, setCreating] = useState(false);
+  const [blocks, setBlocks] = useState<BlockedUser[]>([]);
+  const [mutes, setMutes] = useState<MutedUser[]>([]);
+  const [modLoading, setModLoading] = useState(true);
+  const [labelerInfo, setLabelerInfo] = useState<LabelerInfo | null>(null);
+  const [newLabelerDid, setNewLabelerDid] = useState("");
+  const [addingLabeler, setAddingLabeler] = useState(false);
+  const preferences = useStore($preferences);
 
   useEffect(() => {
     const loadKeys = async () => {
···
       setLoading(false);
     };
     loadKeys();
+
+    const loadModeration = async () => {
+      setModLoading(true);
+      const [blocksData, mutesData] = await Promise.all([
+        getBlocks(),
+        getMutes(),
+      ]);
+      setBlocks(blocksData);
+      setMutes(mutesData);
+      setModLoading(false);
+    };
+    loadModeration();
+
+    loadPreferences();
+    getLabelerInfo().then(setLabelerInfo);
   }, []);
 
   const handleCreate = async (e: React.FormEvent) => {
···
               ))}
             </div>
           )}
+        </section>
+
+        <section className="card p-5">
+          <h2 className="text-xs font-semibold text-surface-500 dark:text-surface-400 uppercase tracking-wider mb-1">
+            Moderation
+          </h2>
+          <p className="text-sm text-surface-400 dark:text-surface-500 mb-5">
+            Manage blocked and muted accounts
+          </p>
+
+          {modLoading ? (
+            <div className="space-y-3">
+              <Skeleton className="h-14 rounded-xl" />
+              <Skeleton className="h-14 rounded-xl" />
+            </div>
+          ) : (
+            <div className="space-y-4">
+              <div>
+                <h3 className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-2 flex items-center gap-2">
+                  <ShieldBan size={14} />
+                  Blocked accounts ({blocks.length})
+                </h3>
+                {blocks.length === 0 ? (
+                  <p className="text-sm text-surface-400 dark:text-surface-500 pl-6">
+                    No blocked accounts
+                  </p>
+                ) : (
+                  <div className="space-y-1.5">
+                    {blocks.map((b) => (
+                      <div
+                        key={b.did}
+                        className="flex items-center justify-between p-3 bg-surface-50 dark:bg-surface-800 rounded-xl group hover:bg-surface-100 dark:hover:bg-surface-700 transition-all"
+                      >
+                        <Link
+                          to={`/profile/${b.did}`}
+                          className="flex items-center gap-3 min-w-0 flex-1"
+                        >
+                          <Avatar
+                            did={b.did}
+                            avatar={b.author?.avatar}
+                            size="sm"
+                          />
+                          <div className="min-w-0">
+                            <p className="font-medium text-surface-900 dark:text-white text-sm truncate">
+                              {b.author?.displayName ||
+                                b.author?.handle ||
+                                b.did}
+                            </p>
+                            {b.author?.handle && (
+                              <p className="text-xs text-surface-400 dark:text-surface-500 truncate">
+                                @{b.author.handle}
+                              </p>
+                            )}
+                          </div>
+                        </Link>
+                        <button
+                          onClick={async () => {
+                            await unblockUser(b.did);
+                            setBlocks((prev) =>
+                              prev.filter((x) => x.did !== b.did),
+                            );
+                          }}
+                          className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium text-surface-500 hover:text-red-600 dark:hover:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20 rounded-lg transition-all opacity-0 group-hover:opacity-100"
+                        >
+                          <ShieldOff size={12} />
+                          Unblock
+                        </button>
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </div>
+
+              <div>
+                <h3 className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-2 flex items-center gap-2">
+                  <VolumeX size={14} />
+                  Muted accounts ({mutes.length})
+                </h3>
+                {mutes.length === 0 ? (
+                  <p className="text-sm text-surface-400 dark:text-surface-500 pl-6">
+                    No muted accounts
+                  </p>
+                ) : (
+                  <div className="space-y-1.5">
+                    {mutes.map((m) => (
+                      <div
+                        key={m.did}
+                        className="flex items-center justify-between p-3 bg-surface-50 dark:bg-surface-800 rounded-xl group hover:bg-surface-100 dark:hover:bg-surface-700 transition-all"
+                      >
+                        <Link
+                          to={`/profile/${m.did}`}
+                          className="flex items-center gap-3 min-w-0 flex-1"
+                        >
+                          <Avatar
+                            did={m.did}
+                            avatar={m.author?.avatar}
+                            size="sm"
+                          />
+                          <div className="min-w-0">
+                            <p className="font-medium text-surface-900 dark:text-white text-sm truncate">
+                              {m.author?.displayName ||
+                                m.author?.handle ||
+                                m.did}
+                            </p>
+                            {m.author?.handle && (
+                              <p className="text-xs text-surface-400 dark:text-surface-500 truncate">
+                                @{m.author.handle}
+                              </p>
+                            )}
+                          </div>
+                        </Link>
+                        <button
+                          onClick={async () => {
+                            await unmuteUser(m.did);
+                            setMutes((prev) =>
+                              prev.filter((x) => x.did !== m.did),
+                            );
+                          }}
+                          className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium text-surface-500 hover:text-amber-600 dark:hover:text-amber-400 hover:bg-amber-50 dark:hover:bg-amber-900/20 rounded-lg transition-all opacity-0 group-hover:opacity-100"
+                        >
+                          <Volume2 size={12} />
+                          Unmute
+                        </button>
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </div>
+            </div>
+          )}
+        </section>
+
+        <section className="card p-5">
+          <h2 className="text-xs font-semibold text-surface-500 dark:text-surface-400 uppercase tracking-wider mb-1">
+            Content Filtering
+          </h2>
+          <p className="text-sm text-surface-400 dark:text-surface-500 mb-5">
+            Subscribe to labelers and configure how labeled content appears
+          </p>
+
+          <div className="space-y-5">
+            <div>
+              <h3 className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-3 flex items-center gap-2">
+                <Shield size={14} />
+                Subscribed Labelers
+              </h3>
+
+              {preferences.subscribedLabelers.length === 0 ? (
+                <p className="text-sm text-surface-400 dark:text-surface-500 pl-6 mb-3">
+                  No labelers subscribed
+                </p>
+              ) : (
+                <div className="space-y-1.5 mb-3">
+                  {preferences.subscribedLabelers.map((labeler) => (
+                    <div
+                      key={labeler.did}
+                      className="flex items-center justify-between p-3 bg-surface-50 dark:bg-surface-800 rounded-xl group hover:bg-surface-100 dark:hover:bg-surface-700 transition-all"
+                    >
+                      <div className="flex items-center gap-3 min-w-0 flex-1">
+                        <div className="p-2 bg-primary-100 dark:bg-primary-900/30 rounded-lg">
+                          <Shield
+                            size={14}
+                            className="text-primary-600 dark:text-primary-400"
+                          />
+                        </div>
+                        <div className="min-w-0">
+                          <p className="font-medium text-surface-900 dark:text-white text-sm truncate">
+                            {labelerInfo?.did === labeler.did
+                              ? labelerInfo.name
+                              : labeler.did}
+                          </p>
+                          <p className="text-xs text-surface-400 dark:text-surface-500 truncate font-mono">
+                            {labeler.did}
+                          </p>
+                        </div>
+                      </div>
+                      <button
+                        onClick={() => removeLabeler(labeler.did)}
+                        className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium text-surface-500 hover:text-red-600 dark:hover:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20 rounded-lg transition-all opacity-0 group-hover:opacity-100"
+                      >
+                        <XCircle size={12} />
+                        Remove
+                      </button>
+                    </div>
+                  ))}
+                </div>
+              )}
+
+              <form
+                onSubmit={async (e) => {
+                  e.preventDefault();
+                  if (!newLabelerDid.trim()) return;
+                  setAddingLabeler(true);
+                  await addLabeler(newLabelerDid.trim());
+                  setNewLabelerDid("");
+                  setAddingLabeler(false);
+                }}
+                className="flex gap-2"
+              >
+                <div className="flex-1">
+                  <Input
+                    value={newLabelerDid}
+                    onChange={(e) => setNewLabelerDid(e.target.value)}
+                    placeholder="did:plc:... (labeler DID)"
+                  />
+                </div>
+                <Button
+                  type="submit"
+                  disabled={!newLabelerDid.trim()}
+                  loading={addingLabeler}
+                  icon={<Plus size={16} />}
+                >
+                  Add
+                </Button>
+              </form>
+            </div>
+
+            {preferences.subscribedLabelers.length > 0 && (
+              <div>
+                <h3 className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-3 flex items-center gap-2">
+                  <Eye size={14} />
+                  Label Visibility
+                </h3>
+                <p className="text-xs text-surface-400 dark:text-surface-500 mb-3 pl-6">
+                  Choose how to handle each label type: <strong>Warn</strong>{" "}
+                  shows a blur overlay, <strong>Hide</strong> removes content
+                  entirely, <strong>Ignore</strong> shows content normally.
+                </p>
+
+                <div className="space-y-4">
+                  {preferences.subscribedLabelers.map((labeler) => {
+                    const labels: ContentLabelValue[] = [
+                      "sexual",
+                      "nudity",
+                      "violence",
+                      "gore",
+                      "spam",
+                      "misleading",
+                    ];
+                    return (
+                      <div
+                        key={labeler.did}
+                        className="bg-surface-50 dark:bg-surface-800 rounded-xl p-4"
+                      >
+                        <p className="text-sm font-medium text-surface-700 dark:text-surface-300 mb-3 truncate">
+                          {labelerInfo?.did === labeler.did
+                            ? labelerInfo.name
+                            : labeler.did}
+                        </p>
+                        <div className="space-y-2">
+                          {labels.map((label) => {
+                            const current = getLabelVisibility(
+                              labeler.did,
+                              label,
+                            );
+                            const options: {
+                              value: LabelVisibilityType;
+                              label: string;
+                              icon: typeof Eye;
+                            }[] = [
+                              { value: "warn", label: "Warn", icon: EyeOff },
+                              { value: "hide", label: "Hide", icon: XCircle },
+                              { value: "ignore", label: "Ignore", icon: Eye },
+                            ];
+                            return (
+                              <div
+                                key={label}
+                                className="flex items-center justify-between py-1.5"
+                              >
+                                <span className="text-sm text-surface-600 dark:text-surface-400 capitalize">
+                                  {label}
+                                </span>
+                                <div className="flex gap-1">
+                                  {options.map((opt) => (
+                                    <button
+                                      key={opt.value}
+                                      onClick={() =>
+                                        setLabelVisibility(
+                                          labeler.did,
+                                          label,
+                                          opt.value,
+                                        )
+                                      }
+                                      className={`px-2.5 py-1 text-xs font-medium rounded-lg transition-all flex items-center gap-1 ${
+                                        current === opt.value
+                                          ? opt.value === "hide"
+                                            ? "bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-400"
+                                            : opt.value === "warn"
+                                              ? "bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-400"
+                                              : "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-400"
+                                          : "text-surface-400 dark:text-surface-500 hover:bg-surface-200 dark:hover:bg-surface-700"
+                                      }`}
+                                    >
+                                      <opt.icon size={12} />
+                                      {opt.label}
+                                    </button>
+                                  ))}
+                                </div>
+                              </div>
+                            );
+                          })}
+                        </div>
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+            )}
+          </div>
         </section>
 
         <section className="card p-5">

web/src/views/profile/Profile.tsx

···
 import React, { useEffect, useState } from "react";
-import { getProfile, getFeed, getCollections } from "../../api/client";
+import {
+  getProfile,
+  getFeed,
+  getCollections,
+  blockUser,
+  unblockUser,
+  muteUser,
+  unmuteUser,
+} from "../../api/client";
 import Card from "../../components/common/Card";
 import RichText from "../../components/common/RichText";
+import MoreMenu from "../../components/common/MoreMenu";
+import type { MoreMenuItem } from "../../components/common/MoreMenu";
+import ReportModal from "../../components/modals/ReportModal";
 import {
   Edit2,
   Github,
···
   PenTool,
   Bookmark,
   Link2,
+  ShieldBan,
+  VolumeX,
+  Flag,
+  ShieldOff,
+  Volume2,
+  EyeOff,
+  Eye,
 } from "lucide-react";
 import { TangledIcon } from "../../components/common/Icons";
-import type { UserProfile, AnnotationItem, Collection } from "../../types";
+import type {
+  UserProfile,
+  AnnotationItem,
+  Collection,
+  ModerationRelationship,
+  ContentLabel,
+  LabelVisibility,
+} from "../../types";
 import { useStore } from "@nanostores/react";
 import { $user } from "../../store/auth";
 import EditProfileModal from "../../components/modals/EditProfileModal";
···
 import CollectionIcon from "../../components/common/CollectionIcon";
 import { $preferences, loadPreferences } from "../../store/preferences";
 import { Link } from "react-router-dom";
+import { clsx } from "clsx";
 import {
   Avatar,
   Tabs,
···
   const isOwner = user?.did === did;
   const [showEdit, setShowEdit] = useState(false);
   const [externalLink, setExternalLink] = useState<string | null>(null);
+  const [showReportModal, setShowReportModal] = useState(false);
+  const [modRelation, setModRelation] = useState<ModerationRelationship>({
+    blocking: false,
+    muting: false,
+    blockedBy: false,
+  });
+  const [accountLabels, setAccountLabels] = useState<ContentLabel[]>([]);
+  const [profileRevealed, setProfileRevealed] = useState(false);
+  const preferences = useStore($preferences);
 
   const formatLinkText = (url: string) => {
     try {
···
           postsCount: bskyData?.postsCount || marginData?.postsCount,
         };
 
+        if (marginData?.labels && Array.isArray(marginData.labels)) {
+          setAccountLabels(marginData.labels);
+        }
+
         setProfile(merged);
+
+        if (user && user.did !== did) {
+          try {
+            const { getModerationRelationship } =
+              await import("../../api/client");
+            const rel = await getModerationRelationship(did);
+            setModRelation(rel);
+          } catch {
+            // ignore
+          }
+        }
       } catch (e) {
         console.error("Profile load failed", e);
       } finally {
···
         ? highlights
         : bookmarks;
 
+  const LABEL_DESCRIPTIONS: Record<string, string> = {
+    sexual: "Sexual Content",
+    nudity: "Nudity",
+    violence: "Violence",
+    gore: "Graphic Content",
+    spam: "Spam",
+    misleading: "Misleading",
+  };
+
+  const accountWarning = (() => {
+    if (!accountLabels.length) return null;
+    const priority = [
+      "gore",
+      "violence",
+      "nudity",
+      "sexual",
+      "misleading",
+      "spam",
+    ];
+    for (const p of priority) {
+      const match = accountLabels.find((l) => l.val === p);
+      if (match) {
+        const pref = preferences.labelPreferences.find(
+          (lp) => lp.label === p && lp.labelerDid === match.src,
+        );
+        const visibility = pref?.visibility || "warn";
+        if (visibility === "ignore") continue;
+        return {
+          label: p,
+          description: LABEL_DESCRIPTIONS[p] || p,
+          visibility,
+        };
+      }
+    }
+    return null;
+  })();
+
+  const shouldBlurAvatar = accountWarning && !profileRevealed;
+
   return (
     <div className="max-w-2xl mx-auto animate-slide-up">
       <div className="card p-5 mb-4">
         <div className="flex items-start gap-4">
-          <Avatar
-            did={profile.did}
-            avatar={profile.avatar}
-            size="xl"
-            className="ring-4 ring-surface-100 dark:ring-surface-800"
-          />
+          <div className="relative">
+            <div className="rounded-full overflow-hidden">
+              <div
+                className={clsx(
+                  "transition-all",
+                  shouldBlurAvatar && "blur-lg",
+                )}
+              >
+                <Avatar
+                  did={profile.did}
+                  avatar={profile.avatar}
+                  size="xl"
+                  className="ring-4 ring-surface-100 dark:ring-surface-800"
+                />
+              </div>
+            </div>
+          </div>
 
           <div className="flex-1 min-w-0">
             <div className="flex items-start justify-between gap-3">
···
                   @{profile.handle}
                 </p>
               </div>
-              {isOwner && (
-                <Button
-                  variant="secondary"
-                  size="sm"
-                  onClick={() => setShowEdit(true)}
-                  icon={<Edit2 size={14} />}
-                >
-                  <span className="hidden sm:inline">Edit</span>
-                </Button>
-              )}
+              <div className="flex items-center gap-2">
+                {isOwner && (
+                  <Button
+                    variant="secondary"
+                    size="sm"
+                    onClick={() => setShowEdit(true)}
+                    icon={<Edit2 size={14} />}
+                  >
+                    <span className="hidden sm:inline">Edit</span>
+                  </Button>
+                )}
+                {!isOwner && user && (
+                  <MoreMenu
+                    items={(() => {
+                      const items: MoreMenuItem[] = [];
+                      if (modRelation.blocking) {
+                        items.push({
+                          label: `Unblock @${profile.handle || "user"}`,
+                          icon: <ShieldOff size={14} />,
+                          onClick: async () => {
+                            await unblockUser(did);
+                            setModRelation((prev) => ({
+                              ...prev,
+                              blocking: false,
+                            }));
+                          },
+                        });
+                      } else {
+                        items.push({
+                          label: `Block @${profile.handle || "user"}`,
+                          icon: <ShieldBan size={14} />,
+                          onClick: async () => {
+                            await blockUser(did);
+                            setModRelation((prev) => ({
+                              ...prev,
+                              blocking: true,
+                            }));
+                          },
+                          variant: "danger",
+                        });
+                      }
+                      if (modRelation.muting) {
+                        items.push({
+                          label: `Unmute @${profile.handle || "user"}`,
+                          icon: <Volume2 size={14} />,
+                          onClick: async () => {
+                            await unmuteUser(did);
+                            setModRelation((prev) => ({
+                              ...prev,
+                              muting: false,
+                            }));
+                          },
+                        });
+                      } else {
+                        items.push({
+                          label: `Mute @${profile.handle || "user"}`,
+                          icon: <VolumeX size={14} />,
+                          onClick: async () => {
+                            await muteUser(did);
+                            setModRelation((prev) => ({
+                              ...prev,
+                              muting: true,
+                            }));
+                          },
+                        });
+                      }
+                      items.push({
+                        label: "Report",
+                        icon: <Flag size={14} />,
+                        onClick: () => setShowReportModal(true),
+                        variant: "danger",
+                      });
+                      return items;
+                    })()}
+                  />
+                )}
+              </div>
             </div>
 
             {profile.description && (
···
         </div>
       </div>
 
+      {accountWarning && (
+        <div className="card p-4 mb-4 border-amber-200 dark:border-amber-800/50 bg-amber-50/50 dark:bg-amber-900/10">
+          <div className="flex items-center gap-3">
+            <EyeOff size={18} className="text-amber-500 flex-shrink-0" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-amber-700 dark:text-amber-400">
+                Account labeled: {accountWarning.description}
+              </p>
+              <p className="text-xs text-amber-600/70 dark:text-amber-400/60 mt-0.5">
+                This label was applied by a moderation service you subscribe to.
+              </p>
+            </div>
+            {!profileRevealed ? (
+              <button
+                onClick={() => setProfileRevealed(true)}
+                className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium text-amber-600 dark:text-amber-400 hover:bg-amber-100 dark:hover:bg-amber-900/30 rounded-lg transition-colors"
+              >
+                <Eye size={12} />
+                Show
+              </button>
+            ) : (
+              <button
+                onClick={() => setProfileRevealed(false)}
+                className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium text-amber-600 dark:text-amber-400 hover:bg-amber-100 dark:hover:bg-amber-900/30 rounded-lg transition-colors"
+              >
+                <EyeOff size={12} />
+                Hide
+              </button>
+            )}
+          </div>
+        </div>
+      )}
+
+      {modRelation.blocking && (
+        <div className="card p-4 mb-4 border-red-200 dark:border-red-800/50 bg-red-50/50 dark:bg-red-900/10">
+          <div className="flex items-center gap-3">
+            <ShieldBan size={18} className="text-red-500 flex-shrink-0" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-red-700 dark:text-red-400">
+                You have blocked @{profile.handle}
+              </p>
+              <p className="text-xs text-red-600/70 dark:text-red-400/60 mt-0.5">
+                Their content is hidden from your feeds.
+              </p>
+            </div>
+            <button
+              onClick={async () => {
+                await unblockUser(did);
+                setModRelation((prev) => ({ ...prev, blocking: false }));
+              }}
+              className="px-3 py-1.5 text-xs font-medium text-red-600 dark:text-red-400 hover:bg-red-100 dark:hover:bg-red-900/30 rounded-lg transition-colors"
+            >
+              Unblock
+            </button>
+          </div>
+        </div>
+      )}
+
+      {modRelation.muting && !modRelation.blocking && (
+        <div className="card p-4 mb-4 border-amber-200 dark:border-amber-800/50 bg-amber-50/50 dark:bg-amber-900/10">
+          <div className="flex items-center gap-3">
+            <VolumeX size={18} className="text-amber-500 flex-shrink-0" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-amber-700 dark:text-amber-400">
+                You have muted @{profile.handle}
+              </p>
+              <p className="text-xs text-amber-600/70 dark:text-amber-400/60 mt-0.5">
+                Their content is hidden from your feeds.
+              </p>
+            </div>
+            <button
+              onClick={async () => {
+                await unmuteUser(did);
+                setModRelation((prev) => ({ ...prev, muting: false }));
+              }}
+              className="px-3 py-1.5 text-xs font-medium text-amber-600 dark:text-amber-400 hover:bg-amber-100 dark:hover:bg-amber-900/30 rounded-lg transition-colors"
+            >
+              Unmute
+            </button>
+          </div>
+        </div>
+      )}
+
+      {modRelation.blockedBy && !modRelation.blocking && (
+        <div className="card p-4 mb-4 border-surface-200 dark:border-surface-700">
+          <div className="flex items-center gap-3">
+            <ShieldBan size={18} className="text-surface-400 flex-shrink-0" />
+            <p className="text-sm text-surface-500 dark:text-surface-400">
+              @{profile.handle} has blocked you. You cannot interact with their
+              content.
+            </p>
+          </div>
+        </div>
+      )}
+
       <Tabs
         tabs={tabs}
         activeTab={activeTab}
···
         isOpen={!!externalLink}
         onClose={() => setExternalLink(null)}
         url={externalLink}
+      />
+
+      <ReportModal
+        isOpen={showReportModal}
+        onClose={() => setShowReportModal(false)}
+        subjectDid={did}
+        subjectHandle={profile?.handle}
       />
     </div>
   );