diff --git a/web/src/app/routes/index.tsx b/web/src/app/routes/index.tsx
index 83c9bc60cf..4c01fed30d 100644
--- a/web/src/app/routes/index.tsx
+++ b/web/src/app/routes/index.tsx
@@ -1,6 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
+import { ChatPage } from "@/features/chat/ui/ChatPage";
 import { NuriWalletGate } from "@/features/nuri-wallet/ui/NuriWalletGate";
-import { ReposPage } from "@/features/repos/ui/ReposPage";
 
 export const Route = createFileRoute("/")({
   component: IndexPage,
@@ -9,7 +9,7 @@ export const Route = createFileRoute("/")({
 function IndexPage() {
   return (
     <NuriWalletGate>
-      <ReposPage />
+      <ChatPage />
     </NuriWalletGate>
   );
 }
diff --git a/web/src/app/routes/repos.tsx b/web/src/app/routes/repos.tsx
index b58d39ada2..ad6dfbeaaf 100644
--- a/web/src/app/routes/repos.tsx
+++ b/web/src/app/routes/repos.tsx
@@ -1,5 +1,15 @@
-import { Navigate, createFileRoute } from "@tanstack/react-router";
+import { createFileRoute } from "@tanstack/react-router";
+import { NuriWalletGate } from "@/features/nuri-wallet/ui/NuriWalletGate";
+import { ReposPage } from "@/features/repos/ui/ReposPage";
 
 export const Route = createFileRoute("/repos")({
-  component: () => <Navigate to="/" />,
+  component: RepositoriesPage,
 });
+
+function RepositoriesPage() {
+  return (
+    <NuriWalletGate>
+      <ReposPage />
+    </NuriWalletGate>
+  );
+}
diff --git a/web/src/features/chat/lib/chat-client.ts b/web/src/features/chat/lib/chat-client.ts
new file mode 100644
index 0000000000..3b9b057646
--- /dev/null
+++ b/web/src/features/chat/lib/chat-client.ts
@@ -0,0 +1,105 @@
+import {
+  type NostrEvent,
+  publishEvent,
+  queryEvents,
+  subscribeEvents,
+} from "@/shared/lib/nostr-client";
+import { getBrowserPublicKey, signNostrEvent } from "@/shared/lib/nostr-signer";
+import { relayWsUrl } from "@/shared/lib/relay-url";
+import {
+  type ChatChannel,
+  mergeChatMessages,
+  projectChatChannels,
+  selectAutoJoinChannel,
+} from "./chat";
+
+const CHANNEL_QUERY_LIMIT = 500;
+const MESSAGE_QUERY_LIMIT = 100;
+const MAX_MESSAGE_LENGTH = 60_000;
+const CHAT_MESSAGE_KINDS = [9, 40002];
+
+async function queryChannelCatalog(
+  wsUrl: string,
+  pubkey: string,
+): Promise<ChatChannel[]> {
+  const [memberships, metadata] = await Promise.all([
+    queryEvents(wsUrl, {
+      kinds: [39002],
+      "#p": [pubkey],
+      limit: CHANNEL_QUERY_LIMIT,
+    }),
+    queryEvents(wsUrl, { kinds: [39000], limit: CHANNEL_QUERY_LIMIT }),
+  ]);
+  return projectChatChannels(memberships, metadata);
+}
+
+export type ChatCatalog = {
+  pubkey: string;
+  channels: ChatChannel[];
+};
+
+export async function loadChatCatalog(): Promise<ChatCatalog> {
+  const wsUrl = relayWsUrl();
+  const pubkey = await getBrowserPublicKey();
+  let channels = await queryChannelCatalog(wsUrl, pubkey);
+  const autoJoin = selectAutoJoinChannel(channels);
+  if (autoJoin) {
+    await joinChatChannel(autoJoin.id);
+    channels = await queryChannelCatalog(wsUrl, pubkey);
+  }
+  return { pubkey, channels };
+}
+
+export async function joinChatChannel(channelId: string): Promise<void> {
+  const signed = await signNostrEvent({
+    kind: 9021,
+    tags: [["h", channelId]],
+    content: "",
+  });
+  await publishEvent(relayWsUrl(), signed);
+}
+
+export async function loadChatMessages(
+  channelId: string,
+): Promise<NostrEvent[]> {
+  const events = await queryEvents(relayWsUrl(), {
+    kinds: CHAT_MESSAGE_KINDS,
+    "#h": [channelId],
+    limit: MESSAGE_QUERY_LIMIT,
+  });
+  return mergeChatMessages([], events);
+}
+
+export async function sendChatMessage(
+  channelId: string,
+  content: string,
+): Promise<NostrEvent> {
+  const trimmed = content.trim();
+  if (!trimmed) throw new Error("Write a message first.");
+  if (trimmed.length > MAX_MESSAGE_LENGTH) {
+    throw new Error("Message is too long.");
+  }
+  const signed = await signNostrEvent({
+    kind: 9,
+    tags: [["h", channelId]],
+    content: trimmed,
+  });
+  await publishEvent(relayWsUrl(), signed);
+  return signed;
+}
+
+export function subscribeToChatChannel(
+  channelId: string,
+  onEvent: (event: NostrEvent) => void,
+  onError: (error: Error) => void,
+): () => void {
+  return subscribeEvents(
+    relayWsUrl(),
+    {
+      kinds: CHAT_MESSAGE_KINDS,
+      "#h": [channelId],
+      since: Math.floor(Date.now() / 1000),
+    },
+    { onEvent, onError },
+  );
+}
diff --git a/web/src/features/chat/lib/chat.ts b/web/src/features/chat/lib/chat.ts
new file mode 100644
index 0000000000..d7798a9a76
--- /dev/null
+++ b/web/src/features/chat/lib/chat.ts
@@ -0,0 +1,111 @@
+import type { NostrEvent } from "@/shared/lib/nostr-client";
+
+export type ChatChannelType = "stream" | "forum" | "dm" | "private" | "unknown";
+export type ChatChannelVisibility = "open" | "private";
+
+export type ChatChannel = {
+  id: string;
+  name: string;
+  type: ChatChannelType;
+  visibility: ChatChannelVisibility;
+  isMember: boolean;
+};
+
+const CHAT_MESSAGE_KINDS = new Set([9, 40002]);
+
+function tagValue(event: NostrEvent, name: string): string | undefined {
+  return event.tags.find((tag) => tag[0] === name)?.[1];
+}
+
+function hasTag(event: NostrEvent, name: string): boolean {
+  return event.tags.some((tag) => tag[0] === name);
+}
+
+function channelType(event: NostrEvent): ChatChannelType {
+  const declared = tagValue(event, "t");
+  if (declared === "forum" || declared === "dm" || declared === "private") {
+    return declared;
+  }
+  if (hasTag(event, "hidden")) return "dm";
+  if (hasTag(event, "private")) return "private";
+  return declared ? "unknown" : "stream";
+}
+
+function channelVisibility(event: NostrEvent): ChatChannelVisibility {
+  return hasTag(event, "private") || channelType(event) === "private"
+    ? "private"
+    : "open";
+}
+
+export function projectChatChannels(
+  membershipEvents: NostrEvent[],
+  metadataEvents: NostrEvent[],
+): ChatChannel[] {
+  const memberships = new Set(
+    membershipEvents
+      .filter((event) => event.kind === 39002)
+      .map((event) => tagValue(event, "d"))
+      .filter((id): id is string => Boolean(id)),
+  );
+  const latestMetadata = new Map<string, NostrEvent>();
+
+  for (const event of metadataEvents) {
+    if (event.kind !== 39000) continue;
+    const id = tagValue(event, "d");
+    if (!id) continue;
+    const previous = latestMetadata.get(id);
+    if (!previous || event.created_at >= previous.created_at) {
+      latestMetadata.set(id, event);
+    }
+  }
+
+  return [...latestMetadata.entries()]
+    .filter(([, event]) => tagValue(event, "archived") !== "true")
+    .map(([id, event]): ChatChannel => {
+      const isMember = memberships.has(id);
+      return {
+        id,
+        name: tagValue(event, "name")?.trim() || "unnamed",
+        type: channelType(event),
+        visibility: channelVisibility(event),
+        isMember,
+      };
+    })
+    .filter((channel) => channel.visibility === "open" || channel.isMember)
+    .sort((left, right) => {
+      if (left.isMember !== right.isMember) return left.isMember ? -1 : 1;
+      const leftGeneral = left.name.toLowerCase() === "general";
+      const rightGeneral = right.name.toLowerCase() === "general";
+      if (leftGeneral !== rightGeneral) return leftGeneral ? -1 : 1;
+      return left.name.localeCompare(right.name, undefined, {
+        sensitivity: "base",
+      });
+    });
+}
+
+export function selectAutoJoinChannel(
+  channels: ChatChannel[],
+): ChatChannel | null {
+  if (channels.some((channel) => channel.isMember)) return null;
+  const candidates = channels.filter(
+    (channel) =>
+      channel.visibility === "open" &&
+      channel.type === "stream" &&
+      channel.name.toLowerCase() === "general",
+  );
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+export function mergeChatMessages(
+  current: NostrEvent[],
+  incoming: NostrEvent[],
+): NostrEvent[] {
+  const byId = new Map<string, NostrEvent>();
+  for (const event of [...current, ...incoming]) {
+    if (CHAT_MESSAGE_KINDS.has(event.kind)) byId.set(event.id, event);
+  }
+  return [...byId.values()].sort(
+    (left, right) =>
+      left.created_at - right.created_at || left.id.localeCompare(right.id),
+  );
+}
diff --git a/web/src/features/chat/ui/ChatPage.tsx b/web/src/features/chat/ui/ChatPage.tsx
new file mode 100644
index 0000000000..9b5e834334
--- /dev/null
+++ b/web/src/features/chat/ui/ChatPage.tsx
@@ -0,0 +1,439 @@
+import { Link } from "@tanstack/react-router";
+import {
+  FolderGit2,
+  Hash,
+  LoaderCircle,
+  MessageCircle,
+  RefreshCw,
+  Send,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+import buzzAppIcon from "@/assets/app-icon@3x.png";
+import {
+  joinChatChannel,
+  loadChatCatalog,
+  loadChatMessages,
+  sendChatMessage,
+  subscribeToChatChannel,
+  type ChatCatalog,
+} from "@/features/chat/lib/chat-client";
+import { mergeChatMessages } from "@/features/chat/lib/chat";
+import type { NostrEvent } from "@/shared/lib/nostr-client";
+import { truncatePubkey } from "@/shared/lib/pubkey";
+import { Button } from "@/shared/ui/button";
+
+type TimelineState = {
+  channelId: string | null;
+  events: NostrEvent[];
+  loading: boolean;
+  error: string;
+};
+
+const EMPTY_TIMELINE: TimelineState = {
+  channelId: null,
+  events: [],
+  loading: false,
+  error: "",
+};
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function messageTime(createdAt: number): string {
+  return new Intl.DateTimeFormat(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+  }).format(new Date(createdAt * 1_000));
+}
+
+function MessageRow({
+  event,
+  ownPubkey,
+}: {
+  event: NostrEvent;
+  ownPubkey: string;
+}) {
+  const own = event.pubkey === ownPubkey;
+  const author = own ? "You" : truncatePubkey(event.pubkey);
+  return (
+    <article className="group flex gap-3 px-4 py-3 hover:bg-black/[0.025] dark:hover:bg-white/[0.025] sm:px-6">
+      <div className="mt-0.5 flex h-9 w-9 shrink-0 items-center justify-center rounded-xl bg-primary/15 text-xs font-semibold text-primary">
+        {author.substring(0, 2).toUpperCase()}
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="flex items-baseline gap-2">
+          <span className="text-sm font-semibold text-foreground">
+            {author}
+          </span>
+          <time className="text-xs text-muted-foreground">
+            {messageTime(event.created_at)}
+          </time>
+        </div>
+        <div className="prose prose-sm mt-0.5 max-w-none break-words text-foreground prose-a:text-primary prose-code:text-foreground dark:prose-invert">
+          <ReactMarkdown remarkPlugins={[remarkGfm]}>
+            {event.content}
+          </ReactMarkdown>
+        </div>
+      </div>
+    </article>
+  );
+}
+
+export function ChatPage() {
+  const [catalog, setCatalog] = useState<ChatCatalog | null>(null);
+  const [catalogError, setCatalogError] = useState("");
+  const [catalogLoading, setCatalogLoading] = useState(true);
+  const [activeChannelId, setActiveChannelId] = useState<string | null>(null);
+  const [joiningChannelId, setJoiningChannelId] = useState<string | null>(null);
+  const [timeline, setTimeline] = useState<TimelineState>(EMPTY_TIMELINE);
+  const [connectionError, setConnectionError] = useState("");
+  const [draft, setDraft] = useState("");
+  const [sending, setSending] = useState(false);
+  const catalogRequest = useRef<Promise<ChatCatalog> | null>(null);
+  const timelineEnd = useRef<HTMLDivElement>(null);
+
+  const refreshCatalog = useCallback(async (force = false) => {
+    setCatalogLoading(true);
+    setCatalogError("");
+    if (force || !catalogRequest.current) {
+      catalogRequest.current = loadChatCatalog();
+    }
+    try {
+      const loaded = await catalogRequest.current;
+      setCatalog(loaded);
+      setActiveChannelId((current) => {
+        if (loaded.channels.some((channel) => channel.id === current)) {
+          return current;
+        }
+        return (
+          loaded.channels.find((channel) => channel.isMember)?.id ??
+          loaded.channels[0]?.id ??
+          null
+        );
+      });
+    } catch (error) {
+      setCatalogError(errorMessage(error));
+    } finally {
+      setCatalogLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void refreshCatalog();
+  }, [refreshCatalog]);
+
+  const activeChannel = useMemo(
+    () =>
+      catalog?.channels.find((channel) => channel.id === activeChannelId) ??
+      null,
+    [activeChannelId, catalog],
+  );
+
+  useEffect(() => {
+    if (!activeChannel?.isMember) {
+      setTimeline(EMPTY_TIMELINE);
+      return;
+    }
+    let cancelled = false;
+    setConnectionError("");
+    setTimeline({
+      channelId: activeChannel.id,
+      events: [],
+      loading: true,
+      error: "",
+    });
+
+    const closeSubscription = subscribeToChatChannel(
+      activeChannel.id,
+      (event) => {
+        if (cancelled) return;
+        setTimeline((current) =>
+          current.channelId === activeChannel.id
+            ? {
+                ...current,
+                events: mergeChatMessages(current.events, [event]),
+              }
+            : current,
+        );
+      },
+      (error) => {
+        if (!cancelled) setConnectionError(error.message);
+      },
+    );
+
+    void loadChatMessages(activeChannel.id)
+      .then((events) => {
+        if (cancelled) return;
+        setTimeline((current) =>
+          current.channelId === activeChannel.id
+            ? {
+                ...current,
+                events: mergeChatMessages(current.events, events),
+                loading: false,
+              }
+            : current,
+        );
+      })
+      .catch((error) => {
+        if (cancelled) return;
+        setTimeline({
+          channelId: activeChannel.id,
+          events: [],
+          loading: false,
+          error: errorMessage(error),
+        });
+      });
+
+    return () => {
+      cancelled = true;
+      closeSubscription();
+    };
+  }, [activeChannel]);
+
+  const latestMessageId = timeline.events[timeline.events.length - 1]?.id;
+  useEffect(() => {
+    if (latestMessageId) {
+      timelineEnd.current?.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [latestMessageId]);
+
+  const join = async () => {
+    if (!activeChannel || joiningChannelId) return;
+    setJoiningChannelId(activeChannel.id);
+    setCatalogError("");
+    try {
+      await joinChatChannel(activeChannel.id);
+      catalogRequest.current = null;
+      await refreshCatalog(true);
+      setActiveChannelId(activeChannel.id);
+    } catch (error) {
+      setCatalogError(errorMessage(error));
+    } finally {
+      setJoiningChannelId(null);
+    }
+  };
+
+  const send = async () => {
+    if (!activeChannel?.isMember || sending || !draft.trim()) return;
+    setSending(true);
+    setConnectionError("");
+    try {
+      const sent = await sendChatMessage(activeChannel.id, draft);
+      setTimeline((current) => ({
+        ...current,
+        events: mergeChatMessages(current.events, [sent]),
+      }));
+      setDraft("");
+    } catch (error) {
+      setConnectionError(errorMessage(error));
+    } finally {
+      setSending(false);
+    }
+  };
+
+  return (
+    <div
+      className="flex min-h-dvh flex-1 flex-col bg-background md:flex-row"
+      data-testid="chat-shell"
+    >
+      <aside className="flex shrink-0 flex-col border-b bg-sidebar md:w-64 md:border-r md:border-b-0">
+        <div className="flex h-16 items-center gap-3 border-b px-4">
+          <img alt="Buzz" className="h-9 w-9 rounded-lg" src={buzzAppIcon} />
+          <div className="min-w-0 flex-1">
+            <p className="truncate text-sm font-semibold">Nuri Buzz</p>
+            <p className="truncate text-xs text-muted-foreground">
+              support.nuri.com
+            </p>
+          </div>
+          <Button
+            aria-label="Refresh channels"
+            onClick={() => void refreshCatalog(true)}
+            size="icon"
+            variant="ghost"
+          >
+            <RefreshCw className={catalogLoading ? "animate-spin" : ""} />
+          </Button>
+        </div>
+
+        <div className="flex items-center justify-between px-4 pt-4 pb-2">
+          <p className="text-xs font-semibold tracking-wide text-muted-foreground uppercase">
+            Channels
+          </p>
+          <Link
+            className="text-muted-foreground hover:text-foreground"
+            title="Repositories"
+            to="/repos"
+          >
+            <FolderGit2 className="h-4 w-4" />
+          </Link>
+        </div>
+
+        <nav className="flex gap-1 overflow-x-auto px-2 pb-3 md:flex-1 md:flex-col md:overflow-y-auto">
+          {catalog?.channels.map((channel) => (
+            <button
+              className={`flex min-w-40 items-center gap-2 rounded-md px-3 py-2 text-left text-sm transition-colors md:min-w-0 ${
+                channel.id === activeChannelId
+                  ? "bg-sidebar-accent font-medium text-sidebar-accent-foreground"
+                  : "text-muted-foreground hover:bg-sidebar-accent/60 hover:text-foreground"
+              }`}
+              key={channel.id}
+              onClick={() => setActiveChannelId(channel.id)}
+              type="button"
+            >
+              <Hash className="h-4 w-4 shrink-0" />
+              <span className="truncate">{channel.name}</span>
+              {!channel.isMember ? (
+                <span className="ml-auto text-xs text-muted-foreground">
+                  Join
+                </span>
+              ) : null}
+            </button>
+          ))}
+          {!catalogLoading && catalog?.channels.length === 0 ? (
+            <p className="px-3 py-4 text-sm text-muted-foreground">
+              No channels available yet.
+            </p>
+          ) : null}
+        </nav>
+      </aside>
+
+      <section className="flex min-h-0 min-w-0 flex-1 flex-col">
+        <header className="flex h-16 shrink-0 items-center gap-3 border-b px-4 sm:px-6">
+          <div className="flex h-9 w-9 items-center justify-center rounded-lg bg-primary/10 text-primary">
+            <Hash className="h-5 w-5" />
+          </div>
+          <div className="min-w-0">
+            <h1 className="truncate text-base font-semibold">
+              {activeChannel?.name ?? "Chat"}
+            </h1>
+            <p className="text-xs text-muted-foreground">
+              {activeChannel?.isMember
+                ? "Connected to Buzz relay"
+                : "Choose or join a channel"}
+            </p>
+          </div>
+        </header>
+
+        {catalogLoading && !catalog ? (
+          <div className="flex flex-1 items-center justify-center gap-2 text-sm text-muted-foreground">
+            <LoaderCircle className="h-5 w-5 animate-spin" /> Loading channels…
+          </div>
+        ) : catalogError ? (
+          <div className="m-6 rounded-lg border border-destructive/30 bg-destructive/10 p-4 text-sm text-destructive">
+            {catalogError}
+          </div>
+        ) : !activeChannel ? (
+          <div className="flex flex-1 flex-col items-center justify-center px-6 text-center">
+            <MessageCircle className="h-10 w-10 text-muted-foreground" />
+            <h2 className="mt-4 text-lg font-semibold">No chat channel yet</h2>
+            <p className="mt-1 max-w-md text-sm text-muted-foreground">
+              An administrator needs to create the first open channel.
+            </p>
+          </div>
+        ) : !activeChannel.isMember ? (
+          <div className="flex flex-1 flex-col items-center justify-center px-6 text-center">
+            <Hash className="h-10 w-10 text-muted-foreground" />
+            <h2 className="mt-4 text-lg font-semibold">
+              Join #{activeChannel.name}
+            </h2>
+            <p className="mt-1 max-w-md text-sm text-muted-foreground">
+              Join this open channel to read and send messages.
+            </p>
+            <Button
+              className="mt-5"
+              disabled={joiningChannelId === activeChannel.id}
+              onClick={() => void join()}
+            >
+              {joiningChannelId === activeChannel.id ? (
+                <LoaderCircle className="animate-spin" />
+              ) : (
+                <Hash />
+              )}
+              Join channel
+            </Button>
+          </div>
+        ) : (
+          <>
+            {connectionError ? (
+              <div className="border-b border-destructive/30 bg-destructive/10 px-4 py-2 text-sm text-destructive sm:px-6">
+                {connectionError}
+              </div>
+            ) : null}
+            <div
+              className="min-h-0 flex-1 overflow-y-auto py-3"
+              data-testid="message-list"
+            >
+              {timeline.loading ? (
+                <div className="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground">
+                  <LoaderCircle className="h-5 w-5 animate-spin" /> Loading
+                  messages…
+                </div>
+              ) : timeline.error ? (
+                <p className="px-6 py-8 text-center text-sm text-destructive">
+                  {timeline.error}
+                </p>
+              ) : timeline.events.length === 0 ? (
+                <div className="flex h-full flex-col items-center justify-center px-6 text-center">
+                  <MessageCircle className="h-10 w-10 text-muted-foreground" />
+                  <h2 className="mt-4 text-lg font-semibold">
+                    Start #{activeChannel.name}
+                  </h2>
+                  <p className="mt-1 text-sm text-muted-foreground">
+                    Send the first message to this channel.
+                  </p>
+                </div>
+              ) : (
+                timeline.events.map((event) => (
+                  <MessageRow
+                    event={event}
+                    key={event.id}
+                    ownPubkey={catalog?.pubkey ?? ""}
+                  />
+                ))
+              )}
+              <div ref={timelineEnd} />
+            </div>
+
+            <div className="shrink-0 border-t p-3 sm:p-4">
+              <div className="mx-auto flex max-w-4xl items-end gap-2 rounded-xl border bg-card p-2 shadow-sm focus-within:ring-1 focus-within:ring-ring">
+                <textarea
+                  aria-label={`Message #${activeChannel.name}`}
+                  className="max-h-40 min-h-10 flex-1 resize-none bg-transparent px-2 py-2 text-sm outline-none placeholder:text-muted-foreground"
+                  onChange={(event) => setDraft(event.target.value)}
+                  onKeyDown={(event) => {
+                    if (event.key === "Enter" && !event.shiftKey) {
+                      event.preventDefault();
+                      void send();
+                    }
+                  }}
+                  placeholder={`Message #${activeChannel.name}`}
+                  rows={1}
+                  value={draft}
+                />
+                <Button
+                  aria-label="Send message"
+                  disabled={sending || !draft.trim()}
+                  onClick={() => void send()}
+                  size="icon"
+                >
+                  {sending ? (
+                    <LoaderCircle className="animate-spin" />
+                  ) : (
+                    <Send />
+                  )}
+                </Button>
+              </div>
+              <p className="mt-1.5 text-center text-xs text-muted-foreground">
+                Enter to send · Shift+Enter for a new line
+              </p>
+            </div>
+          </>
+        )}
+      </section>
+    </div>
+  );
+}
diff --git a/web/src/features/nuri-wallet/ui/NuriWalletGate.tsx b/web/src/features/nuri-wallet/ui/NuriWalletGate.tsx
index 330ea2b91c..33f43769ee 100644
--- a/web/src/features/nuri-wallet/ui/NuriWalletGate.tsx
+++ b/web/src/features/nuri-wallet/ui/NuriWalletGate.tsx
@@ -3,7 +3,11 @@ import type { ReactNode } from "react";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import buzzAppIcon from "@/assets/app-icon@3x.png";
-import { lockNuriSigner, unlockNuriSigner } from "@/shared/lib/nostr-signer";
+import {
+  hasNuriSigner,
+  lockNuriSigner,
+  unlockNuriSigner,
+} from "@/shared/lib/nostr-signer";
 import { Button } from "@/shared/ui/button";
 import {
   clearPendingConnectFlow,
@@ -26,7 +30,9 @@ function isLocalPreview(): boolean {
 }
 
 export function NuriWalletGate({ children }: { children: ReactNode }) {
-  const [unlocked, setUnlocked] = useState(isLocalPreview);
+  const [unlocked, setUnlocked] = useState(
+    () => hasNuriSigner() || isLocalPreview(),
+  );
   const [busy, setBusy] = useState(false);
   const [status, setStatus] = useState("");
   const [error, setError] = useState("");
diff --git a/web/src/shared/lib/nostr-client.ts b/web/src/shared/lib/nostr-client.ts
index d8a986ef27..55c6417fb8 100644
--- a/web/src/shared/lib/nostr-client.ts
+++ b/web/src/shared/lib/nostr-client.ts
@@ -24,6 +24,7 @@ export interface NostrFilter {
 export type NostrEvent = SignedNostrEvent;
 
 const QUERY_TIMEOUT_MS = 10_000;
+const PUBLISH_TIMEOUT_MS = 10_000;
 
 /**
  * Open a WebSocket to `wsUrl`, authenticate via NIP-42 if challenged,
@@ -173,3 +174,214 @@ export function queryEvents(
     });
   });
 }
+
+/** Publish a signed event and wait for the relay's matching `OK` response. */
+export function publishEvent(wsUrl: string, event: NostrEvent): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    let settled = false;
+    let eventSent = false;
+    let authEventId: string | null = null;
+    let unauthenticatedPublishTimer: ReturnType<typeof setTimeout> | null =
+      null;
+
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (unauthenticatedPublishTimer) {
+        clearTimeout(unauthenticatedPublishTimer);
+      }
+      ws.close();
+      if (error) reject(error);
+      else resolve();
+    };
+
+    const timeout = setTimeout(
+      () =>
+        finish(
+          new Error(`Relay publish timed out after ${PUBLISH_TIMEOUT_MS}ms`),
+        ),
+      PUBLISH_TIMEOUT_MS,
+    );
+
+    const sendEvent = () => {
+      if (eventSent || settled) return;
+      eventSent = true;
+      ws.send(JSON.stringify(["EVENT", event]));
+    };
+
+    ws.addEventListener("open", () => {
+      unauthenticatedPublishTimer = setTimeout(sendEvent, 100);
+    });
+
+    ws.addEventListener("message", async (message) => {
+      let data: unknown;
+      try {
+        data = JSON.parse(String(message.data));
+      } catch {
+        return;
+      }
+      if (!Array.isArray(data)) return;
+
+      if (data[0] === "AUTH" && typeof data[1] === "string") {
+        if (unauthenticatedPublishTimer) {
+          clearTimeout(unauthenticatedPublishTimer);
+          unauthenticatedPublishTimer = null;
+        }
+        try {
+          const authEvent = await signNostrEvent(makeAuthEvent(wsUrl, data[1]));
+          if (settled) return;
+          authEventId = authEvent.id;
+          ws.send(JSON.stringify(["AUTH", authEvent]));
+        } catch (error) {
+          finish(
+            error instanceof Error
+              ? error
+              : new Error("Failed to sign relay authentication."),
+          );
+        }
+        return;
+      }
+
+      if (data[0] !== "OK") return;
+      if (data[1] === authEventId) {
+        if (data[2] === true) sendEvent();
+        else {
+          finish(
+            new Error(
+              typeof data[3] === "string"
+                ? data[3]
+                : "Relay authentication failed.",
+            ),
+          );
+        }
+      } else if (data[1] === event.id) {
+        if (data[2] === true) finish();
+        else {
+          finish(
+            new Error(
+              typeof data[3] === "string"
+                ? data[3]
+                : "Relay rejected the event.",
+            ),
+          );
+        }
+      }
+    });
+
+    ws.addEventListener("error", () => {
+      finish(new Error("WebSocket connection failed"));
+    });
+    ws.addEventListener("close", () => {
+      if (!settled)
+        finish(new Error("Relay closed before acknowledging event."));
+    });
+  });
+}
+
+type SubscriptionCallbacks = {
+  onEvent(event: NostrEvent): void;
+  onEose?(): void;
+  onError?(error: Error): void;
+};
+
+/** Maintain a live NIP-01 subscription until the returned cleanup is called. */
+export function subscribeEvents(
+  wsUrl: string,
+  filter: NostrFilter,
+  callbacks: SubscriptionCallbacks,
+): () => void {
+  const ws = new WebSocket(wsUrl);
+  const subId = `live-${Date.now().toString(36)}-${crypto.randomUUID()}`;
+  let closedByClient = false;
+  let reqSent = false;
+  let authEventId: string | null = null;
+  let unauthenticatedReqTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const reportError = (error: Error) => {
+    if (!closedByClient) callbacks.onError?.(error);
+  };
+  const sendReq = () => {
+    if (reqSent || closedByClient) return;
+    reqSent = true;
+    ws.send(JSON.stringify(["REQ", subId, filter]));
+  };
+
+  ws.addEventListener("open", () => {
+    unauthenticatedReqTimer = setTimeout(sendReq, 100);
+  });
+  ws.addEventListener("message", async (message) => {
+    let data: unknown;
+    try {
+      data = JSON.parse(String(message.data));
+    } catch {
+      return;
+    }
+    if (!Array.isArray(data)) return;
+
+    if (data[0] === "AUTH" && typeof data[1] === "string") {
+      if (unauthenticatedReqTimer) {
+        clearTimeout(unauthenticatedReqTimer);
+        unauthenticatedReqTimer = null;
+      }
+      try {
+        const authEvent = await signNostrEvent(makeAuthEvent(wsUrl, data[1]));
+        if (closedByClient) return;
+        authEventId = authEvent.id;
+        ws.send(JSON.stringify(["AUTH", authEvent]));
+      } catch (error) {
+        reportError(
+          error instanceof Error
+            ? error
+            : new Error("Failed to sign relay authentication."),
+        );
+        ws.close();
+      }
+      return;
+    }
+
+    if (data[0] === "OK" && data[1] === authEventId) {
+      if (data[2] === true) sendReq();
+      else {
+        reportError(
+          new Error(
+            typeof data[3] === "string"
+              ? data[3]
+              : "Relay authentication failed.",
+          ),
+        );
+        ws.close();
+      }
+    } else if (data[0] === "EVENT" && data[1] === subId && data[2]) {
+      callbacks.onEvent(data[2] as NostrEvent);
+    } else if (data[0] === "EOSE" && data[1] === subId) {
+      callbacks.onEose?.();
+    } else if (data[0] === "CLOSED" && data[1] === subId) {
+      reportError(
+        new Error(
+          typeof data[2] === "string"
+            ? data[2]
+            : "Relay closed the subscription.",
+        ),
+      );
+    }
+  });
+  ws.addEventListener("error", () => {
+    reportError(new Error("WebSocket connection failed"));
+  });
+  ws.addEventListener("close", () => {
+    if (!closedByClient && reqSent) {
+      reportError(new Error("Relay subscription disconnected."));
+    }
+  });
+
+  return () => {
+    closedByClient = true;
+    if (unauthenticatedReqTimer) clearTimeout(unauthenticatedReqTimer);
+    if (reqSent && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(["CLOSE", subId]));
+    }
+    ws.close();
+  };
+}
diff --git a/web/src/shared/lib/nostr-signer.ts b/web/src/shared/lib/nostr-signer.ts
index 06fd9f6c9e..ada503cbae 100644
--- a/web/src/shared/lib/nostr-signer.ts
+++ b/web/src/shared/lib/nostr-signer.ts
@@ -76,6 +76,19 @@ export function hasBrowserSigner(): boolean {
   return hasNuriSigner() || hasNip07Provider();
 }
 
+export async function getBrowserPublicKey(): Promise<string> {
+  if (nuriSecretKey) {
+    return getPublicKey(nuriSecretKey);
+  }
+  const provider = typeof window === "undefined" ? undefined : window.nostr;
+  if (!provider) throw new Nip07UnavailableError();
+  const pubkey = await provider.getPublicKey();
+  if (!/^[0-9a-f]{64}$/i.test(pubkey)) {
+    throw new Error("The NIP-07 extension returned an invalid public key.");
+  }
+  return pubkey.toLowerCase();
+}
+
 function sameUnsignedEvent(
   expected: UnsignedNostrEvent,
   actual: SignedNostrEvent,
diff --git a/web/tests/e2e/smoke.spec.ts b/web/tests/e2e/smoke.spec.ts
index ffb3b34a75..32a4595152 100644
--- a/web/tests/e2e/smoke.spec.ts
+++ b/web/tests/e2e/smoke.spec.ts
@@ -16,7 +16,7 @@ test("home page requires a Nuri wallet", async ({ page }) => {
 });
 
 test("home page shows repositories section", async ({ page }) => {
-  await page.goto("/?preview=repositories");
+  await page.goto("/repos?preview=repositories");
   await expect(page.getByText("Repositories")).toBeVisible();
 });
 
diff --git a/web/tests/unit/chat.test.ts b/web/tests/unit/chat.test.ts
new file mode 100644
index 0000000000..02c1e92af5
--- /dev/null
+++ b/web/tests/unit/chat.test.ts
@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  mergeChatMessages,
+  projectChatChannels,
+  selectAutoJoinChannel,
+} from "../../src/features/chat/lib/chat.ts";
+import type { NostrEvent } from "../../src/shared/lib/nostr-client.ts";
+
+function event(
+  id: string,
+  kind: number,
+  tags: string[][],
+  content = "",
+  createdAt = 1,
+): NostrEvent {
+  return {
+    id: id.padEnd(64, "0"),
+    pubkey: "ab".repeat(32),
+    sig: "cd".repeat(64),
+    kind,
+    tags,
+    content,
+    created_at: createdAt,
+  };
+}
+
+test("projects channel memberships onto relay metadata", () => {
+  const generalId = "11111111-1111-4111-8111-111111111111";
+  const privateId = "22222222-2222-4222-8222-222222222222";
+  const publicId = "33333333-3333-4333-8333-333333333333";
+
+  const channels = projectChatChannels(
+    [
+      event("member-general", 39002, [["d", generalId]]),
+      event("member-private", 39002, [["d", privateId]]),
+    ],
+    [
+      event("meta-public", 39000, [
+        ["d", publicId],
+        ["name", "random"],
+      ]),
+      event("meta-private", 39000, [
+        ["d", privateId],
+        ["name", "staff"],
+        ["private"],
+      ]),
+      event("meta-general", 39000, [
+        ["d", generalId],
+        ["name", "general"],
+      ]),
+    ],
+  );
+
+  assert.deepEqual(
+    channels.map(({ id, name, visibility, isMember }) => ({
+      id,
+      name,
+      visibility,
+      isMember,
+    })),
+    [
+      { id: generalId, name: "general", visibility: "open", isMember: true },
+      { id: privateId, name: "staff", visibility: "private", isMember: true },
+      { id: publicId, name: "random", visibility: "open", isMember: false },
+    ],
+  );
+});
+
+test("hides archived channels and private channels without membership", () => {
+  const archivedId = "44444444-4444-4444-8444-444444444444";
+  const privateId = "55555555-5555-4555-8555-555555555555";
+
+  const channels = projectChatChannels(
+    [],
+    [
+      event("archived", 39000, [
+        ["d", archivedId],
+        ["name", "old"],
+        ["archived", "true"],
+      ]),
+      event("private", 39000, [
+        ["d", privateId],
+        ["name", "secret"],
+        ["private"],
+      ]),
+    ],
+  );
+
+  assert.deepEqual(channels, []);
+});
+
+test("selects the single open general channel only for a new member", () => {
+  const general = {
+    id: "11111111-1111-4111-8111-111111111111",
+    name: "general",
+    type: "stream" as const,
+    visibility: "open" as const,
+    isMember: false,
+  };
+  assert.equal(selectAutoJoinChannel([general]), general);
+  assert.equal(selectAutoJoinChannel([{ ...general, isMember: true }]), null);
+  assert.equal(
+    selectAutoJoinChannel([
+      general,
+      { ...general, id: "22222222-2222-4222-8222-222222222222" },
+    ]),
+    null,
+  );
+});
+
+test("merges supported chat messages by id in chronological order", () => {
+  const channelId = "11111111-1111-4111-8111-111111111111";
+  const first = event("first", 9, [["h", channelId]], "one", 10);
+  const second = event("second", 40002, [["h", channelId]], "two", 20);
+  const unsupported = event("reaction", 7, [["h", channelId]], "+", 30);
+
+  assert.deepEqual(
+    mergeChatMessages([second], [first, second, unsupported]).map(
+      ({ content }) => content,
+    ),
+    ["one", "two"],
+  );
+});
diff --git a/web/tests/unit/nostr-signer.test.ts b/web/tests/unit/nostr-signer.test.ts
index 75eda11ee9..e6a944b35c 100644
--- a/web/tests/unit/nostr-signer.test.ts
+++ b/web/tests/unit/nostr-signer.test.ts
@@ -3,6 +3,7 @@ import test from "node:test";
 import { getPublicKey } from "nostr-tools/pure";
 
 import {
+  getBrowserPublicKey,
   hasNuriSigner,
   lockNuriSigner,
   signNostrEvent,
@@ -16,6 +17,7 @@ test("Nuri signer signs from a copied session key and locks cleanly", async () =
   assert.equal(unlockNuriSigner(secretKey), expectedPubkey);
   secretKey.fill(0);
   assert.equal(hasNuriSigner(), true);
+  assert.equal(await getBrowserPublicKey(), expectedPubkey);
 
   const signed = await signNostrEvent({
     kind: 1,