From e280b91b9ff0dc5996be4654a624816e157faebf Mon Sep 17 00:00:00 2001
From: Sam Clemente <sam@theclementes.com>
Date: Sun, 30 Aug 2026 20:56:14 -0500
Subject: [PATCH 1/3] feat: add read-only research workspace

Adds a responsive Research destination for browsing the linked account's Semble collections and Margin annotations with independent source states and safe external links.
---
 apps/web/components/cms/cms-workspace.tsx     |   3 +
 .../cms/mobile-workspace-footer.tsx           |   7 +-
 apps/web/components/cms/research-section.tsx  | 251 ++++++++++++++++++
 apps/web/components/cms/workspace-header.tsx  |  10 +-
 apps/web/lib/research-api.ts                  |  50 ++++
 apps/web/lib/workspace-navigation.ts          |   4 +-
 apps/web/test/mobile-workspace-ui.test.tsx    |   2 +
 apps/web/test/research-api.test.ts            |  23 ++
 apps/web/test/research-section.test.tsx       | 115 ++++++++
 apps/web/test/workspace-navigation.test.ts    |  10 +
 10 files changed, 469 insertions(+), 6 deletions(-)
 create mode 100644 apps/web/components/cms/research-section.tsx
 create mode 100644 apps/web/lib/research-api.ts
 create mode 100644 apps/web/test/research-api.test.ts
 create mode 100644 apps/web/test/research-section.test.tsx

diff --git a/apps/web/components/cms/cms-workspace.tsx b/apps/web/components/cms/cms-workspace.tsx
index ad34faa..784e88b 100644
--- a/apps/web/components/cms/cms-workspace.tsx
+++ b/apps/web/components/cms/cms-workspace.tsx
@@ -20,6 +20,7 @@ import {
 } from "@/components/cms/post-dialogs";
 import { RightPanel } from "@/components/cms/right-panel";
 import { PublicationsDashboard } from "@/components/cms/publications-dashboard";
+import { ResearchSection } from "@/components/cms/research-section";
 import { WorkspaceHeader } from "@/components/cms/workspace-header";
 import { FeedbackSection } from "@/components/cms/feedback-section";
 import { MobileWorkspaceFooter } from "@/components/cms/mobile-workspace-footer";
@@ -641,6 +642,8 @@ export function CmsWorkspace() {
               isSyncing={isSyncing}
               onSync={syncPublications}
             />
+          ) : activeView === "research" ? (
+            <ResearchSection />
           ) : activeView === "feedback" ? (
             <FeedbackSection account={activeAccount} onReconnect={logOut} />
           ) : (
diff --git a/apps/web/components/cms/mobile-workspace-footer.tsx b/apps/web/components/cms/mobile-workspace-footer.tsx
index ce29430..06d6da5 100644
--- a/apps/web/components/cms/mobile-workspace-footer.tsx
+++ b/apps/web/components/cms/mobile-workspace-footer.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { BookOpenIcon, LibraryIcon, MessageSquareTextIcon, RocketIcon, SaveIcon } from "lucide-react";
+import { BookOpenIcon, LibraryIcon, MessageSquareTextIcon, RocketIcon, SaveIcon, TelescopeIcon } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
 import type { DraftSaveState } from "@/lib/draft-editor";
@@ -51,13 +51,14 @@ export function MobileWorkspaceFooter({
   const views = [
     { value: "posts", label: "Posts", icon: BookOpenIcon },
     { value: "publications", label: "Publications", icon: LibraryIcon },
+    { value: "research", label: "Research", icon: TelescopeIcon },
     { value: "feedback", label: "Feedback", icon: MessageSquareTextIcon },
   ] as const;
 
   return (
     <nav
       aria-label="Mobile workspace"
-      className="z-20 grid shrink-0 grid-cols-3 border-t bg-background/95 px-2 pt-1 pb-[calc(0.25rem+env(safe-area-inset-bottom))] backdrop-blur xl:hidden"
+      className="z-20 grid shrink-0 grid-cols-4 border-t bg-background/95 px-1 pt-1 pb-[calc(0.25rem+env(safe-area-inset-bottom))] backdrop-blur xl:hidden sm:px-2"
     >
       {views.map(({ value, label, icon: Icon }) => (
         <button
@@ -67,7 +68,7 @@ export function MobileWorkspaceFooter({
           aria-current={activeView === value ? "page" : undefined}
           onClick={() => onViewChange(value)}
           className={cn(
-            "flex min-h-12 flex-col items-center justify-center gap-0.5 rounded-md px-2 text-[11px] font-medium transition-colors",
+            "flex min-h-12 min-w-0 flex-col items-center justify-center gap-0.5 rounded-md px-1 text-[10px] font-medium transition-colors sm:px-2 sm:text-[11px]",
             activeView === value ? "text-foreground" : "text-muted-foreground",
           )}
         >
diff --git a/apps/web/components/cms/research-section.tsx b/apps/web/components/cms/research-section.tsx
new file mode 100644
index 0000000..05c0eef
--- /dev/null
+++ b/apps/web/components/cms/research-section.tsx
@@ -0,0 +1,251 @@
+"use client";
+
+import * as React from "react";
+import { format, parseISO } from "date-fns";
+import {
+  ArrowUpRightIcon,
+  BookMarkedIcon,
+  HighlighterIcon,
+  LibraryBigIcon,
+  LoaderCircleIcon,
+  RefreshCwIcon,
+} from "lucide-react";
+import {
+  loadResearch,
+  type MarginResearchAnnotation,
+  type ResearchResponse,
+  type SembleResearchCard,
+  type SembleResearchCollection,
+} from "@/lib/research-api";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardDescription, CardHeader } from "@/components/ui/card";
+import { Empty, EmptyDescription, EmptyTitle } from "@/components/ui/empty";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+
+export function ResearchSection() {
+  const [research, setResearch] = React.useState<ResearchResponse | null>(null);
+  const [error, setError] = React.useState("");
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [refreshVersion, setRefreshVersion] = React.useState(0);
+
+  const refresh = React.useCallback(() => {
+    setIsLoading(true);
+    setError("");
+    setRefreshVersion((version) => version + 1);
+  }, []);
+
+  React.useEffect(() => {
+    const controller = new AbortController();
+    loadResearch(controller.signal)
+      .then(setResearch)
+      .catch((loadError: unknown) => {
+        if (loadError instanceof DOMException && loadError.name === "AbortError") return;
+        setError(loadError instanceof Error ? loadError.message : "Could not load research.");
+      })
+      .finally(() => {
+        if (!controller.signal.aborted) setIsLoading(false);
+      });
+    return () => controller.abort();
+  }, [refreshVersion]);
+
+  return (
+    <section className="min-h-0 flex-1 overflow-auto bg-muted/20">
+      <div className="mx-auto w-full max-w-6xl px-4 py-8 sm:px-6 lg:py-10">
+        <div className="flex flex-col gap-4 border-b pb-6 sm:flex-row sm:items-end sm:justify-between">
+          <div>
+            <p className="text-muted-foreground text-xs font-medium uppercase tracking-[0.16em]">Your AT Protocol library</p>
+            <h1 className="mt-2 text-2xl font-semibold tracking-tight">Research</h1>
+            <p className="text-muted-foreground mt-1 max-w-2xl text-sm leading-6">
+              Browse your Semble collections and Margin annotations when you are looking for something worth developing.
+            </p>
+          </div>
+          <Button variant="outline" size="sm" onClick={refresh} disabled={isLoading}>
+            <RefreshCwIcon data-icon="inline-start" className={isLoading ? "animate-spin" : undefined} />
+            {isLoading ? "Refreshing…" : "Refresh"}
+          </Button>
+        </div>
+
+        {isLoading && !research ? (
+          <div className="text-muted-foreground flex min-h-64 items-center justify-center gap-2 text-sm">
+            <LoaderCircleIcon className="size-4 animate-spin" aria-hidden /> Loading your research…
+          </div>
+        ) : error ? (
+          <Empty className="mt-8 min-h-64">
+            <EmptyTitle>Research is unavailable</EmptyTitle>
+            <EmptyDescription>{error}</EmptyDescription>
+            <Button variant="outline" size="sm" onClick={refresh}>Try again</Button>
+          </Empty>
+        ) : research ? (
+          <Tabs defaultValue="semble" className="mt-6 gap-5">
+            <TabsList aria-label="Research sources">
+              <TabsTrigger value="semble">
+                <LibraryBigIcon className="mr-2 size-4" aria-hidden />
+                Semble <span className="text-muted-foreground ml-1.5">{research.semble.collections.length}</span>
+              </TabsTrigger>
+              <TabsTrigger value="margin">
+                <HighlighterIcon className="mr-2 size-4" aria-hidden />
+                Margin <span className="text-muted-foreground ml-1.5">{research.margin.annotations.length}</span>
+              </TabsTrigger>
+            </TabsList>
+            <TabsContent value="semble">
+              <SourceNotice message={research.semble.error} />
+              <SembleCollections collections={research.semble.collections} />
+            </TabsContent>
+            <TabsContent value="margin">
+              <SourceNotice message={research.margin.error} />
+              <MarginAnnotations annotations={research.margin.annotations} />
+            </TabsContent>
+          </Tabs>
+        ) : null}
+      </div>
+    </section>
+  );
+}
+
+function SourceNotice({ message }: { message?: string }) {
+  return message ? (
+    <div role="status" className="mb-4 rounded-lg border border-amber-500/30 bg-amber-500/5 px-4 py-3 text-sm text-amber-800 dark:text-amber-200">
+      {message}
+    </div>
+  ) : null;
+}
+
+function SembleCollections({ collections }: { collections: SembleResearchCollection[] }) {
+  if (!collections.length) {
+    return (
+      <Empty className="min-h-64">
+        <EmptyTitle>No Semble collections found</EmptyTitle>
+        <EmptyDescription>Collections saved by this linked account will appear here.</EmptyDescription>
+      </Empty>
+    );
+  }
+
+  return (
+    <div className="grid gap-5">
+      {collections.map((collection) => (
+        <Card key={collection.uri}>
+          <CardHeader className="gap-2 border-b">
+            <div className="flex flex-wrap items-start justify-between gap-3">
+              <div className="min-w-0">
+                <h2 className="text-base font-semibold leading-none">{collection.name}</h2>
+                {collection.description ? <CardDescription className="mt-1 leading-5">{collection.description}</CardDescription> : null}
+              </div>
+              <div className="flex items-center gap-2">
+                <Badge variant="outline">{collection.accessType.toLowerCase()}</Badge>
+                <Badge variant="secondary">{collection.cards.length} {collection.cards.length === 1 ? "item" : "items"}</Badge>
+              </div>
+            </div>
+          </CardHeader>
+          <CardContent className="divide-y p-0">
+            {collection.cards.length ? collection.cards.map((card) => (
+              <SembleCard key={card.uri} card={card} />
+            )) : (
+              <p className="text-muted-foreground p-4 text-sm">This collection is empty.</p>
+            )}
+          </CardContent>
+        </Card>
+      ))}
+    </div>
+  );
+}
+
+function SembleCard({ card }: { card: SembleResearchCard }) {
+  const title = card.title || card.note || card.url || "Untitled saved item";
+  return (
+    <article className="grid gap-3 p-4 sm:grid-cols-[minmax(0,1fr)_auto] sm:items-start sm:gap-6">
+      <div className="min-w-0">
+        <div className="flex flex-wrap items-center gap-2">
+          <h3 className="text-sm font-semibold leading-5">{title}</h3>
+          {card.siteName ? <Badge variant="outline" className="font-normal">{card.siteName}</Badge> : null}
+        </div>
+        {card.author ? <p className="text-muted-foreground mt-1 text-xs">By {card.author}</p> : null}
+        {card.note && card.note !== title ? <p className="mt-2 text-sm leading-6">{card.note}</p> : null}
+        {card.description ? <p className="text-muted-foreground mt-2 line-clamp-3 text-sm leading-6">{card.description}</p> : null}
+        {card.createdAt ? <ResearchDate value={card.createdAt} /> : null}
+      </div>
+      {safeHTTPURL(card.url) ? (
+        <Button variant="ghost" size="sm" asChild>
+          <a href={card.url} target="_blank" rel="noreferrer">
+            Open source <ArrowUpRightIcon data-icon="inline-end" />
+          </a>
+        </Button>
+      ) : null}
+    </article>
+  );
+}
+
+function MarginAnnotations({ annotations }: { annotations: MarginResearchAnnotation[] }) {
+  if (!annotations.length) {
+    return (
+      <Empty className="min-h-64">
+        <EmptyTitle>No Margin annotations found</EmptyTitle>
+        <EmptyDescription>Notes, highlights, and bookmarks from this linked account will appear here.</EmptyDescription>
+      </Empty>
+    );
+  }
+
+  return (
+    <div className="grid gap-4 md:grid-cols-2">
+      {annotations.map((annotation) => (
+        <Card key={annotation.uri} className="min-w-0">
+          <CardHeader className="gap-3">
+            <div className="flex flex-wrap items-center justify-between gap-2">
+              <Badge variant="outline" className="capitalize">
+                <BookMarkedIcon className="mr-1 size-3" aria-hidden /> {annotation.motivation}
+              </Badge>
+              <ResearchDate value={annotation.modifiedAt ?? annotation.createdAt} />
+            </div>
+            <h2 className="text-base font-semibold leading-6">{annotation.title || sourceHost(annotation.source)}</h2>
+          </CardHeader>
+          <CardContent className="space-y-3">
+            {annotation.quote ? (
+              <blockquote className="border-l-2 border-primary/40 pl-3 text-sm leading-6 italic">“{annotation.quote}”</blockquote>
+            ) : null}
+            {annotation.body ? <p className="text-sm leading-6 whitespace-pre-wrap">{annotation.body}</p> : null}
+            {annotation.tags.length ? (
+              <div className="flex flex-wrap gap-1.5">
+                {annotation.tags.map((tag) => <Badge key={tag} variant="secondary">{tag}</Badge>)}
+              </div>
+            ) : null}
+            {safeHTTPURL(annotation.source) ? (
+              <Button variant="ghost" size="sm" className="-ml-3" asChild>
+                <a href={annotation.source} target="_blank" rel="noreferrer">
+                  Open source <ArrowUpRightIcon data-icon="inline-end" />
+                </a>
+              </Button>
+            ) : null}
+          </CardContent>
+        </Card>
+      ))}
+    </div>
+  );
+}
+
+function ResearchDate({ value }: { value: string }) {
+  let label: string;
+  try {
+    label = format(parseISO(value), "MMM d, yyyy");
+  } catch {
+    return null;
+  }
+  return <time dateTime={value} className="text-muted-foreground mt-2 block text-xs">{label}</time>;
+}
+
+function safeHTTPURL(value?: string) {
+  if (!value) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function sourceHost(value: string) {
+  try {
+    return new URL(value).hostname.replace(/^www\./, "");
+  } catch {
+    return "Untitled annotation";
+  }
+}
diff --git a/apps/web/components/cms/workspace-header.tsx b/apps/web/components/cms/workspace-header.tsx
index 459606e..9fed5f0 100644
--- a/apps/web/components/cms/workspace-header.tsx
+++ b/apps/web/components/cms/workspace-header.tsx
@@ -11,6 +11,7 @@ import {
   RocketIcon,
   Settings2Icon,
   SunIcon,
+  TelescopeIcon,
 } from "lucide-react";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -183,6 +184,7 @@ function WorkspaceNavigation({
   const views = [
     { value: "posts", label: "Posts", icon: BookOpenIcon },
     { value: "publications", label: "Publications", icon: LibraryIcon },
+    { value: "research", label: "Research", icon: TelescopeIcon },
     { value: "feedback", label: "Feedback", icon: MessageSquareTextIcon },
   ] as const;
 
@@ -208,7 +210,13 @@ function WorkspaceNavigation({
 }
 
 function mobileViewTitle(view: WorkspaceView) {
-  return view === "posts" ? "Posts" : view === "publications" ? "Publications" : "Feedback";
+  return view === "posts"
+    ? "Posts"
+    : view === "publications"
+      ? "Publications"
+      : view === "research"
+        ? "Research"
+        : "Feedback";
 }
 
 function MobileAccountSheet({
diff --git a/apps/web/lib/research-api.ts b/apps/web/lib/research-api.ts
new file mode 100644
index 0000000..d6b0871
--- /dev/null
+++ b/apps/web/lib/research-api.ts
@@ -0,0 +1,50 @@
+import { apiFetch } from "@/lib/api";
+
+export type SembleResearchCard = {
+  uri: string;
+  url?: string;
+  title?: string;
+  description?: string;
+  siteName?: string;
+  author?: string;
+  note?: string;
+  createdAt?: string;
+};
+
+export type SembleResearchCollection = {
+  uri: string;
+  name: string;
+  description?: string;
+  accessType: string;
+  createdAt?: string;
+  updatedAt?: string;
+  cards: SembleResearchCard[];
+};
+
+export type MarginResearchAnnotation = {
+  uri: string;
+  motivation: string;
+  source: string;
+  title?: string;
+  body?: string;
+  quote?: string;
+  tags: string[];
+  color?: string;
+  createdAt: string;
+  modifiedAt?: string;
+};
+
+export type ResearchResponse = {
+  semble: {
+    collections: SembleResearchCollection[];
+    error?: string;
+  };
+  margin: {
+    annotations: MarginResearchAnnotation[];
+    error?: string;
+  };
+};
+
+export function loadResearch(signal?: AbortSignal) {
+  return apiFetch<ResearchResponse>("/api/research", { signal });
+}
diff --git a/apps/web/lib/workspace-navigation.ts b/apps/web/lib/workspace-navigation.ts
index 43d705d..9f83187 100644
--- a/apps/web/lib/workspace-navigation.ts
+++ b/apps/web/lib/workspace-navigation.ts
@@ -1,4 +1,4 @@
-export type WorkspaceView = "posts" | "publications" | "feedback";
+export type WorkspaceView = "posts" | "publications" | "research" | "feedback";
 export type MobileWorkspacePane = "list" | "write" | "details" | "schedule";
 
 export type WorkspaceNavigationState = {
@@ -7,7 +7,7 @@ export type WorkspaceNavigationState = {
   pane: MobileWorkspacePane;
 };
 
-const workspaceViews = new Set<WorkspaceView>(["posts", "publications", "feedback"]);
+const workspaceViews = new Set<WorkspaceView>(["posts", "publications", "research", "feedback"]);
 const editorPanes = new Set<MobileWorkspacePane>(["write", "details", "schedule"]);
 
 export const defaultWorkspaceNavigation: WorkspaceNavigationState = {
diff --git a/apps/web/test/mobile-workspace-ui.test.tsx b/apps/web/test/mobile-workspace-ui.test.tsx
index 46df36a..2f437cf 100644
--- a/apps/web/test/mobile-workspace-ui.test.tsx
+++ b/apps/web/test/mobile-workspace-ui.test.tsx
@@ -102,6 +102,8 @@ describe("mobile workspace controls", () => {
 
     fireEvent.click(screen.getByRole("button", { name: "Open Feedback" }));
     expect(onViewChange).toHaveBeenCalledWith("feedback");
+    fireEvent.click(screen.getByRole("button", { name: "Open Research" }));
+    expect(onViewChange).toHaveBeenCalledWith("research");
   });
 
   it("keeps save and publish actions in the editing footer", () => {
diff --git a/apps/web/test/research-api.test.ts b/apps/web/test/research-api.test.ts
new file mode 100644
index 0000000..92e8e8b
--- /dev/null
+++ b/apps/web/test/research-api.test.ts
@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { loadResearch } from "@/lib/research-api";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("research API", () => {
+  it("loads the authenticated account research inventory", async () => {
+    const payload = {
+      semble: { collections: [] },
+      margin: { annotations: [] },
+    };
+    const fetchMock = vi.fn().mockResolvedValue(Response.json(payload));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await expect(loadResearch()).resolves.toEqual(payload);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://localhost:8080/api/research",
+      expect.objectContaining({ credentials: "include" }),
+    );
+  });
+});
diff --git a/apps/web/test/research-section.test.tsx b/apps/web/test/research-section.test.tsx
new file mode 100644
index 0000000..4c52384
--- /dev/null
+++ b/apps/web/test/research-section.test.tsx
@@ -0,0 +1,115 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ResearchSection } from "@/components/cms/research-section";
+
+const mocks = vi.hoisted(() => ({ loadResearch: vi.fn() }));
+
+vi.mock("@/lib/research-api", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@/lib/research-api")>();
+  return { ...original, loadResearch: mocks.loadResearch };
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.loadResearch.mockResolvedValue({
+    semble: {
+      collections: [{
+        uri: "at://did:plc:writer/network.cosmik.collection/research",
+        name: "Things to write about",
+        description: "Saved prompts and source material.",
+        accessType: "CLOSED",
+        cards: [{
+          uri: "at://did:plc:writer/network.cosmik.card/source",
+          url: "https://example.com/source",
+          title: "A promising source",
+          description: "A useful description.",
+          siteName: "Example",
+          author: "A. Writer",
+          note: "Revisit the central claim.",
+          createdAt: "2026-08-29T12:00:00.000Z",
+        }],
+      }],
+    },
+    margin: {
+      annotations: [{
+        uri: "at://did:plc:writer/at.margin.note/note",
+        motivation: "highlighting",
+        source: "https://example.org/essay",
+        title: "An essay worth revisiting",
+        body: "Connect this to the publishing workflow.",
+        quote: "A highlighted passage",
+        tags: ["publishing"],
+        createdAt: "2026-08-30T12:00:00.000Z",
+      }],
+    },
+  });
+});
+
+describe("research workspace", () => {
+  it("browses the linked user's Semble collections and Margin annotations", async () => {
+    render(<ResearchSection />);
+
+    expect(await screen.findByRole("heading", { name: "Things to write about" })).toBeInTheDocument();
+    expect(screen.getByText("A promising source")).toBeInTheDocument();
+    expect(screen.getByRole("link", { name: /Open source/ })).toHaveAttribute("href", "https://example.com/source");
+
+    const marginTab = screen.getByRole("tab", { name: /Margin 1/ });
+    fireEvent.mouseDown(marginTab, { button: 0, ctrlKey: false });
+    fireEvent.click(marginTab);
+    expect(screen.getByRole("heading", { name: "An essay worth revisiting" })).toBeInTheDocument();
+    expect(screen.getByText("“A highlighted passage”")).toBeInTheDocument();
+    expect(screen.getByText("Connect this to the publishing workflow.")).toBeInTheDocument();
+  });
+
+  it("keeps one source usable when the other reports a partial failure", async () => {
+    mocks.loadResearch.mockResolvedValue({
+      semble: { collections: [], error: "Semble records could not be loaded." },
+      margin: { annotations: [] },
+    });
+
+    render(<ResearchSection />);
+
+    expect(await screen.findByText("Semble records could not be loaded.")).toBeInTheDocument();
+    expect(screen.getByText("No Semble collections found")).toBeInTheDocument();
+    const marginTab = screen.getByRole("tab", { name: /Margin 0/ });
+    fireEvent.mouseDown(marginTab, { button: 0, ctrlKey: false });
+    fireEvent.click(marginTab);
+    expect(screen.getByText("No Margin annotations found")).toBeInTheDocument();
+  });
+
+  it("offers retry after the inventory request fails", async () => {
+    mocks.loadResearch
+      .mockRejectedValueOnce(new Error("Research service unavailable"))
+      .mockResolvedValueOnce({ semble: { collections: [] }, margin: { annotations: [] } });
+
+    render(<ResearchSection />);
+
+    expect(await screen.findByText("Research service unavailable")).toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: "Try again" }));
+    await waitFor(() => expect(mocks.loadResearch).toHaveBeenCalledTimes(2));
+    expect(await screen.findByText("No Semble collections found")).toBeInTheDocument();
+  });
+
+  it("does not expose unsafe source schemes as links", async () => {
+    mocks.loadResearch.mockResolvedValue({
+      semble: {
+        collections: [{
+          uri: "at://did:plc:writer/network.cosmik.collection/unsafe",
+          name: "Unsafe links",
+          accessType: "OPEN",
+          cards: [{
+            uri: "at://did:plc:writer/network.cosmik.card/unsafe",
+            url: "javascript:alert(1)",
+            title: "Untrusted item",
+          }],
+        }],
+      },
+      margin: { annotations: [] },
+    });
+
+    render(<ResearchSection />);
+
+    expect(await screen.findByText("Untrusted item")).toBeInTheDocument();
+    expect(screen.queryByRole("link", { name: /Open source/ })).not.toBeInTheDocument();
+  });
+});
diff --git a/apps/web/test/workspace-navigation.test.ts b/apps/web/test/workspace-navigation.test.ts
index 61f99c8..09190ba 100644
--- a/apps/web/test/workspace-navigation.test.ts
+++ b/apps/web/test/workspace-navigation.test.ts
@@ -32,6 +32,16 @@ describe("workspace navigation", () => {
     });
   });
 
+  it("supports the research inventory as a global destination", () => {
+    expect(parseWorkspaceNavigation("?view=research&draft=draft-1&pane=details")).toEqual({
+      view: "research",
+      draftID: "",
+      pane: "list",
+    });
+    expect(workspaceNavigationURL({ view: "research", draftID: "ignored", pane: "schedule" }))
+      .toBe("/editor?view=research");
+  });
+
   it("serializes stable, minimal editor URLs", () => {
     expect(workspaceNavigationURL(defaultWorkspaceNavigation)).toBe("/editor");
     expect(workspaceNavigationURL({ view: "publications", draftID: "ignored", pane: "details" }))

From 3cae7107fd13fe5608a7b1380c9dd5142f7b65c9 Mon Sep 17 00:00:00 2001
From: Sam Clemente <sam@theclementes.com>
Date: Sun, 30 Aug 2026 21:09:16 -0500
Subject: [PATCH 2/3] fix: keep research navigation readable on mobile

Uses a compact Sites label and tighter four-column footer spacing so the new destination remains legible at 320px without horizontal overflow.
---
 .../components/cms/mobile-workspace-footer.tsx   | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/apps/web/components/cms/mobile-workspace-footer.tsx b/apps/web/components/cms/mobile-workspace-footer.tsx
index 06d6da5..a773b34 100644
--- a/apps/web/components/cms/mobile-workspace-footer.tsx
+++ b/apps/web/components/cms/mobile-workspace-footer.tsx
@@ -49,18 +49,18 @@ export function MobileWorkspaceFooter({
   }
 
   const views = [
-    { value: "posts", label: "Posts", icon: BookOpenIcon },
-    { value: "publications", label: "Publications", icon: LibraryIcon },
-    { value: "research", label: "Research", icon: TelescopeIcon },
-    { value: "feedback", label: "Feedback", icon: MessageSquareTextIcon },
+    { value: "posts", label: "Posts", mobileLabel: "Posts", icon: BookOpenIcon },
+    { value: "publications", label: "Publications", mobileLabel: "Sites", icon: LibraryIcon },
+    { value: "research", label: "Research", mobileLabel: "Research", icon: TelescopeIcon },
+    { value: "feedback", label: "Feedback", mobileLabel: "Feedback", icon: MessageSquareTextIcon },
   ] as const;
 
   return (
     <nav
       aria-label="Mobile workspace"
-      className="z-20 grid shrink-0 grid-cols-4 border-t bg-background/95 px-1 pt-1 pb-[calc(0.25rem+env(safe-area-inset-bottom))] backdrop-blur xl:hidden sm:px-2"
+      className="z-20 grid shrink-0 grid-cols-4 gap-0.5 border-t bg-background/95 px-1 pt-1 pb-[calc(0.25rem+env(safe-area-inset-bottom))] backdrop-blur xl:hidden sm:px-2"
     >
-      {views.map(({ value, label, icon: Icon }) => (
+      {views.map(({ value, label, mobileLabel, icon: Icon }) => (
         <button
           key={value}
           type="button"
@@ -68,12 +68,12 @@ export function MobileWorkspaceFooter({
           aria-current={activeView === value ? "page" : undefined}
           onClick={() => onViewChange(value)}
           className={cn(
-            "flex min-h-12 min-w-0 flex-col items-center justify-center gap-0.5 rounded-md px-1 text-[10px] font-medium transition-colors sm:px-2 sm:text-[11px]",
+            "flex min-h-12 min-w-0 flex-col items-center justify-center gap-0.5 rounded-md px-0 text-[9px] leading-none font-medium transition-colors sm:px-2 sm:text-[11px]",
             activeView === value ? "text-foreground" : "text-muted-foreground",
           )}
         >
           <Icon className={cn("size-5", activeView === value && "text-primary")} aria-hidden />
-          {label}
+          <span className="max-w-full truncate">{mobileLabel}</span>
         </button>
       ))}
     </nav>

From 89f512af76f00c3302c59c8ff5dfb3303f3a26bb Mon Sep 17 00:00:00 2001
From: Sam Clemente <sam@theclementes.com>
Date: Sun, 30 Aug 2026 21:09:21 -0500
Subject: [PATCH 3/3] feat: aggregate account research records

Reads the linked account's current Semble collections and Margin notes from its PDS, isolates source failures, applies collection-link removals, and returns deterministic newest-first research data.
---
 .../App/Controllers/ResearchController.swift  |  12 +
 .../App/Services/ATProtoXRPCClient.swift      |  18 +-
 .../App/Services/ResearchService.swift        | 476 ++++++++++++++++++
 services/backend/Sources/App/routes.swift     |   1 +
 .../Tests/AppTests/ResearchTests.swift        | 403 +++++++++++++++
 5 files changed, 908 insertions(+), 2 deletions(-)
 create mode 100644 services/backend/Sources/App/Controllers/ResearchController.swift
 create mode 100644 services/backend/Sources/App/Services/ResearchService.swift
 create mode 100644 services/backend/Tests/AppTests/ResearchTests.swift

diff --git a/services/backend/Sources/App/Controllers/ResearchController.swift b/services/backend/Sources/App/Controllers/ResearchController.swift
new file mode 100644
index 0000000..c93e54f
--- /dev/null
+++ b/services/backend/Sources/App/Controllers/ResearchController.swift
@@ -0,0 +1,12 @@
+import Vapor
+
+struct ResearchController: RouteCollection {
+    func boot(routes: RoutesBuilder) throws {
+        routes.get("research", use: show)
+    }
+
+    func show(req: Request) async throws -> ResearchResponse {
+        let account = try await req.authenticatedContext().account
+        return await req.application.research.load(account: account, req: req)
+    }
+}
diff --git a/services/backend/Sources/App/Services/ATProtoXRPCClient.swift b/services/backend/Sources/App/Services/ATProtoXRPCClient.swift
index e8025c3..28fdf78 100644
--- a/services/backend/Sources/App/Services/ATProtoXRPCClient.swift
+++ b/services/backend/Sources/App/Services/ATProtoXRPCClient.swift
@@ -129,16 +129,30 @@ struct ATProtoXRPCClient: Sendable {
         account: LinkedAccount,
         cursor: String?,
         client: Client
+    ) async throws -> ListRecordsResponse<JSONValue> {
+        try await listRecordsPage(
+            account: account,
+            collection: "site.standard.publication",
+            cursor: cursor,
+            client: client
+        )
+    }
+
+    func listRecordsPage(
+        account: LinkedAccount,
+        collection: String,
+        cursor: String?,
+        client: Client
     ) async throws -> ListRecordsResponse<JSONValue> {
         var query = [
             "repo": account.did,
-            "collection": "site.standard.publication",
+            "collection": collection,
             "limit": "100",
         ]
         if let cursor { query["cursor"] = cursor }
         let uri = try xrpcURL(pdsURL: account.pdsURL, method: "com.atproto.repo.listRecords", query: query)
         let response = try await xrpcGet(uri, client: client)
-        try requireSuccess(response, operation: "publication listing")
+        try requireSuccess(response, operation: "\(collection) listing")
         return try response.content.decode(ListRecordsResponse<JSONValue>.self)
     }
 
diff --git a/services/backend/Sources/App/Services/ResearchService.swift b/services/backend/Sources/App/Services/ResearchService.swift
new file mode 100644
index 0000000..1357f8f
--- /dev/null
+++ b/services/backend/Sources/App/Services/ResearchService.swift
@@ -0,0 +1,476 @@
+import Foundation
+import Vapor
+
+protocol RepositoryRecordPageListing: Sendable {
+    func listRecordsPage(
+        account: LinkedAccount,
+        collection: String,
+        cursor: String?,
+        client: Client
+    ) async throws -> ListRecordsResponse<JSONValue>
+}
+
+extension ATProtoXRPCClient: RepositoryRecordPageListing {}
+
+struct RepositoryRecordPaginator: Sendable {
+    private let records: any RepositoryRecordPageListing
+
+    init(records: any RepositoryRecordPageListing = ATProtoXRPCClient()) {
+        self.records = records
+    }
+
+    func listAll(
+        account: LinkedAccount,
+        collection: String,
+        client: Client
+    ) async throws -> [RepositoryRecord<JSONValue>] {
+        var cursor: String?
+        var seenCursors = Set<String>()
+        var result: [RepositoryRecord<JSONValue>] = []
+
+        while true {
+            let page = try await records.listRecordsPage(
+                account: account,
+                collection: collection,
+                cursor: cursor,
+                client: client
+            )
+            result.append(contentsOf: page.records)
+
+            guard !page.records.isEmpty, let nextCursor = page.cursor else { break }
+            guard seenCursors.insert(nextCursor).inserted else {
+                throw Abort(.badGateway, reason: "PDS repeated a \(collection) listing cursor")
+            }
+            cursor = nextCursor
+        }
+
+        return result
+    }
+}
+
+protocol ResearchLoading: Sendable {
+    func load(account: LinkedAccount, req: Request) async -> ResearchResponse
+}
+
+struct ResearchService: ResearchLoading, Sendable {
+    private enum Collection {
+        static let sembleCollection = "network.cosmik.collection"
+        static let sembleCollectionLink = "network.cosmik.collectionLink"
+        static let sembleCollectionLinkRemoval = "network.cosmik.collectionLinkRemoval"
+        static let sembleCard = "network.cosmik.card"
+        static let marginNote = "at.margin.note"
+    }
+
+    private let paginator: RepositoryRecordPaginator
+
+    init(records: any RepositoryRecordPageListing = ATProtoXRPCClient()) {
+        paginator = RepositoryRecordPaginator(records: records)
+    }
+
+    func load(account: LinkedAccount, req: Request) async -> ResearchResponse {
+        async let sembleFetch = fetchSemble(account: account, req: req)
+        async let marginFetch = fetchMargin(account: account, req: req)
+
+        let semble: SembleResearchResponse
+        do {
+            semble = SembleResearchResponse(
+                collections: try await sembleFetch,
+                error: nil
+            )
+        } catch {
+            req.logger.warning("Semble research refresh failed", metadata: [
+                "accountDID": "\(account.did)",
+                "error": "\(error)",
+            ])
+            semble = SembleResearchResponse(
+                collections: [],
+                error: "Semble research is temporarily unavailable."
+            )
+        }
+
+        let margin: MarginResearchResponse
+        do {
+            margin = MarginResearchResponse(
+                annotations: try await marginFetch,
+                error: nil
+            )
+        } catch {
+            req.logger.warning("Margin research refresh failed", metadata: [
+                "accountDID": "\(account.did)",
+                "error": "\(error)",
+            ])
+            margin = MarginResearchResponse(
+                annotations: [],
+                error: "Margin research is temporarily unavailable."
+            )
+        }
+
+        return ResearchResponse(semble: semble, margin: margin)
+    }
+
+    func fetchSemble(account: LinkedAccount, req: Request) async throws -> [SembleCollectionResponse] {
+        async let collectionFetch = paginator.listAll(
+            account: account,
+            collection: Collection.sembleCollection,
+            client: req.client
+        )
+        async let linkFetch = paginator.listAll(
+            account: account,
+            collection: Collection.sembleCollectionLink,
+            client: req.client
+        )
+        async let removalFetch = paginator.listAll(
+            account: account,
+            collection: Collection.sembleCollectionLinkRemoval,
+            client: req.client
+        )
+        async let cardFetch = paginator.listAll(
+            account: account,
+            collection: Collection.sembleCard,
+            client: req.client
+        )
+        let (collectionRecords, linkRecords, removalRecords, cardRecords) = try await (
+            collectionFetch,
+            linkFetch,
+            removalFetch,
+            cardFetch
+        )
+
+        let collections: [SembleCollection] = collectionRecords.compactMap { record -> SembleCollection? in
+            guard let collection = SembleCollection(record: record, accountDID: account.did) else {
+                logMalformed(record, source: "Semble collection", req: req)
+                return nil
+            }
+            return collection
+        }
+        let cards = cardRecords.compactMap { record -> SembleCardResponse? in
+            guard let card = SembleCardResponse(record: record, accountDID: account.did) else {
+                logMalformed(record, source: "Semble card", req: req)
+                return nil
+            }
+            return card
+        }
+        let cardsByURI = Dictionary(cards.map { ($0.uri, $0) }, uniquingKeysWith: { _, latest in latest })
+        let removedLinkURIs = Set(removalRecords.compactMap { record -> String? in
+            guard let removal = SembleCollectionLinkRemoval(record: record, accountDID: account.did) else {
+                logMalformed(record, source: "Semble collection-link removal", req: req)
+                return nil
+            }
+            return removal.removedLinkURI
+        })
+
+        var cardsByCollectionURI: [String: [SembleCardResponse]] = [:]
+        var linkedCardURIsByCollectionURI: [String: Set<String>] = [:]
+        for record in linkRecords {
+            guard !removedLinkURIs.contains(record.uri) else { continue }
+            guard let link = SembleCollectionLink(record: record, accountDID: account.did),
+                  let card = cardsByURI[link.cardURI]
+            else {
+                logMalformed(record, source: "Semble collection link", req: req)
+                continue
+            }
+            guard linkedCardURIsByCollectionURI[link.collectionURI, default: []].insert(link.cardURI).inserted else {
+                continue
+            }
+            cardsByCollectionURI[link.collectionURI, default: []].append(card)
+        }
+
+        return collections.map { collection in
+            SembleCollectionResponse(
+                uri: collection.uri,
+                name: collection.name,
+                description: collection.description,
+                accessType: collection.accessType,
+                createdAt: collection.createdAt,
+                updatedAt: collection.updatedAt,
+                cards: (cardsByCollectionURI[collection.uri] ?? []).sorted {
+                    newestFirst($0.createdAt, $1.createdAt, lhsTieBreaker: $0.uri, rhsTieBreaker: $1.uri)
+                }
+            )
+        }.sorted {
+            newestFirst(
+                $0.updatedAt ?? $0.createdAt,
+                $1.updatedAt ?? $1.createdAt,
+                lhsTieBreaker: $0.uri,
+                rhsTieBreaker: $1.uri
+            )
+        }
+    }
+
+    func fetchMargin(account: LinkedAccount, req: Request) async throws -> [MarginAnnotationResponse] {
+        let records = try await paginator.listAll(
+            account: account,
+            collection: Collection.marginNote,
+            client: req.client
+        )
+        return records.compactMap { record in
+            guard let annotation = MarginAnnotationResponse(record: record, accountDID: account.did) else {
+                logMalformed(record, source: "Margin annotation", req: req)
+                return nil
+            }
+            return annotation
+        }.sorted {
+            newestFirst(
+                $0.modifiedAt ?? $0.createdAt,
+                $1.modifiedAt ?? $1.createdAt,
+                lhsTieBreaker: $0.uri,
+                rhsTieBreaker: $1.uri
+            )
+        }
+    }
+
+    private func logMalformed(_ record: RepositoryRecord<JSONValue>, source: String, req: Request) {
+        req.logger.warning("Skipping malformed or unrelated \(source) record", metadata: ["uri": "\(record.uri)"])
+    }
+}
+
+private func newestFirst(
+    _ lhsTimestamp: String?,
+    _ rhsTimestamp: String?,
+    lhsTieBreaker: String,
+    rhsTieBreaker: String
+) -> Bool {
+    let lhsDate = researchDate(lhsTimestamp)
+    let rhsDate = researchDate(rhsTimestamp)
+    if lhsDate != rhsDate {
+        if let lhsDate, let rhsDate { return lhsDate > rhsDate }
+        return lhsDate != nil
+    }
+    return lhsTieBreaker < rhsTieBreaker
+}
+
+private func researchDate(_ timestamp: String?) -> Date? {
+    guard let timestamp else { return nil }
+    let fractional = ISO8601DateFormatter()
+    fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    if let date = fractional.date(from: timestamp) { return date }
+    let standard = ISO8601DateFormatter()
+    standard.formatOptions = [.withInternetDateTime]
+    return standard.date(from: timestamp)
+}
+
+struct ResearchResponse: Content, Equatable, Sendable {
+    let semble: SembleResearchResponse
+    let margin: MarginResearchResponse
+}
+
+struct SembleResearchResponse: Content, Equatable, Sendable {
+    let collections: [SembleCollectionResponse]
+    let error: String?
+}
+
+struct SembleCollectionResponse: Content, Equatable, Sendable {
+    let uri: String
+    let name: String
+    let description: String?
+    let accessType: String
+    let createdAt: String?
+    let updatedAt: String?
+    let cards: [SembleCardResponse]
+}
+
+struct SembleCardResponse: Content, Equatable, Sendable {
+    let uri: String
+    let url: String?
+    let title: String?
+    let description: String?
+    let siteName: String?
+    let author: String?
+    let note: String?
+    let createdAt: String?
+
+    init?(
+        record: RepositoryRecord<JSONValue>,
+        accountDID: String
+    ) {
+        guard record.belongs(to: accountDID, collection: "network.cosmik.card"),
+              let value = record.value.objectValue,
+              value.hasType("network.cosmik.card"),
+              let cardType = value.nonEmptyString("type"),
+              let content = value["content"]?.objectValue
+        else { return nil }
+
+        let metadata = content["metadata"]?.objectValue
+        switch cardType {
+        case "URL":
+            guard content.hasType("network.cosmik.card#urlContent"),
+                  let contentURL = content.nonEmptyString("url")
+            else { return nil }
+            url = contentURL
+            title = metadata?.nonEmptyString("title")
+            description = metadata?.nonEmptyString("description")
+            siteName = metadata?.nonEmptyString("siteName")
+            author = metadata?.nonEmptyString("author")
+            note = nil
+        case "NOTE":
+            guard content.hasType("network.cosmik.card#noteContent"),
+                  let text = content.nonEmptyString("text")
+            else { return nil }
+            url = value.nonEmptyString("url")
+            title = nil
+            description = nil
+            siteName = nil
+            author = nil
+            note = text
+        default:
+            return nil
+        }
+
+        uri = record.uri
+        createdAt = value.nonEmptyString("createdAt")
+    }
+}
+
+struct MarginResearchResponse: Content, Equatable, Sendable {
+    let annotations: [MarginAnnotationResponse]
+    let error: String?
+}
+
+struct MarginAnnotationResponse: Content, Equatable, Sendable {
+    let uri: String
+    let motivation: String
+    let source: String
+    let title: String?
+    let body: String?
+    let quote: String?
+    let tags: [String]
+    let color: String?
+    let createdAt: String
+    let modifiedAt: String?
+
+    init?(record: RepositoryRecord<JSONValue>, accountDID: String) {
+        guard record.belongs(to: accountDID, collection: "at.margin.note"),
+              let value = record.value.objectValue,
+              value.hasType("at.margin.note"),
+              let motivation = value.nonEmptyString("motivation"),
+              let target = value["target"]?.objectValue,
+              let source = target.nonEmptyString("source"),
+              let createdAt = value.nonEmptyString("createdAt")
+        else { return nil }
+
+        uri = record.uri
+        self.motivation = motivation
+        self.source = source
+        title = target.nonEmptyString("title")
+        body = value["body"]?.objectValue?.nonEmptyString("value")
+        quote = Self.exactQuote(in: target["selector"])
+        tags = value["tags"]?.arrayValue?.compactMap(\.stringValue) ?? []
+        color = value.nonEmptyString("color")
+        self.createdAt = createdAt
+        modifiedAt = value.nonEmptyString("modifiedAt")
+    }
+
+    private static func exactQuote(in selector: JSONValue?) -> String? {
+        if let selectors = selector?.arrayValue {
+            return selectors.lazy.compactMap(exactQuote).first
+        }
+        guard let selector = selector?.objectValue else { return nil }
+        if let exact = selector.nonEmptyString("exact") { return exact }
+        return exactQuote(in: selector["refinedBy"])
+    }
+}
+
+private struct SembleCollection: Sendable {
+    let uri: String
+    let name: String
+    let description: String?
+    let accessType: String
+    let createdAt: String?
+    let updatedAt: String?
+
+    init?(record: RepositoryRecord<JSONValue>, accountDID: String) {
+        guard record.belongs(to: accountDID, collection: "network.cosmik.collection"),
+              let value = record.value.objectValue,
+              value.hasType("network.cosmik.collection"),
+              let name = value.nonEmptyString("name"),
+              let accessType = value.nonEmptyString("accessType")
+        else { return nil }
+        uri = record.uri
+        self.name = name
+        description = value.nonEmptyString("description")
+        self.accessType = accessType
+        createdAt = value.nonEmptyString("createdAt")
+        updatedAt = value.nonEmptyString("updatedAt")
+    }
+}
+
+private struct SembleCollectionLink: Sendable {
+    let collectionURI: String
+    let cardURI: String
+
+    init?(record: RepositoryRecord<JSONValue>, accountDID: String) {
+        guard record.belongs(to: accountDID, collection: "network.cosmik.collectionLink"),
+              let value = record.value.objectValue,
+              value.hasType("network.cosmik.collectionLink"),
+              value.nonEmptyString("addedBy") != nil,
+              value.nonEmptyString("addedAt") != nil,
+              let collectionURI = value.strongReferenceURI("collection"),
+              let cardURI = value.strongReferenceURI("card"),
+              collectionURI.belongs(to: accountDID, collection: "network.cosmik.collection"),
+              cardURI.belongs(to: accountDID, collection: "network.cosmik.card")
+        else { return nil }
+        self.collectionURI = collectionURI
+        self.cardURI = cardURI
+    }
+}
+
+private struct SembleCollectionLinkRemoval: Sendable {
+    let removedLinkURI: String
+
+    init?(record: RepositoryRecord<JSONValue>, accountDID: String) {
+        guard record.belongs(to: accountDID, collection: "network.cosmik.collectionLinkRemoval"),
+              let value = record.value.objectValue,
+              value.hasType("network.cosmik.collectionLinkRemoval"),
+              value.nonEmptyString("removedAt") != nil,
+              let collectionURI = value.strongReferenceURI("collection"),
+              let removedLinkURI = value.strongReferenceURI("removedLink"),
+              collectionURI.belongs(to: accountDID, collection: "network.cosmik.collection")
+        else { return nil }
+        self.removedLinkURI = removedLinkURI
+    }
+}
+
+private extension RepositoryRecord where Value == JSONValue {
+    func belongs(to accountDID: String, collection: String) -> Bool {
+        uri.belongs(to: accountDID, collection: collection)
+    }
+}
+
+private extension String {
+    func belongs(to accountDID: String, collection: String) -> Bool {
+        guard let reference = try? ATRecordReference(uri: self) else { return false }
+        return reference.repo == accountDID && reference.collection == collection
+    }
+}
+
+private extension Dictionary where Key == String, Value == JSONValue {
+    func nonEmptyString(_ key: String) -> String? {
+        guard let value = self[key]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !value.isEmpty
+        else { return nil }
+        return value
+    }
+
+    func hasType(_ expected: String) -> Bool {
+        self["$type"] == nil || self["$type"]?.stringValue == expected
+    }
+
+    func strongReferenceURI(_ key: String) -> String? {
+        guard let reference = self[key]?.objectValue,
+              let uri = reference.nonEmptyString("uri"),
+              reference.nonEmptyString("cid") != nil
+        else { return nil }
+        return uri
+    }
+}
+
+private struct ResearchLoadingKey: StorageKey {
+    typealias Value = any ResearchLoading
+}
+
+extension Application {
+    var research: any ResearchLoading {
+        get { storage[ResearchLoadingKey.self] ?? ResearchService() }
+        set { storage[ResearchLoadingKey.self] = newValue }
+    }
+}
diff --git a/services/backend/Sources/App/routes.swift b/services/backend/Sources/App/routes.swift
index 4d15d61..4ccd511 100644
--- a/services/backend/Sources/App/routes.swift
+++ b/services/backend/Sources/App/routes.swift
@@ -12,6 +12,7 @@ func routes(_ app: Application) throws {
     try api.register(collection: AssetController())
     try api.register(collection: UnsplashController())
     try api.register(collection: FeedbackController())
+    try api.register(collection: ResearchController())
 
     app.get("health") { _ in
         HealthResponse(ok: true)
diff --git a/services/backend/Tests/AppTests/ResearchTests.swift b/services/backend/Tests/AppTests/ResearchTests.swift
new file mode 100644
index 0000000..02a6cee
--- /dev/null
+++ b/services/backend/Tests/AppTests/ResearchTests.swift
@@ -0,0 +1,403 @@
+@testable import App
+import Foundation
+import Testing
+import Vapor
+import VaporTesting
+
+@Suite("Research")
+struct ResearchTests {
+    @Test("Semble aggregation keeps current own records and applies link removals")
+    func sembleAggregation() async throws {
+        try await withApp(configure: configure) { app in
+            let did = "did:plc:research-semble"
+            let collectionURI = researchURI(did, "network.cosmik.collection", "ideas")
+            let olderCollectionURI = researchURI(did, "network.cosmik.collection", "older")
+            let urlCardURI = researchURI(did, "network.cosmik.card", "url-card")
+            let noteCardURI = researchURI(did, "network.cosmik.card", "note-card")
+            let removedCardURI = researchURI(did, "network.cosmik.card", "removed-card")
+            let removedLinkURI = researchURI(did, "network.cosmik.collectionLink", "removed-link")
+            let lister = StubResearchRecordLister(pages: [
+                researchPageKey("network.cosmik.collection"): ListRecordsResponse(records: [
+                    researchRecord(uri: olderCollectionURI, value: [
+                        "$type": .string("network.cosmik.collection"),
+                        "name": .string("Older ideas"),
+                        "accessType": .string("OPEN"),
+                        "createdAt": .string("2026-07-01T00:00:00Z"),
+                    ]),
+                    researchRecord(uri: collectionURI, value: [
+                        "$type": .string("network.cosmik.collection"),
+                        "name": .string("Draft ideas"),
+                        "description": .string("Things to explore"),
+                        "accessType": .string("CLOSED"),
+                        "createdAt": .string("2026-08-01T00:00:00Z"),
+                        "updatedAt": .string("2026-08-02T00:00:00Z"),
+                        "ignoredExtension": .bool(true),
+                    ]),
+                    researchRecord(
+                        uri: researchURI(did, "network.cosmik.collection", "malformed"),
+                        value: ["accessType": .string("OPEN")]
+                    ),
+                    researchRecord(
+                        uri: researchURI("did:plc:someone-else", "network.cosmik.collection", "other"),
+                        value: ["name": .string("Other"), "accessType": .string("OPEN")]
+                    ),
+                ], cursor: nil),
+                researchPageKey("network.cosmik.card"): ListRecordsResponse(records: [
+                    researchRecord(uri: urlCardURI, value: [
+                        "$type": .string("network.cosmik.card"),
+                        "type": .string("URL"),
+                        "content": .object([
+                            "$type": .string("network.cosmik.card#urlContent"),
+                            "url": .string("https://example.com/article"),
+                            "metadata": .object([
+                                "$type": .string("network.cosmik.card#urlMetadata"),
+                                "title": .string("An article"),
+                                "description": .string("Useful context"),
+                                "siteName": .string("Example"),
+                                "author": .string("A. Writer"),
+                            ]),
+                        ]),
+                        "createdAt": .string("2026-08-03T00:00:00Z"),
+                    ]),
+                    researchRecord(uri: noteCardURI, value: [
+                        "type": .string("NOTE"),
+                        "url": .string("https://example.com/note-source"),
+                        "content": .object([
+                            "$type": .string("network.cosmik.card#noteContent"),
+                            "text": .string("A connection worth developing"),
+                        ]),
+                        "createdAt": .string("2026-08-04T00:00:00Z"),
+                    ]),
+                    researchRecord(uri: removedCardURI, value: [
+                        "type": .string("URL"),
+                        "content": .object(["url": .string("https://example.com/removed")]),
+                    ]),
+                ], cursor: nil),
+                researchPageKey("network.cosmik.collectionLink"): ListRecordsResponse(records: [
+                    researchCollectionLink(
+                        uri: researchURI(did, "network.cosmik.collectionLink", "url-link"),
+                        collectionURI: collectionURI,
+                        cardURI: urlCardURI,
+                        did: did
+                    ),
+                    researchCollectionLink(
+                        uri: researchURI(did, "network.cosmik.collectionLink", "note-link"),
+                        collectionURI: collectionURI,
+                        cardURI: noteCardURI,
+                        did: did
+                    ),
+                    researchCollectionLink(
+                        uri: removedLinkURI,
+                        collectionURI: collectionURI,
+                        cardURI: removedCardURI,
+                        did: did
+                    ),
+                ], cursor: nil),
+                researchPageKey("network.cosmik.collectionLinkRemoval"): ListRecordsResponse(records: [
+                    researchRecord(
+                        uri: researchURI(did, "network.cosmik.collectionLinkRemoval", "removal"),
+                        value: [
+                            "$type": .string("network.cosmik.collectionLinkRemoval"),
+                            "collection": researchStrongRef(collectionURI),
+                            "removedLink": researchStrongRef(removedLinkURI),
+                            "removedAt": .string("2026-08-05T00:00:00Z"),
+                        ]
+                    ),
+                ], cursor: nil),
+            ])
+            let request = Request(application: app, on: app.eventLoopGroup.next())
+
+            let collections = try await ResearchService(records: lister).fetchSemble(
+                account: researchAccount(did: did),
+                req: request
+            )
+
+            let collection = try #require(collections.first)
+            #expect(collections.map(\.uri) == [collectionURI, olderCollectionURI])
+            #expect(collection.uri == collectionURI)
+            #expect(collection.name == "Draft ideas")
+            #expect(collection.description == "Things to explore")
+            #expect(collection.accessType == "CLOSED")
+            #expect(collection.createdAt == "2026-08-01T00:00:00Z")
+            #expect(collection.updatedAt == "2026-08-02T00:00:00Z")
+            #expect(collection.cards.map(\.uri) == [noteCardURI, urlCardURI])
+            #expect(collection.cards[0].note == "A connection worth developing")
+            #expect(collection.cards[0].url == "https://example.com/note-source")
+            #expect(collection.cards[1].url == "https://example.com/article")
+            #expect(collection.cards[1].title == "An article")
+            #expect(collection.cards[1].description == "Useful context")
+            #expect(collection.cards[1].siteName == "Example")
+            #expect(collection.cards[1].author == "A. Writer")
+        }
+    }
+
+    @Test("Margin aggregation maps the unified note schema and skips malformed or other-user records")
+    func marginAggregation() async throws {
+        try await withApp(configure: configure) { app in
+            let did = "did:plc:research-margin"
+            let uri = researchURI(did, "at.margin.note", "annotation")
+            let olderURI = researchURI(did, "at.margin.note", "older")
+            let lister = StubResearchRecordLister(pages: [
+                researchPageKey("at.margin.note"): ListRecordsResponse(records: [
+                    researchRecord(uri: olderURI, value: [
+                        "motivation": .string("bookmarking"),
+                        "target": .object(["source": .string("https://example.com/older")]),
+                        "createdAt": .string("2026-07-01T00:00:00Z"),
+                    ]),
+                    researchRecord(uri: uri, value: [
+                        "$type": .string("at.margin.note"),
+                        "motivation": .string("highlighting"),
+                        "target": .object([
+                            "source": .string("https://example.com/essay"),
+                            "title": .string("An essay"),
+                            "selector": .object([
+                                "type": .string("TextQuoteSelector"),
+                                "exact": .string("A precise passage"),
+                                "prefix": .string("before"),
+                                "suffix": .string("after"),
+                            ]),
+                        ]),
+                        "body": .object([
+                            "value": .string("This could become a section."),
+                            "format": .string("text/plain"),
+                        ]),
+                        "tags": .array([.string("draft"), .string("research")]),
+                        "color": .string("yellow"),
+                        "createdAt": .string("2026-08-06T00:00:00Z"),
+                        "modifiedAt": .string("2026-08-07T00:00:00Z"),
+                    ]),
+                    researchRecord(
+                        uri: researchURI(did, "at.margin.note", "malformed"),
+                        value: ["motivation": .string("commenting")]
+                    ),
+                    researchRecord(
+                        uri: researchURI("did:plc:someone-else", "at.margin.note", "other"),
+                        value: [
+                            "motivation": .string("commenting"),
+                            "target": .object(["source": .string("https://other.example")]),
+                            "createdAt": .string("2026-08-01T00:00:00Z"),
+                        ]
+                    ),
+                ], cursor: nil),
+            ])
+            let request = Request(application: app, on: app.eventLoopGroup.next())
+
+            let annotations = try await ResearchService(records: lister).fetchMargin(
+                account: researchAccount(did: did),
+                req: request
+            )
+
+            let annotation = try #require(annotations.first)
+            #expect(annotations.map(\.uri) == [uri, olderURI])
+            #expect(annotation.uri == uri)
+            #expect(annotation.motivation == "highlighting")
+            #expect(annotation.source == "https://example.com/essay")
+            #expect(annotation.title == "An essay")
+            #expect(annotation.body == "This could become a section.")
+            #expect(annotation.quote == "A precise passage")
+            #expect(annotation.tags == ["draft", "research"])
+            #expect(annotation.color == "yellow")
+            #expect(annotation.createdAt == "2026-08-06T00:00:00Z")
+            #expect(annotation.modifiedAt == "2026-08-07T00:00:00Z")
+        }
+    }
+
+    @Test("Generic paginator reads all pages and rejects cursor cycles")
+    func paginationAndCycleSafety() async throws {
+        try await withApp(configure: configure) { app in
+            let did = "did:plc:research-pages"
+            let first = researchRecord(
+                uri: researchURI(did, "at.margin.note", "first"),
+                value: ["value": .string("first")]
+            )
+            let second = researchRecord(
+                uri: researchURI(did, "at.margin.note", "second"),
+                value: ["value": .string("second")]
+            )
+            let lister = StubResearchRecordLister(pages: [
+                researchPageKey("at.margin.note"): ListRecordsResponse(records: [first], cursor: "two"),
+                researchPageKey("at.margin.note", cursor: "two"): ListRecordsResponse(records: [second], cursor: nil),
+            ])
+
+            let records = try await RepositoryRecordPaginator(records: lister).listAll(
+                account: researchAccount(did: did),
+                collection: "at.margin.note",
+                client: app.client
+            )
+            #expect(records.map(\.uri) == [first.uri, second.uri])
+
+            let cycling = StubResearchRecordLister(pages: [
+                researchPageKey("network.cosmik.card"): ListRecordsResponse(records: [first], cursor: "same"),
+                researchPageKey("network.cosmik.card", cursor: "same"): ListRecordsResponse(records: [second], cursor: "same"),
+            ])
+            await #expect(throws: (any Error).self) {
+                try await RepositoryRecordPaginator(records: cycling).listAll(
+                    account: researchAccount(did: did),
+                    collection: "network.cosmik.card",
+                    client: app.client
+                )
+            }
+        }
+    }
+
+    @Test("Source failures are isolated and legacy Margin collections are not queried")
+    func partialSourceFailure() async throws {
+        try await withApp(configure: configure) { app in
+            let did = "did:plc:research-partial"
+            let marginURI = researchURI(did, "at.margin.note", "available")
+            let lister = StubResearchRecordLister(
+                pages: [
+                    researchPageKey("at.margin.note"): ListRecordsResponse(records: [
+                        researchRecord(uri: marginURI, value: [
+                            "motivation": .string("bookmarking"),
+                            "target": .object(["source": .string("https://available.example")]),
+                            "createdAt": .string("2026-08-08T00:00:00Z"),
+                        ]),
+                    ], cursor: nil),
+                ],
+                failingCollections: ["network.cosmik.collection"]
+            )
+            let request = Request(application: app, on: app.eventLoopGroup.next())
+
+            let response = await ResearchService(records: lister).load(
+                account: researchAccount(did: did),
+                req: request
+            )
+
+            #expect(response.semble.collections.isEmpty)
+            #expect(response.semble.error != nil)
+            #expect(response.margin.error == nil)
+            #expect(response.margin.annotations.map(\.uri) == [marginURI])
+            let requested = Set(await lister.requestedCollections())
+            let currentCollections: Set<String> = [
+                "network.cosmik.collection",
+                "network.cosmik.collectionLink",
+                "network.cosmik.collectionLinkRemoval",
+                "network.cosmik.card",
+                "at.margin.note",
+            ]
+            #expect(requested.contains("network.cosmik.collection"))
+            #expect(requested.contains("at.margin.note"))
+            #expect(requested.isSubset(of: currentCollections))
+        }
+    }
+
+    @Test("Research endpoint requires the browser session and uses its linked account")
+    func authenticatedEndpoint() async throws {
+        try await withApp(configure: configure) { app in
+            let did = "did:plc:research-endpoint"
+            let cookie = try await authenticatedCookie(for: did, app: app)
+            app.research = FixedResearchLoader(expectedDID: did)
+
+            try await app.testing().test(.GET, "/api/research") { _ in
+            } afterResponse: { response in
+                #expect(response.status == .unauthorized)
+            }
+
+            try await app.testing().test(.GET, "/api/research") { request in
+                request.headers.replaceOrAdd(name: .cookie, value: cookie)
+            } afterResponse: { response in
+                #expect(response.status == .ok)
+                expectContent(ResearchResponse.self, response) { research in
+                    #expect(research.semble.collections.first?.name == "Own research")
+                    #expect(research.margin.annotations.isEmpty)
+                }
+            }
+        }
+    }
+}
+
+private actor StubResearchRecordLister: RepositoryRecordPageListing {
+    let pages: [String: ListRecordsResponse<JSONValue>]
+    let failingCollections: Set<String>
+    private var requested: [String] = []
+
+    init(
+        pages: [String: ListRecordsResponse<JSONValue>],
+        failingCollections: Set<String> = []
+    ) {
+        self.pages = pages
+        self.failingCollections = failingCollections
+    }
+
+    func listRecordsPage(
+        account: LinkedAccount,
+        collection: String,
+        cursor: String?,
+        client: Client
+    ) async throws -> ListRecordsResponse<JSONValue> {
+        requested.append(collection)
+        if failingCollections.contains(collection) {
+            throw Abort(.badGateway, reason: "Stubbed \(collection) failure")
+        }
+        return pages[researchPageKey(collection, cursor: cursor)] ?? ListRecordsResponse(records: [], cursor: nil)
+    }
+
+    func requestedCollections() -> [String] { requested }
+}
+
+private struct FixedResearchLoader: ResearchLoading {
+    let expectedDID: String
+
+    func load(account: LinkedAccount, req: Request) async -> ResearchResponse {
+        ResearchResponse(
+            semble: SembleResearchResponse(collections: [
+                SembleCollectionResponse(
+                    uri: researchURI(expectedDID, "network.cosmik.collection", "own"),
+                    name: account.did == expectedDID ? "Own research" : "Wrong account",
+                    description: nil,
+                    accessType: "CLOSED",
+                    createdAt: nil,
+                    updatedAt: nil,
+                    cards: []
+                ),
+            ], error: nil),
+            margin: MarginResearchResponse(annotations: [], error: nil)
+        )
+    }
+}
+
+private func researchAccount(did: String) -> LinkedAccount {
+    LinkedAccount(
+        did: did,
+        handle: "researcher.example",
+        pdsURL: "https://pds.example",
+        scope: "atproto",
+        accessToken: "plain:access",
+        refreshToken: "plain:refresh"
+    )
+}
+
+private func researchURI(_ did: String, _ collection: String, _ rkey: String) -> String {
+    "at://\(did)/\(collection)/\(rkey)"
+}
+
+private func researchPageKey(_ collection: String, cursor: String? = nil) -> String {
+    "\(collection)|\(cursor ?? "")"
+}
+
+private func researchRecord(
+    uri: String,
+    value: [String: JSONValue]
+) -> RepositoryRecord<JSONValue> {
+    RepositoryRecord(uri: uri, cid: "test-cid", value: .object(value))
+}
+
+private func researchStrongRef(_ uri: String) -> JSONValue {
+    .object(["uri": .string(uri), "cid": .string("test-cid")])
+}
+
+private func researchCollectionLink(
+    uri: String,
+    collectionURI: String,
+    cardURI: String,
+    did: String
+) -> RepositoryRecord<JSONValue> {
+    researchRecord(uri: uri, value: [
+        "$type": .string("network.cosmik.collectionLink"),
+        "collection": researchStrongRef(collectionURI),
+        "card": researchStrongRef(cardURI),
+        "addedBy": .string(did),
+        "addedAt": .string("2026-08-05T00:00:00Z"),
+    ])
+}