fix various bugs

backend/internal/api/annotations.go

···
 	}
 
 	record := xrpc.NewAnnotationRecordWithMotivation(req.URL, urlHash, req.Text, req.Selector, req.Title, motivation)
+	if len(req.Tags) > 0 {
+		record.Tags = req.Tags
+	}
 
 	var result *xrpc.CreateRecordOutput
 	err = s.refresher.ExecuteWithAutoRefresh(r, session, func(client *xrpc.Client, did string) error {
···
 		selectorJSONPtr = &selectorStr
 	}
 
+	var tagsJSONPtr *string
+	if len(req.Tags) > 0 {
+		tagsBytes, _ := json.Marshal(req.Tags)
+		tagsStr := string(tagsBytes)
+		tagsJSONPtr = &tagsStr
+	}
+
 	cid := result.CID
 	did := session.DID
 	annotation := &db.Annotation{
···
 		TargetHash:   urlHash,
 		TargetTitle:  targetTitlePtr,
 		SelectorJSON: selectorJSONPtr,
+		TagsJSON:     tagsJSONPtr,
 		CreatedAt:    time.Now(),
 		IndexedAt:    time.Now(),
 	}
···
 	}
 	rkey := parts[2]
 
-	var selector interface{} = nil
-	if annotation.SelectorJSON != nil && *annotation.SelectorJSON != "" {
-		json.Unmarshal([]byte(*annotation.SelectorJSON), &selector)
-	}
-
 	tagsJSON := ""
 	if len(req.Tags) > 0 {
 		tagsBytes, _ := json.Marshal(req.Tags)
 		tagsJSON = string(tagsBytes)
 	}
 
-	record := map[string]interface{}{
-		"$type":     xrpc.CollectionAnnotation,
-		"text":      req.Text,
-		"url":       annotation.TargetSource,
-		"createdAt": annotation.CreatedAt.Format(time.RFC3339),
-	}
-	if selector != nil {
-		record["selector"] = selector
-	}
-	if len(req.Tags) > 0 {
-		record["tags"] = req.Tags
-	}
-	if annotation.TargetTitle != nil {
-		record["title"] = *annotation.TargetTitle
-	}
-
 	if annotation.BodyValue != nil {
 		previousContent := *annotation.BodyValue
 		s.db.SaveEditHistory(uri, "annotation", previousContent, annotation.CID)
···
 
 	var result *xrpc.PutRecordOutput
 	err = s.refresher.ExecuteWithAutoRefresh(r, session, func(client *xrpc.Client, did string) error {
+		existing, getErr := client.GetRecord(r.Context(), did, xrpc.CollectionAnnotation, rkey)
+		if getErr != nil {
+			return fmt.Errorf("failed to fetch existing record: %w", getErr)
+		}
+
+		var record map[string]interface{}
+		if err := json.Unmarshal(existing.Value, &record); err != nil {
+			return fmt.Errorf("failed to parse existing record: %w", err)
+		}
+
+		record["text"] = req.Text
+		if req.Tags != nil {
+			record["tags"] = req.Tags
+		} else {
+			delete(record, "tags")
+		}
+
 		var updateErr error
 		result, updateErr = client.PutRecord(r.Context(), did, xrpc.CollectionAnnotation, rkey, record)
 		if updateErr != nil {

backend/internal/api/collections.go

···
 
 	enrichedItems := make([]EnrichedCollectionItem, 0, len(items))
 
+	session, err := s.refresher.GetSessionWithAutoRefresh(r)
+	viewerDID := ""
+	if err == nil {
+		viewerDID = session.DID
+	}
+
 	for _, item := range items {
 		enriched := EnrichedCollectionItem{
 			URI:           item.URI,
···
 		if strings.Contains(item.AnnotationURI, "at.margin.annotation") {
 			enriched.Type = "annotation"
 			if a, err := s.db.GetAnnotationByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateAnnotations([]db.Annotation{*a})
+				hydrated, _ := hydrateAnnotations(s.db, []db.Annotation{*a}, viewerDID)
 				if len(hydrated) > 0 {
 					enriched.Annotation = &hydrated[0]
 				}
···
 		} else if strings.Contains(item.AnnotationURI, "at.margin.highlight") {
 			enriched.Type = "highlight"
 			if h, err := s.db.GetHighlightByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateHighlights([]db.Highlight{*h})
+				hydrated, _ := hydrateHighlights(s.db, []db.Highlight{*h}, viewerDID)
 				if len(hydrated) > 0 {
 					enriched.Highlight = &hydrated[0]
 				}
···
 		} else if strings.Contains(item.AnnotationURI, "at.margin.bookmark") {
 			enriched.Type = "bookmark"
 			if b, err := s.db.GetBookmarkByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateBookmarks([]db.Bookmark{*b})
+				hydrated, _ := hydrateBookmarks(s.db, []db.Bookmark{*b}, viewerDID)
 				if len(hydrated) > 0 {
 					enriched.Bookmark = &hydrated[0]
 				}

backend/internal/api/handler.go

···
 		return
 	}
 
-	enriched, _ := hydrateAnnotations(annotations)
+	enriched, _ := hydrateAnnotations(h.db, annotations, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 			bookmarks, _ = h.db.GetBookmarksByTag(tag, limit, 0)
 			collectionItems = []db.CollectionItem{}
 		}
+	} else if creator != "" {
+		annotations, _ = h.db.GetAnnotationsByAuthor(creator, limit, 0)
+		highlights, _ = h.db.GetHighlightsByAuthor(creator, limit, 0)
+		bookmarks, _ = h.db.GetBookmarksByAuthor(creator, limit, 0)
+		collectionItems = []db.CollectionItem{}
 	} else {
 		annotations, _ = h.db.GetRecentAnnotations(limit, 0)
 		highlights, _ = h.db.GetRecentHighlights(limit, 0)
···
 		}
 	}
 
-	authAnnos, _ := hydrateAnnotations(annotations)
-	authHighs, _ := hydrateHighlights(highlights)
-	authBooks, _ := hydrateBookmarks(bookmarks)
+	viewerDID := h.getViewerDID(r)
+	authAnnos, _ := hydrateAnnotations(h.db, annotations, viewerDID)
+	authHighs, _ := hydrateHighlights(h.db, highlights, viewerDID)
+	authBooks, _ := hydrateBookmarks(h.db, bookmarks, viewerDID)
 
-	authCollectionItems, _ := hydrateCollectionItems(h.db, collectionItems)
+	authCollectionItems, _ := hydrateCollectionItems(h.db, collectionItems, viewerDID)
 
 	var feed []interface{}
 	for _, a := range authAnnos {
···
 	}
 
 	if annotation, err := h.db.GetAnnotationByURI(uri); err == nil {
-		if enriched, _ := hydrateAnnotations([]db.Annotation{*annotation}); len(enriched) > 0 {
+		if enriched, _ := hydrateAnnotations(h.db, []db.Annotation{*annotation}, h.getViewerDID(r)); len(enriched) > 0 {
 			serveResponse(enriched[0], "http://www.w3.org/ns/anno.jsonld")
 			return
 		}
 	}
 
 	if highlight, err := h.db.GetHighlightByURI(uri); err == nil {
-		if enriched, _ := hydrateHighlights([]db.Highlight{*highlight}); len(enriched) > 0 {
+		if enriched, _ := hydrateHighlights(h.db, []db.Highlight{*highlight}, h.getViewerDID(r)); len(enriched) > 0 {
 			serveResponse(enriched[0], "http://www.w3.org/ns/anno.jsonld")
 			return
 		}
···
 	if strings.Contains(uri, "at.margin.annotation") {
 		highlightURI := strings.Replace(uri, "at.margin.annotation", "at.margin.highlight", 1)
 		if highlight, err := h.db.GetHighlightByURI(highlightURI); err == nil {
-			if enriched, _ := hydrateHighlights([]db.Highlight{*highlight}); len(enriched) > 0 {
+			if enriched, _ := hydrateHighlights(h.db, []db.Highlight{*highlight}, h.getViewerDID(r)); len(enriched) > 0 {
 				serveResponse(enriched[0], "http://www.w3.org/ns/anno.jsonld")
 				return
 			}
···
 	}
 
 	if bookmark, err := h.db.GetBookmarkByURI(uri); err == nil {
-		if enriched, _ := hydrateBookmarks([]db.Bookmark{*bookmark}); len(enriched) > 0 {
+		if enriched, _ := hydrateBookmarks(h.db, []db.Bookmark{*bookmark}, h.getViewerDID(r)); len(enriched) > 0 {
 			serveResponse(enriched[0], "http://www.w3.org/ns/anno.jsonld")
 			return
 		}
···
 	if strings.Contains(uri, "at.margin.annotation") {
 		bookmarkURI := strings.Replace(uri, "at.margin.annotation", "at.margin.bookmark", 1)
 		if bookmark, err := h.db.GetBookmarkByURI(bookmarkURI); err == nil {
-			if enriched, _ := hydrateBookmarks([]db.Bookmark{*bookmark}); len(enriched) > 0 {
+			if enriched, _ := hydrateBookmarks(h.db, []db.Bookmark{*bookmark}, h.getViewerDID(r)); len(enriched) > 0 {
 				serveResponse(enriched[0], "http://www.w3.org/ns/anno.jsonld")
 				return
 			}
···
 	annotations, _ := h.db.GetAnnotationsByTargetHash(urlHash, limit, offset)
 	highlights, _ := h.db.GetHighlightsByTargetHash(urlHash, limit, offset)
 
-	enrichedAnnotations, _ := hydrateAnnotations(annotations)
-	enrichedHighlights, _ := hydrateHighlights(highlights)
+	enrichedAnnotations, _ := hydrateAnnotations(h.db, annotations, h.getViewerDID(r))
+	enrichedHighlights, _ := hydrateHighlights(h.db, highlights, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 		return
 	}
 
-	enriched, _ := hydrateHighlights(highlights)
+	enriched, _ := hydrateHighlights(h.db, highlights, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 		return
 	}
 
-	enriched, _ := hydrateBookmarks(bookmarks)
+	enriched, _ := hydrateBookmarks(h.db, bookmarks, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 		return
 	}
 
-	enriched, _ := hydrateAnnotations(annotations)
+	enriched, _ := hydrateAnnotations(h.db, annotations, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 		return
 	}
 
-	enriched, _ := hydrateHighlights(highlights)
+	enriched, _ := hydrateHighlights(h.db, highlights, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 		return
 	}
 
-	enriched, _ := hydrateBookmarks(bookmarks)
+	enriched, _ := hydrateBookmarks(h.db, bookmarks, h.getViewerDID(r))
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]interface{}{
···
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
 }
+func (h *Handler) getViewerDID(r *http.Request) string {
+	cookie, err := r.Cookie("margin_session")
+	if err != nil {
+		return ""
+	}
+	did, _, _, _, _, err := h.db.GetSession(cookie.Value)
+	if err != nil {
+		return ""
+	}
+	return did
+}

backend/internal/api/hydration.go

···
 }
 
 type APIAnnotation struct {
-	ID         string        `json:"id"`
-	CID        string        `json:"cid"`
-	Type       string        `json:"type"`
-	Motivation string        `json:"motivation,omitempty"`
-	Author     Author        `json:"creator"`
-	Body       *APIBody      `json:"body,omitempty"`
-	Target     APITarget     `json:"target"`
-	Tags       []string      `json:"tags,omitempty"`
-	Generator  *APIGenerator `json:"generator,omitempty"`
-	CreatedAt  time.Time     `json:"created"`
-	IndexedAt  time.Time     `json:"indexed"`
+	ID             string        `json:"id"`
+	CID            string        `json:"cid"`
+	Type           string        `json:"type"`
+	Motivation     string        `json:"motivation,omitempty"`
+	Author         Author        `json:"creator"`
+	Body           *APIBody      `json:"body,omitempty"`
+	Target         APITarget     `json:"target"`
+	Tags           []string      `json:"tags,omitempty"`
+	Generator      *APIGenerator `json:"generator,omitempty"`
+	CreatedAt      time.Time     `json:"created"`
+	IndexedAt      time.Time     `json:"indexed"`
+	LikeCount      int           `json:"likeCount"`
+	ReplyCount     int           `json:"replyCount"`
+	ViewerHasLiked bool          `json:"viewerHasLiked"`
 }
 
 type APIHighlight struct {
-	ID        string    `json:"id"`
-	Type      string    `json:"type"`
-	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"`
+	ID             string    `json:"id"`
+	Type           string    `json:"type"`
+	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"`
 }
 
 type APIBookmark struct {
-	ID          string    `json:"id"`
-	Type        string    `json:"type"`
-	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"`
+	ID             string    `json:"id"`
+	Type           string    `json:"type"`
+	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"`
 }
 
 type APIReply struct {
···
 	ReadAt     *time.Time  `json:"readAt,omitempty"`
 }
 
-func hydrateAnnotations(annotations []db.Annotation) ([]APIAnnotation, error) {
+func hydrateAnnotations(database *db.DB, annotations []db.Annotation, viewerDID string) ([]APIAnnotation, error) {
 	if len(annotations) == 0 {
 		return []APIAnnotation{}, nil
 	}
···
 			CreatedAt: a.CreatedAt,
 			IndexedAt: a.IndexedAt,
 		}
+
+		if database != nil {
+			result[i].LikeCount, _ = database.GetLikeCount(a.URI)
+			result[i].ReplyCount, _ = database.GetReplyCount(a.URI)
+			if viewerDID != "" {
+				if _, err := database.GetLikeByUserAndSubject(viewerDID, a.URI); err == nil {
+					result[i].ViewerHasLiked = true
+				}
+			}
+		}
 	}
 
 	return result, nil
 }
 
-func hydrateHighlights(highlights []db.Highlight) ([]APIHighlight, error) {
+func hydrateHighlights(database *db.DB, highlights []db.Highlight, viewerDID string) ([]APIHighlight, error) {
 	if len(highlights) == 0 {
 		return []APIHighlight{}, nil
 	}
···
 			CreatedAt: h.CreatedAt,
 			CID:       cid,
 		}
+
+		if database != nil {
+			result[i].LikeCount, _ = database.GetLikeCount(h.URI)
+			result[i].ReplyCount, _ = database.GetReplyCount(h.URI)
+			if viewerDID != "" {
+				if _, err := database.GetLikeByUserAndSubject(viewerDID, h.URI); err == nil {
+					result[i].ViewerHasLiked = true
+				}
+			}
+		}
 	}
 
 	return result, nil
 }
 
-func hydrateBookmarks(bookmarks []db.Bookmark) ([]APIBookmark, error) {
+func hydrateBookmarks(database *db.DB, bookmarks []db.Bookmark, viewerDID string) ([]APIBookmark, error) {
 	if len(bookmarks) == 0 {
 		return []APIBookmark{}, nil
 	}
···
 			Tags:        tags,
 			CreatedAt:   b.CreatedAt,
 			CID:         cid,
+		}
+		if database != nil {
+			result[i].LikeCount, _ = database.GetLikeCount(b.URI)
+			result[i].ReplyCount, _ = database.GetReplyCount(b.URI)
+			if viewerDID != "" {
+				if _, err := database.GetLikeByUserAndSubject(viewerDID, b.URI); err == nil {
+					result[i].ViewerHasLiked = true
+				}
+			}
 		}
 	}
 
···
 	return result, nil
 }
 
-func hydrateCollectionItems(database *db.DB, items []db.CollectionItem) ([]APICollectionItem, error) {
+func hydrateCollectionItems(database *db.DB, items []db.CollectionItem, viewerDID string) ([]APICollectionItem, error) {
 	if len(items) == 0 {
 		return []APICollectionItem{}, nil
 	}
···
 
 		if strings.Contains(item.AnnotationURI, "at.margin.annotation") {
 			if a, err := database.GetAnnotationByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateAnnotations([]db.Annotation{*a})
+				hydrated, _ := hydrateAnnotations(database, []db.Annotation{*a}, viewerDID)
 				if len(hydrated) > 0 {
 					apiItem.Annotation = &hydrated[0]
 				}
 			}
 		} else if strings.Contains(item.AnnotationURI, "at.margin.highlight") {
 			if h, err := database.GetHighlightByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateHighlights([]db.Highlight{*h})
+				hydrated, _ := hydrateHighlights(database, []db.Highlight{*h}, viewerDID)
 				if len(hydrated) > 0 {
 					apiItem.Highlight = &hydrated[0]
 				}
 			}
 		} else if strings.Contains(item.AnnotationURI, "at.margin.bookmark") {
 			if b, err := database.GetBookmarkByURI(item.AnnotationURI); err == nil {
-				hydrated, _ := hydrateBookmarks([]db.Bookmark{*b})
+				hydrated, _ := hydrateBookmarks(database, []db.Bookmark{*b}, viewerDID)
 				if len(hydrated) > 0 {
 					apiItem.Bookmark = &hydrated[0]
 				} else {
 					log.Printf("Failed to hydrate bookmark %s: empty hydration result\n", item.AnnotationURI)
 				}
 			} else {
-				log.Printf("GetBookmarkByURI failed for %s: %v\n", item.AnnotationURI, err)
 			}
 		} else {
 			log.Printf("Unknown item type for URI: %s\n", item.AnnotationURI)

backend/internal/db/queries.go

···
 	return count, err
 }
 
+func (db *DB) GetReplyCount(rootURI string) (int, error) {
+	var count int
+	err := db.QueryRow(db.Rebind(`SELECT COUNT(*) FROM replies WHERE root_uri = ?`), rootURI).Scan(&count)
+	return count, err
+}
+
 func (db *DB) GetLikeByUserAndSubject(userDID, subjectURI string) (*Like, error) {
 	var like Like
 	err := db.QueryRow(db.Rebind(`

web/src/api/client.js

···
       tags: item.tags || [],
       createdAt: item.createdAt || item.created,
       cid: item.cid || item.CID,
+      likeCount: item.likeCount || 0,
+      replyCount: item.replyCount || 0,
+      viewerHasLiked: item.viewerHasLiked || false,
     };
   }
 
···
       tags: item.tags || [],
       createdAt: item.createdAt || item.created,
       cid: item.cid || item.CID,
+      likeCount: item.likeCount || 0,
+      replyCount: item.replyCount || 0,
+      viewerHasLiked: item.viewerHasLiked || false,
     };
   }
 
···
       tags: item.tags || [],
       createdAt: item.createdAt || item.created,
       cid: item.cid || item.CID,
+      likeCount: item.likeCount || 0,
+      replyCount: item.replyCount || 0,
+      viewerHasLiked: item.viewerHasLiked || false,
     };
   }
 
···
     tags: item.tags || [],
     createdAt: item.createdAt || item.created,
     cid: item.cid || item.CID,
+    likeCount: item.likeCount || 0,
+    replyCount: item.replyCount || 0,
+    viewerHasLiked: item.viewerHasLiked || false,
   };
 }
 
···
     color: highlight.color,
     tags: highlight.tags || [],
     createdAt: highlight.createdAt || highlight.created,
+    likeCount: highlight.likeCount || 0,
+    replyCount: highlight.replyCount || 0,
+    viewerHasLiked: highlight.viewerHasLiked || false,
   };
 }
 
···
     description: bookmark.description,
     tags: bookmark.tags || [],
     createdAt: bookmark.createdAt || bookmark.created,
+    likeCount: bookmark.likeCount || 0,
+    replyCount: bookmark.replyCount || 0,
+    viewerHasLiked: bookmark.viewerHasLiked || false,
   };
 }
 

web/src/components/AnnotationCard.jsx

···
   const { user, login } = useAuth();
   const data = normalizeAnnotation(annotation);
 
-  const [likeCount, setLikeCount] = useState(0);
-  const [isLiked, setIsLiked] = useState(false);
+  const [likeCount, setLikeCount] = useState(data.likeCount || 0);
+  const [isLiked, setIsLiked] = useState(data.viewerHasLiked || false);
   const [deleting, setDeleting] = useState(false);
   const [isEditing, setIsEditing] = useState(false);
   const [editText, setEditText] = useState(data.text || "");
···
   const [loadingHistory, setLoadingHistory] = useState(false);
 
   const [replies, setReplies] = useState([]);
-  const [replyCount, setReplyCount] = useState(0);
+  const [replyCount, setReplyCount] = useState(data.replyCount || 0);
   const [showReplies, setShowReplies] = useState(false);
   const [replyingTo, setReplyingTo] = useState(null);
   const [replyText, setReplyText] = useState("");
···
 
   const [hasEditHistory, setHasEditHistory] = useState(false);
 
-  useEffect(() => {
-    let mounted = true;
-    async function fetchData() {
-      try {
-        const repliesRes = await getReplies(data.uri);
-        if (mounted && repliesRes.items) {
-          setReplies(repliesRes.items);
-          setReplyCount(repliesRes.items.length);
-        }
-
-        const likeRes = await getLikeCount(data.uri);
-        if (mounted) {
-          if (likeRes.count !== undefined) {
-            setLikeCount(likeRes.count);
-          }
-          if (likeRes.liked !== undefined) {
-            setIsLiked(likeRes.liked);
-          }
-        }
-
-        if (!data.color && !data.description) {
-          try {
-            const history = await getEditHistory(data.uri);
-            if (mounted && history && history.length > 0) {
-              setHasEditHistory(true);
-            }
-          } catch {}
-        }
-      } catch (err) {
-        console.error("Failed to fetch data:", err);
-      }
-    }
-    if (data.uri) {
-      fetchData();
-    }
-    return () => {
-      mounted = false;
-    };
-  }, [data.uri]);
+  useEffect(() => {}, []);
 
   const fetchHistory = async () => {
     if (showHistory) {
···
             rel="noopener noreferrer"
             className="annotation-highlight"
             style={{
-              borderLeftColor: isEditing ? editColor : data.color || "#f59e0b",
+              borderLeftColor: data.color || "#f59e0b",
             }}
           >
             <mark>"{highlightedText}"</mark>
···
           </button>
           <button
             className={`annotation-action ${showReplies ? "active" : ""}`}
-            onClick={() => setShowReplies(!showReplies)}
+            onClick={async () => {
+              if (!showReplies && replies.length === 0) {
+                try {
+                  const res = await getReplies(data.uri);
+                  if (res.items) setReplies(res.items);
+                } catch (err) {
+                  console.error("Failed to load replies:", err);
+                }
+              }
+              setShowReplies(!showReplies);
+            }}
           >
             <MessageIcon size={16} />
             <span>{replyCount > 0 ? `${replyCount}` : "Reply"}</span>

web/src/pages/Feed.jsx

···
 export default function Feed() {
   const [searchParams, setSearchParams] = useSearchParams();
   const tagFilter = searchParams.get("tag");
+  const filter = searchParams.get("filter") || "all";
+
   const [annotations, setAnnotations] = useState([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState(null);
-  const [filter, setFilter] = useState("all");
+
+  const updateFilter = (newFilter) => {
+    setSearchParams(
+      (prev) => {
+        const next = new URLSearchParams(prev);
+        next.set("filter", newFilter);
+        return next;
+      },
+      { replace: true },
+    );
+  };
+
   const [collectionModalState, setCollectionModalState] = useState({
     isOpen: false,
     uri: null,
···
       try {
         setLoading(true);
         let creatorDid = "";
-        if (filter === "my-tags" && user?.did) {
-          creatorDid = user.did;
+
+        if (filter === "my-tags") {
+          if (user?.did) {
+            creatorDid = user.did;
+          } else {
+            setAnnotations([]);
+            setLoading(false);
+            return;
+          }
         }
 
         const data = await getAnnotationFeed(
···
               Filtering by tag: <strong>#{tagFilter}</strong>
             </span>
             <button
-              onClick={() => setSearchParams({})}
+              onClick={() =>
+                setSearchParams((prev) => {
+                  const next = new URLSearchParams(prev);
+                  next.delete("tag");
+                  return next;
+                })
+              }
               className="btn btn-sm"
               style={{ padding: "2px 8px", fontSize: "0.8rem" }}
             >
···
       <div className="feed-filters">
         <button
           className={`filter-tab ${filter === "all" ? "active" : ""}`}
-          onClick={() => setFilter("all")}
+          onClick={() => updateFilter("all")}
         >
           All
         </button>
         {user && (
           <button
             className={`filter-tab ${filter === "my-tags" ? "active" : ""}`}
-            onClick={() => setFilter("my-tags")}
+            onClick={() => updateFilter("my-tags")}
           >
             My Feed
           </button>
         )}
         <button
           className={`filter-tab ${filter === "commenting" ? "active" : ""}`}
-          onClick={() => setFilter("commenting")}
+          onClick={() => updateFilter("commenting")}
         >
           Annotations
         </button>
         <button
           className={`filter-tab ${filter === "highlighting" ? "active" : ""}`}
-          onClick={() => setFilter("highlighting")}
+          onClick={() => updateFilter("highlighting")}
         >
           Highlights
         </button>
         <button
           className={`filter-tab ${filter === "bookmarking" ? "active" : ""}`}
-          onClick={() => setFilter("bookmarking")}
+          onClick={() => updateFilter("bookmarking")}
         >
           Bookmarks
         </button>

web/src/pages/New.jsx

···
 
       <div className="card">
         <Composer
-          url={url || initialUrl}
+          url={
+            (url || initialUrl) && !/^(?:f|ht)tps?:\/\//.test(url || initialUrl)
+              ? `https://${url || initialUrl}`
+              : url || initialUrl
+          }
           selector={initialSelector}
           onSuccess={handleSuccess}
           onCancel={() => navigate(-1)}

web/src/pages/Profile.jsx

···
           </div>
         );
       }
-      return bookmarks.map((b) => <BookmarkCard key={b.id} annotation={b} />);
-    }
-    if (activeTab === "bookmarks") {
-      if (bookmarks.length === 0) {
-        return (
-          <div className="empty-state">
-            <div className="empty-state-icon">
-              <BookmarkIcon size={32} />
-            </div>
-            <h3 className="empty-state-title">No bookmarks</h3>
-            <p className="empty-state-text">
-              This user hasn't bookmarked any pages.
-            </p>
-          </div>
-        );
-      }
-      return bookmarks.map((b) => <BookmarkCard key={b.id} annotation={b} />);
+      return bookmarks.map((b) => <BookmarkCard key={b.uri} bookmark={b} />);
     }
 
     if (activeTab === "collections") {