diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 5e274e9180..cb902958cd 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -138,6 +138,13 @@ that agent in Buzz; they do not notify the external app through this connection.
   it searches only once that word has at least three characters, even with
   `from:` or `in:`. A shorter last word shows how many characters to type, not
   "no results".
+- **Join** in a View only chat or channel adds you as a viewer, with a sidebar
+  entry and normal unread tracking. Notifications follow your existing settings
+  and mention/thread rules. You appear in People as **Viewing only**; you still
+  cannot post or react. Reading without joining stays available.
+  Use **Leave chat** or **Leave channel** to remove your membership and sidebar
+  entry. Joined viewers keep reading after a switch to Private until they leave
+  or are removed in People.
 - **Long text pastes** that exceed the message limit show an error and leave
   your draft unchanged. Shorten the text, or save it as a text file and use
   **Attach files** where uploads are available.
diff --git a/docs/solo/sharing.md b/docs/solo/sharing.md
index da0f6725e9..795c5e3996 100644
--- a/docs/solo/sharing.md
+++ b/docs/solo/sharing.md
@@ -116,12 +116,17 @@ With View only, visitors can find the chat by name in Search Buzz or open its
 ordinary chat link. They read without joining and cannot send messages, react or wake agents.
 The relay's ordinary Guest/default-Guest write policy enforces this boundary;
 the absent composer is only its client presentation. View-only access grants no
-membership and adds no sidebar entry for a visitor. The owner keeps the same
-Solo label, conversation ID and private workspace filing.
+membership and adds no sidebar entry for a visitor. **Join** adds a visitor as a
+Guest, listed in People as **Viewing only**.
+The chat then appears under Solo/Chats with normal unread tracking; notifications
+follow existing settings and mention/thread rules. It stays read-only. **Leave
+chat** removes membership and the sidebar entry; an open chat can still be read
+without joining. The owner keeps the same Solo label, conversation ID and private
+workspace filing.
 
 Changing back to Private stops nonmembers from reading; it does not remove
-members or change their roles. Guests who joined through the CLI, MCP or another
-client while the chat was View only keep read access until removed in People.
+members or change their roles. Guests who joined while the chat was View only
+keep read access until they leave or are removed in People.
 Reading without joining creates no membership to retain. Neither transition
 changes invitations, creates a share message or adds notifications. Unconfirmed
 publication uses **Check save status**, without automatically resending.
diff --git a/src/bundled/channels/ChannelsPage.solo.test.tsx b/src/bundled/channels/ChannelsPage.solo.test.tsx
index 805de0cc19..e0ae4b3697 100644
--- a/src/bundled/channels/ChannelsPage.solo.test.tsx
+++ b/src/bundled/channels/ChannelsPage.solo.test.tsx
@@ -64,11 +64,16 @@ function fixture({
   others = [],
   unread,
   capability = "frontier-sync",
+  viewOnly = false,
+  preview,
 }: {
   /** Observed unread messages in this chat; fakes the read state when given. */
   unread?: number;
   /** What the read state can do on this connection. */
   capability?: "unsupported" | "read-only" | "frontier-sync";
+  viewOnly?: boolean;
+  /** An unjoined reader of an open chat, including legacy admission defaults. */
+  preview?: { joinRole?: "member" | "guest" };
   /** Other Solo chats listed after this one in the sidebar's Chats. */
   others?: readonly string[];
   /** The viewer's own profile has loaded too. */
@@ -120,9 +125,15 @@ function fixture({
     id,
     name: "Planning",
     channelType: type,
-    private: true as const,
+    ...(!preview && { private: true as const }),
     creator: ownedBy ?? (placed ? viewer.pubkey : agent),
     members: [viewer.pubkey, agent, ...people],
+    ...(viewOnly && { readOnly: true as const, viewerRole: "guest" as const }),
+    ...(preview && {
+      members: [agent, ...people],
+      readOnly: true,
+      ...preview,
+    }),
     ...(archived && { archived }),
   };
   const neighbors = others.map((other, index) => ({
@@ -226,10 +237,10 @@ function fixture({
       load: vi.fn(async () => ({
         channelId: id,
         channelType: "stream" as const,
-        canArchive: true,
+        canArchive: !viewOnly,
         canUnarchive: false,
-        canDelete: true,
-        canLeave: false,
+        canDelete: !viewOnly,
+        canLeave: viewOnly,
         canHide: false,
       })),
       run,
@@ -1015,6 +1026,54 @@ it("marks an archived chat once and keeps only its lifecycle actions", async ()
   expect(screen.queryByRole("textbox")).toBeNull();
 });
 
+it.each([
+  { preview: { joinRole: "guest" as const }, joinable: true },
+  { preview: { joinRole: "member" as const }, joinable: false },
+  { preview: {}, joinable: false },
+])(
+  "offers Solo preview Join only for Guest admission ($preview)",
+  async ({ preview, joinable }) => {
+    fixture({ placed: false, preview }).mount();
+    expect(
+      await screen.findByRole("region", {
+        name:
+          "joinRole" in preview && preview.joinRole === "guest"
+            ? "Read-only chat"
+            : "Chat preview",
+      }),
+    ).toBeVisible();
+    expect(screen.queryByRole("textbox")).toBeNull();
+    expect(!!screen.queryByRole("button", { name: "Join" })).toBe(joinable);
+  },
+);
+
+it("lets a joined Solo viewer cancel Leave and restores focus to Chat actions", async () => {
+  const f = fixture({ placed: false, viewOnly: true });
+  f.mountWithSidebar();
+  const row = await screen.findByRole("button", { name: /^Planning/ });
+  expect(row).toBeVisible();
+  expect(screen.queryByRole("textbox")).toBeNull();
+  expect(screen.queryByRole("button", { name: "Join" })).toBeNull();
+  const user = userEvent.setup();
+  const actions = screen.getByRole("button", { name: "Chat actions" });
+  await user.click(actions);
+  const leave = await screen.findByRole("menuitem", { name: "Leave chat" });
+  expect(screen.queryByRole("menuitem", { name: "Archive chat" })).toBeNull();
+  expect(screen.queryByRole("menuitem", { name: "Delete chat" })).toBeNull();
+  await user.click(leave);
+  const dialog = await screen.findByRole("dialog", {
+    name: "Leave chat: Planning",
+  });
+  await waitFor(() =>
+    expect(
+      within(dialog).getByRole("button", { name: "Cancel" }),
+    ).toHaveFocus(),
+  );
+  await user.click(within(dialog).getByRole("button", { name: "Cancel" }));
+  await waitFor(() => expect(actions).toHaveFocus());
+  expect(f.run).not.toHaveBeenCalled();
+});
+
 it.each(["solo", "stream"] as const)(
   "replaces an archived %s composer with a notice and restores its draft on unarchive",
   async (type) => {
diff --git a/src/bundled/channels/ChannelsPage.tsx b/src/bundled/channels/ChannelsPage.tsx
index 5e29c8a32c..e3ebd2603b 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -1886,7 +1886,9 @@ function ChannelWorkspace({
             joinable={
               !current.archived &&
               (current.channelType === "stream" ||
-                current.channelType === "forum")
+                current.channelType === "forum" ||
+                (current.channelType === "solo" &&
+                  current.joinRole === "guest"))
             }
             onJoin={() => setJoiningChannel(current.id)}
             onHeightChange={setJoinNoticeHeight}
diff --git a/src/bundled/channels/SoloChatMenu.tsx b/src/bundled/channels/SoloChatMenu.tsx
index 5274caa566..d001769abc 100644
--- a/src/bundled/channels/SoloChatMenu.tsx
+++ b/src/bundled/channels/SoloChatMenu.tsx
@@ -169,16 +169,18 @@ export function SoloChatMenuItems({
             {conversionLabel(session, channel.id)}
           </MenuItem>
         )}
-      {onLifecycle && !channel.readOnly && !channel.cached && (
-        <ChannelLifecycleMenu
-          channelId={channel.id}
-          lifecycle={session.channelLifecycle}
-          disabled={!!handoff?.lifecycleDialog}
-          separator
-          noun="chat"
-          choose={onLifecycle}
-        />
-      )}
+      {onLifecycle &&
+        (!channel.readOnly || channel.viewerRole === "guest") &&
+        !channel.cached && (
+          <ChannelLifecycleMenu
+            channelId={channel.id}
+            lifecycle={session.channelLifecycle}
+            disabled={!!handoff?.lifecycleDialog}
+            separator
+            noun="chat"
+            choose={onLifecycle}
+          />
+        )}
     </>
   );
 }
diff --git a/src/bundled/channels/SoloHeading.tsx b/src/bundled/channels/SoloHeading.tsx
index 4501240354..0114d0e0e1 100644
--- a/src/bundled/channels/SoloHeading.tsx
+++ b/src/bundled/channels/SoloHeading.tsx
@@ -104,6 +104,8 @@ export function SoloToolbar({
   const owner = useSoloOwner(session, channel);
   const [readError, setReadError] = useState<string>();
   const preferences = session.soloPreferences;
+  const canOpenActions =
+    !channel.cached && (!channel.readOnly || channel.viewerRole === "guest");
   return (
     <>
       {region && (
@@ -132,7 +134,7 @@ export function SoloToolbar({
         </>
       )}
       {/* Archived chats keep their lifecycle actions, including Unarchive. */}
-      {!channel.readOnly && !channel.cached && (
+      {canOpenActions && (
         <MenuRoot key={regions.binding?.incarnation ?? "recovery"}>
           <MenuTrigger
             render={
diff --git a/src/features/messages/ChannelJoinNotice.test.tsx b/src/features/messages/ChannelJoinNotice.test.tsx
index 594918f49e..2232e7b632 100644
--- a/src/features/messages/ChannelJoinNotice.test.tsx
+++ b/src/features/messages/ChannelJoinNotice.test.tsx
@@ -16,9 +16,14 @@ import { ChannelJoinNotice } from "./ChannelJoinNotice";
 
 afterEach(cleanup);
 
-it.each([false, true])(
-  "keeps Guest-default previews read-only with stored Guest membership %s",
-  (guest) => {
+it.each([
+  { guest: false, place: "channel" as const },
+  { guest: true, place: "channel" as const },
+  { guest: false, place: "chat" as const },
+  { guest: true, place: "chat" as const },
+])(
+  "offers a $place preview Join only before Guest membership ($guest)",
+  ({ guest, place }) => {
     const run = vi.fn();
     const started = vi.fn();
     render(
@@ -27,14 +32,17 @@ it.each([false, true])(
         lifecycle={lifecycle(run)}
         joinable
         guest={guest}
+        place={place}
         joinRole="guest"
         onJoin={started}
       />,
     );
     expect(
-      screen.getByRole("region", { name: "Read-only channel" }),
-    ).toHaveTextContent(/^This channel is read-only$/);
-    expect(screen.queryByRole("button", { name: "Join" })).toBeNull();
+      screen.getByRole("region", { name: `Read-only ${place}` }),
+    ).toHaveTextContent(
+      `This ${place} is read-only${guest ? "" : ". Join to keep it in your sidebar and appear as a viewer."}`,
+    );
+    expect(!!screen.queryByRole("button", { name: "Join" })).toBe(!guest);
     expect(run).not.toHaveBeenCalled();
     expect(started).not.toHaveBeenCalled();
   },
@@ -100,47 +108,51 @@ it("offers Join only for a joinable channel on a connection that can send it", (
   expect(run).not.toHaveBeenCalled();
 });
 
-it("joins once, reports its start, and keeps a failed join retryable", async () => {
-  let settle: { resolve(): void; reject(error: unknown): void } | undefined;
-  const run = vi.fn(
-    () =>
-      new Promise<void>((resolve, reject) => {
-        settle = { resolve, reject };
-      }),
-  );
-  const started = vi.fn();
-  render(
-    <ChannelJoinNotice
-      channelId="open"
-      lifecycle={lifecycle(run)}
-      joinable
-      onJoin={started}
-    />,
-  );
-  const button = screen.getByRole("button", { name: "Join" });
-  fireEvent.click(button);
-  fireEvent.click(button);
-  expect(run).toHaveBeenCalledOnce();
-  // The page owns focus handoff; membership may arrive before the run settles.
-  expect(started).toHaveBeenCalledOnce();
-  expect(run).toHaveBeenCalledWith("join", "open", expect.any(AbortSignal));
-  expect(button).toHaveAttribute("aria-disabled", "true");
-  await act(async () =>
-    settle?.reject(new ChannelLifecycleUnconfirmed(new Error("timeout"))),
-  );
-  expect(screen.getByRole("alert")).toHaveTextContent(
-    "Join may have taken effect, but it is not confirmed yet. Try again to check.",
-  );
-  fireEvent.click(screen.getByRole("button", { name: "Join" }));
-  expect(run).toHaveBeenCalledTimes(2);
-  expect(started).toHaveBeenCalledTimes(2);
-  expect(screen.queryByRole("alert")).toBeNull();
-  await act(async () => settle?.resolve());
-  expect(screen.getByRole("button", { name: "Join" })).not.toHaveAttribute(
-    "aria-disabled",
-    "true",
-  );
-});
+it.each(["member", "guest"] as const)(
+  "joins once with %s admission and keeps a failed join retryable",
+  async (joinRole) => {
+    let settle: { resolve(): void; reject(error: unknown): void } | undefined;
+    const run = vi.fn(
+      () =>
+        new Promise<void>((resolve, reject) => {
+          settle = { resolve, reject };
+        }),
+    );
+    const started = vi.fn();
+    render(
+      <ChannelJoinNotice
+        channelId="open"
+        lifecycle={lifecycle(run)}
+        joinable
+        joinRole={joinRole}
+        onJoin={started}
+      />,
+    );
+    const button = screen.getByRole("button", { name: "Join" });
+    fireEvent.click(button);
+    fireEvent.click(button);
+    expect(run).toHaveBeenCalledOnce();
+    // The page owns focus handoff; membership may arrive before the run settles.
+    expect(started).toHaveBeenCalledOnce();
+    expect(run).toHaveBeenCalledWith("join", "open", expect.any(AbortSignal));
+    expect(button).toHaveAttribute("aria-disabled", "true");
+    await act(async () =>
+      settle?.reject(new ChannelLifecycleUnconfirmed(new Error("timeout"))),
+    );
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "Join may have taken effect, but it is not confirmed yet. Try again to check.",
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Join" }));
+    expect(run).toHaveBeenCalledTimes(2);
+    expect(started).toHaveBeenCalledTimes(2);
+    expect(screen.queryByRole("alert")).toBeNull();
+    await act(async () => settle?.resolve());
+    expect(screen.getByRole("button", { name: "Join" })).not.toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+  },
+);
 
 it("waits for content once per channel and stays visible during refresh", () => {
   const props = {
diff --git a/src/features/messages/ChannelJoinNotice.tsx b/src/features/messages/ChannelJoinNotice.tsx
index 203e9e3912..45a578a9a6 100644
--- a/src/features/messages/ChannelJoinNotice.tsx
+++ b/src/features/messages/ChannelJoinNotice.tsx
@@ -5,7 +5,7 @@ import { Button } from "../../shared/design-system/ui/Button";
 import styles from "./Messages.module.css";
 
 /** Archived and read-only channels share the public preview's lower notice.
- * Member-default public previews offer Join; confirmed membership enables composition.
+ * Public previews offer Join; the admission role determines whether joining enables composition.
  * Confirmed membership can unmount this notice before its run settles, so the
  * page records the join intent when the run starts, not when it resolves. */
 export function ChannelJoinNotice({
@@ -72,13 +72,13 @@ export function ChannelJoinNotice({
               ? "Join may have taken effect, but it is not confirmed yet. Try again to check."
               : reason instanceof Error
                 ? reason.message
-                : "Couldn’t join this channel.",
+                : `Couldn’t join this ${place}.`,
         });
       },
     );
   };
   const readOnly = guest || joinRole === "guest";
-  const canJoin = !archived && !readOnly && joinable && !!lifecycle?.available;
+  const canJoin = !archived && !guest && joinable && !!lifecycle?.available;
   return (
     <section
       ref={notice}
@@ -86,8 +86,10 @@ export function ChannelJoinNotice({
         archived
           ? `Archived ${place}`
           : readOnly
-            ? "Read-only channel"
-            : "Channel preview"
+            ? `Read-only ${place}`
+            : place === "chat"
+              ? "Chat preview"
+              : "Channel preview"
       }
       aria-hidden={!visible}
       inert={!visible}
@@ -103,11 +105,11 @@ export function ChannelJoinNotice({
             ? `This ${place} is archived`
             : readOnly
               ? joinRole === "guest"
-                ? `This ${place} is read-only`
+                ? `This ${place} is read-only${canJoin ? ". Join to keep it in your sidebar and appear as a viewer." : ""}`
                 : "Read-only access"
               : canJoin
-                ? "Join channel to send messages"
-                : "You’re previewing this channel"}
+                ? `Join ${place} to send messages`
+                : `You’re previewing this ${place}`}
         </p>
         {canJoin && (
           <Button
diff --git a/src/features/messages/ThreadPanel.test.tsx b/src/features/messages/ThreadPanel.test.tsx
index 33c141fceb..02b364520d 100644
--- a/src/features/messages/ThreadPanel.test.tsx
+++ b/src/features/messages/ThreadPanel.test.tsx
@@ -1517,13 +1517,19 @@ it.each([
   {
     channelType: "stream" as const,
     joinRole: "guest" as const,
-    joinable: false,
+    joinable: true,
   },
   { channelType: "stream" as const, archived: true as const, joinable: false },
   { channelType: "solo" as const, archived: true as const, joinable: false },
+  { channelType: "solo" as const, joinRole: "guest" as const, joinable: true },
+  {
+    channelType: "solo" as const,
+    joinRole: "member" as const,
+    joinable: false,
+  },
   { channelType: "solo" as const, joinable: false },
 ])(
-  "replaces the reply composer for a $channelType preview (joinable: $joinable)",
+  "replaces the reply composer for a $channelType preview (joinRole: $joinRole, joinable: $joinable)",
   ({ joinable, ...metadata }) => {
     const h = messagesHarness();
     Object.assign(h.props, {
@@ -1552,8 +1558,10 @@ it.each([
             ? "Archived chat"
             : "Archived channel"
           : metadata.joinRole === "guest"
-            ? "Read-only channel"
-            : "Channel preview",
+            ? `Read-only ${metadata.channelType === "solo" ? "chat" : "channel"}`
+            : metadata.channelType === "solo"
+              ? "Chat preview"
+              : "Channel preview",
       }),
     ).toBeVisible();
     if (metadata.archived) {
diff --git a/src/features/messages/ThreadPanel.tsx b/src/features/messages/ThreadPanel.tsx
index e4520dd39f..28aa182836 100644
--- a/src/features/messages/ThreadPanel.tsx
+++ b/src/features/messages/ThreadPanel.tsx
@@ -553,7 +553,8 @@ function ThreadMessages({
       if (channel?.viewerRole === "guest") return "guest";
       if (channel?.readOnly && !channel.cached) {
         return channel.channelType === "stream" ||
-          channel.channelType === "forum"
+          channel.channelType === "forum" ||
+          (channel.channelType === "solo" && channel.joinRole === "guest")
           ? "joinable"
           : "preview";
       }
diff --git a/src/features/relay/channel-lifecycle.test.ts b/src/features/relay/channel-lifecycle.test.ts
index 320baff6db..a62f548bef 100644
--- a/src/features/relay/channel-lifecycle.test.ts
+++ b/src/features/relay/channel-lifecycle.test.ts
@@ -1795,7 +1795,7 @@ describe("join from a public preview", () => {
     const h = preview(tags);
     try {
       await expect(h.owner.capability.run("join", id)).rejects.toThrow(
-        "Only active public channels can be joined.",
+        "This conversation can’t be joined right now.",
       );
       expect(h.sign).not.toHaveBeenCalled();
       expect(h.acceptDiscovery).not.toHaveBeenCalled();
diff --git a/src/features/relay/channel-lifecycle.ts b/src/features/relay/channel-lifecycle.ts
index d1611a4add..e67978614a 100644
--- a/src/features/relay/channel-lifecycle.ts
+++ b/src/features/relay/channel-lifecycle.ts
@@ -385,7 +385,7 @@ export function createChannelLifecycle({
               !openMetadata(channel) ||
               exactLifecycleTag(channel, "archived") === "true"
             )
-              throw new Error("Only active public channels can be joined.");
+              throw new Error("This conversation can’t be joined right now.");
             return false;
           };
           const authorize = async () => {
diff --git a/src/features/solo/labels.test.ts b/src/features/solo/labels.test.ts
index 5882cc075d..0d6b537ae1 100644
--- a/src/features/solo/labels.test.ts
+++ b/src/features/solo/labels.test.ts
@@ -1,5 +1,7 @@
 import { expect, it } from "vitest";
+import type { ChannelSummary } from "../relay/contracts";
 import {
+  eligibleSolo,
   ownSolo,
   SOLO_NAMED_LABEL,
   SOLO_LABEL,
@@ -11,6 +13,43 @@ const id = "22222222-2222-4222-8222-222222222222";
 const owner = "a".repeat(64);
 const guest = "b".repeat(64);
 
+it.each([
+  { name: "joined viewer", changes: {}, expected: true },
+  { name: "departed viewer", changes: { members: [owner] }, expected: false },
+  { name: "empty roster", changes: { members: [] }, expected: false },
+  {
+    name: "unjoined reader",
+    changes: { viewerRole: undefined, members: [owner] },
+    expected: false,
+  },
+  { name: "archived membership", changes: { archived: true }, expected: false },
+  {
+    name: "ordinary channel",
+    changes: { channelType: "stream" },
+    expected: false,
+  },
+] satisfies {
+  name: string;
+  changes: Partial<ChannelSummary>;
+  expected: boolean;
+}[])(
+  "lists a $name in Solo only with current membership",
+  ({ changes, expected }) => {
+    const channel: ChannelSummary = {
+      id,
+      name: "Shared chat",
+      channelType: "solo",
+      creator: owner,
+      readOnly: true,
+      viewerRole: "guest",
+      members: [owner, guest],
+      ...changes,
+    };
+    expect(eligibleSolo(channel, guest)).toBe(expected);
+    expect(eligibleSolo(channel, undefined)).toBe(false);
+  },
+);
+
 it("names shared chats by their current name, falling back to the short ID", () => {
   expect(soloChatLinkName({ id, name: "Investigate the flaky test" })).toBe(
     "Investigate the flaky test",
diff --git a/src/features/solo/labels.ts b/src/features/solo/labels.ts
index 5b8923f284..9ed1a854b3 100644
--- a/src/features/solo/labels.ts
+++ b/src/features/solo/labels.ts
@@ -57,6 +57,10 @@ export function eligibleSolo(
   return (
     !channel.archived &&
     channel.channelType === "solo" &&
-    (!channel.readOnly || ownSolo(channel, viewer))
+    (!channel.readOnly ||
+      ownSolo(channel, viewer) ||
+      (!!viewer &&
+        channel.viewerRole === "guest" &&
+        !!channel.members?.includes(viewer)))
   );
 }
diff --git a/tests/browser/channel-permissions.spec.mjs b/tests/browser/channel-permissions.spec.mjs
index 9677ab2280..d60576e922 100644
--- a/tests/browser/channel-permissions.spec.mjs
+++ b/tests/browser/channel-permissions.spec.mjs
@@ -41,7 +41,7 @@ async function readPermalink(page, app, messageId, joined = false) {
   ).toBeVisible();
   await expect(
     page.getByRole("button", { name: "Join", exact: true }),
-  ).toHaveCount(0);
+  ).toHaveCount(joined ? 0 : 2);
   await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
   // Opening the actual message menu settles the deferred message actions.
   await hoverMessage(row);
@@ -110,7 +110,7 @@ test.describe("Guest-default permalinks", () => {
 
   test.describe("nonmember", () => {
     test.use({ lifecycleRole: "nonmember" });
-    test("old message and nested reply links read without joining", async ({
+    test("old message and nested reply links read without joining, then join explicitly", async ({
       page,
       app,
     }) => {
@@ -118,6 +118,23 @@ test.describe("Guest-default permalinks", () => {
       await readPermalink(page, app, app.exact.root.id);
       await readPermalink(page, app, app.exact.target.id);
       expectNotJoined(app);
+      const join = page
+        .getByRole("button", { name: "Join", exact: true })
+        .last();
+      await join.focus();
+      await join.press("Enter");
+      await expect(
+        page.getByRole("button", { name: "Join", exact: true }),
+      ).toHaveCount(0);
+      await expect(
+        page
+          .getByRole("navigation", { name: "Subscribed channels" })
+          .getByRole("button", { name: /^Lifecycle channel/ }),
+      ).toBeVisible();
+      await readPermalink(page, app, app.exact.target.id, true);
+      expect(app.report.lifecyclePublications.map(({ kind }) => kind)).toEqual([
+        9021,
+      ]);
     });
   });
 
diff --git a/tests/browser/fixture.mjs b/tests/browser/fixture.mjs
index cc62e948c6..8195d31e74 100644
--- a/tests/browser/fixture.mjs
+++ b/tests/browser/fixture.mjs
@@ -337,6 +337,8 @@ export const test = base.extend({
     const archivedIds = new Set(lifecycleVisibility.archived);
     const hiddenDmIds = new Set(lifecycleVisibility.hidden);
     let lifecycleTime = 1700000001;
+    const joinedRoles = new Map();
+    const channelGuests = new Map();
     const rosterIds = [
       ...new Set([
         ...channels,
@@ -1043,6 +1045,7 @@ export const test = base.extend({
       );
       if (preview && rosterKind) {
         const owner = preview.tags.find(([key]) => key === "P")?.[1];
+        if (filter["#p"] && !filter["#p"].includes(owner)) return [];
         return [
           sign(
             rosterKind,
@@ -1161,56 +1164,69 @@ export const test = base.extend({
         return rosterIds
           .filter((id) => !filter["#d"] || filter["#d"].includes(id))
           .map((id) =>
-            sign(39002, [
-              ["d", id],
+            sign(
+              39002,
               [
-                "p",
-                viewer,
-                "",
-                lifecycleRows.some((row) => row.id === id) ||
-                ownSoloChannels.includes(id)
-                  ? lifecycleRole === "nonmember"
-                    ? "member"
-                    : lifecycleRole
-                  : "member",
+                ["d", id],
+                [
+                  "p",
+                  viewer,
+                  "",
+                  joinedRoles.get(id) ??
+                    (lifecycleRows.some((row) => row.id === id) ||
+                    ownSoloChannels.includes(id)
+                      ? lifecycleRole === "nonmember"
+                        ? "member"
+                        : lifecycleRole
+                      : "member"),
+                ],
+                ...(ownSoloChannels.includes(id)
+                  ? soloAgents.map(({ pubkey }) => ["p", pubkey, "", "member"])
+                  : []),
+                ...(ownerAgent && lifecycleRows.some((row) => row.id === id)
+                  ? [["p", ownerAgent, "", "owner"]]
+                  : []),
+                ...(sessionMembers[id] ?? []).map((pubkey) => [
+                  "p",
+                  pubkey,
+                  "",
+                  "member",
+                ]),
+                ...[...(channelGuests.get(id) ?? [])].map((pubkey) => [
+                  "p",
+                  pubkey,
+                  "",
+                  "guest",
+                ]),
+                ...(dmMembers[id]
+                  ? dmMembers[id].map((index) => [
+                      "p",
+                      participants[index],
+                      "",
+                      "member",
+                    ])
+                  : agentPeers && channels.includes(id)
+                    ? participants.map((pubkey) => ["p", pubkey, "", "member"])
+                    : dmLabels && id === "dm-peer"
+                      ? [["p", participants[0], "", "member"]]
+                      : dmLabels && id === "dm-group"
+                        ? participants.map((pubkey) => [
+                            "p",
+                            pubkey,
+                            "",
+                            "member",
+                          ])
+                        : participants
+                            .slice(
+                              dmIds.indexOf(id) * 8,
+                              (dmIds.indexOf(id) + 1) * 8,
+                            )
+                            .map((pubkey) => ["p", pubkey, "", "member"])),
               ],
-              ...(ownSoloChannels.includes(id)
-                ? soloAgents.map(({ pubkey }) => ["p", pubkey, "", "member"])
-                : []),
-              ...(ownerAgent && lifecycleRows.some((row) => row.id === id)
-                ? [["p", ownerAgent, "", "owner"]]
-                : []),
-              ...(sessionMembers[id] ?? []).map((pubkey) => [
-                "p",
-                pubkey,
-                "",
-                "member",
-              ]),
-              ...(dmMembers[id]
-                ? dmMembers[id].map((index) => [
-                    "p",
-                    participants[index],
-                    "",
-                    "member",
-                  ])
-                : agentPeers && channels.includes(id)
-                  ? participants.map((pubkey) => ["p", pubkey, "", "member"])
-                  : dmLabels && id === "dm-peer"
-                    ? [["p", participants[0], "", "member"]]
-                    : dmLabels && id === "dm-group"
-                      ? participants.map((pubkey) => [
-                          "p",
-                          pubkey,
-                          "",
-                          "member",
-                        ])
-                      : participants
-                          .slice(
-                            dmIds.indexOf(id) * 8,
-                            (dmIds.indexOf(id) + 1) * 8,
-                          )
-                          .map((pubkey) => ["p", pubkey, "", "member"])),
-            ]),
+              "",
+              relayKey,
+              lifecycleTime,
+            ),
           );
       if (filter.kinds?.includes(39000))
         return [
@@ -1822,6 +1838,22 @@ export const test = base.extend({
         deliverRoster(OPEN_CHANNEL, community);
         return heldJoin.promise;
       }
+      if (channelLifecycle && event.kind === 9021) {
+        const id = event.tags.find(([key]) => key === "h")?.[1];
+        expect(lifecycleRows.some((row) => row.id === id)).toBe(true);
+        const metadata = answer(community, { kinds: [39000], "#d": [id] })[0];
+        expect(metadata.tags).toContainEqual(["public"]);
+        expect(metadata.tags).not.toContainEqual(["private"]);
+        joinedRoles.set(
+          id,
+          metadata.tags.find(([key]) => key === "join_role")?.[1] ?? "member",
+        );
+        if (!rosterIds.includes(id)) rosterIds.push(id);
+        lifecycleTime++;
+        report.lifecyclePublications ??= [];
+        report.lifecyclePublications.push(event);
+        return;
+      }
       if (
         event.kind === 9002 &&
         ownSoloChannels.includes(event.tags.find(([key]) => key === "h")?.[1])
@@ -2019,7 +2051,7 @@ export const test = base.extend({
                   expect(event.pubkey).toBe(viewer);
                   if (
                     channelLifecycle &&
-                    [9002, 9008, 9022, 41012].includes(event.kind)
+                    [9002, 9008, 9021, 9022, 41012].includes(event.kind)
                   )
                     return acceptReadPublication(community, event);
                   if (event.kind === 30078 || event.kind === 20002)
@@ -2627,6 +2659,13 @@ export const test = base.extend({
         },
         // Change only modeled relay state. The app must consume the next real
         // roster response; this does not call client purge/recovery internals.
+        addChannelGuest(id, pubkey) {
+          expect(rosterIds).toContain(id);
+          const guests = channelGuests.get(id) ?? new Set();
+          guests.add(pubkey);
+          channelGuests.set(id, guests);
+          lifecycleTime++;
+        },
         renameChannel(id, name) {
           expect(rosterIds).toContain(id);
           renamedChannels.set(id, name);
diff --git a/tests/browser/solo-public-access.spec.mjs b/tests/browser/solo-public-access.spec.mjs
index 3f3594056f..7d1fd43627 100644
--- a/tests/browser/solo-public-access.spec.mjs
+++ b/tests/browser/solo-public-access.spec.mjs
@@ -204,26 +204,7 @@ test.describe("owner", () => {
     const guest = app.serveProfile(generateSecretKey(), {
       name: "Aria viewer",
     });
-    await page.route("**/api/relay/**/query", async (route) => {
-      const filters = route.request().postDataJSON();
-      if (!filters.some((filter) => filter.kinds?.includes(39002)))
-        return route.continue();
-      const response = await route.fetch();
-      const events = await response.json();
-      await route.fulfill({
-        json: events.map((event) =>
-          event.kind === 39002 &&
-          event.tags.some(([key, value]) => key === "d" && value === own)
-            ? app.signRelay({
-                ...event,
-                // A changed signed roster must supersede the startup version.
-                created_at: event.created_at + 1,
-                tags: [...event.tags, ["p", guest.pubkey, "", "guest"]],
-              })
-            : event,
-        ),
-      });
-    });
+    app.addChannelGuest(own, guest.pubkey);
     for (const presentation of presentations) {
       const suffix = `${presentation.mode}_${presentation.width}`;
       app.setChannelMetadata(own, [
@@ -350,12 +331,15 @@ test.describe("visitor", () => {
       const message = article.locator("[data-message-id]").last();
       await expect(message).toBeVisible();
       await expect(
-        page.getByText("This chat is read-only", { exact: true }),
+        page.getByText(
+          "This chat is read-only. Join to keep it in your sidebar and appear as a viewer.",
+          { exact: true },
+        ),
       ).toBeVisible();
       await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
       await expect(
         page.getByRole("button", { name: "Join", exact: true }),
-      ).toHaveCount(0);
+      ).toBeVisible();
       await expect(
         page.locator(`[data-solo-channel-id="${shared}"]`),
       ).toHaveCount(0);
@@ -417,6 +401,12 @@ test.describe("visitor", () => {
     ]);
     await page.reload();
     await expect(article.locator("[data-message-id]").last()).toBeVisible();
+    await expect(
+      article.getByRole("region", { name: "Chat preview", exact: true }),
+    ).toBeVisible();
+    await expect(
+      article.getByRole("button", { name: "Join", exact: true }),
+    ).toHaveCount(0);
     await page
       .getByRole("button", { name: /^Share access/ })
       .last()
@@ -444,4 +434,119 @@ test.describe("visitor", () => {
     expect(app.report.lifecyclePublications ?? []).toEqual([]);
     expect(app.report.publications).toEqual([]);
   });
+
+  // Browser boundary: signed join/readback must update the real Solo inventory,
+  // both action menus and role presentation without enabling composition.
+  test("joins as a viewer, keeps Private access and leaves without write access", async ({
+    page,
+    app,
+  }, info) => {
+    const tags = [
+      ["name", "Release planning"],
+      ["t", "stream"],
+      ["t", "buzz.solo"],
+      ["P", "a".repeat(64)],
+      ["join_role", "guest"],
+    ];
+    app.setChannelMetadata(shared, [...tags, ["public"]]);
+    await openChat(page, app, shared);
+    const article = page.getByRole("article", {
+      name: "Conversation",
+      exact: true,
+    });
+    const row = page.locator(`[data-solo-channel-id="${shared}"]`);
+    await expect(row).toHaveCount(0);
+    const join = page.getByRole("button", { name: "Join", exact: true });
+    await present(page, presentations[0]);
+    await expect(article.locator("[data-message-id]").last()).toBeVisible();
+    await expect(join).toBeVisible();
+    await capture(page, info, "VIEWER_JOIN_NOTICE_dark_1440");
+    await join.focus();
+    await join.press("Enter");
+    await expect(row).toBeVisible();
+    await expect(join).toHaveCount(0);
+    await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
+    await expect(
+      page.getByText("This chat is read-only", { exact: true }),
+    ).toBeVisible();
+    expect(app.report.lifecyclePublications.map(({ kind }) => kind)).toEqual([
+      9021,
+    ]);
+    for (const presentation of presentations) {
+      await present(page, presentation);
+      await expect(article.locator("[data-message-id]").last()).toBeVisible();
+      if (presentation.width === 1440) await expect(row).toBeVisible();
+      await expect(join).toHaveCount(0);
+      await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
+      await expect(
+        page.getByText("This chat is read-only", { exact: true }),
+      ).toBeInViewport({ ratio: 1 });
+      await capture(
+        page,
+        info,
+        `VIEWER_JOINED_${presentation.mode}_${presentation.width}`,
+      );
+    }
+    await present(page, presentations[0]);
+    await page.reload();
+    await expect(row).toBeVisible();
+    await page
+      .getByRole("button", { name: /^Share access/ })
+      .last()
+      .click();
+    const access = page.getByRole("dialog", {
+      name: "Chat access",
+      exact: true,
+    });
+    await expect(
+      access.getByText("Viewing only", { exact: true }),
+    ).toBeVisible();
+    await capture(access, info, "VIEWER_JOINED_ACCESS_dark_1440");
+    await page.keyboard.press("Escape");
+    app.setChannelMetadata(shared, [...tags, ["private"]]);
+    await page.reload();
+    await expect(article.locator("[data-message-id]").last()).toBeVisible();
+    await expect(row).toBeVisible();
+    await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
+    const actions = page.getByRole("button", {
+      name: "Chat actions",
+      exact: true,
+    });
+    await actions.click();
+    await expect(
+      page.getByRole("menuitem", { name: "Archive chat", exact: true }),
+    ).toHaveCount(0);
+    await page
+      .getByRole("menuitem", { name: "Leave chat", exact: true })
+      .click();
+    const leave = page.getByRole("dialog", {
+      name: "Leave chat: Release planning",
+      exact: true,
+    });
+    await expect(
+      leave.getByRole("button", { name: "Cancel", exact: true }),
+    ).toBeFocused();
+    await page.keyboard.press("Escape");
+    await expect(actions).toBeFocused();
+    await actions.click();
+    await page
+      .getByRole("menuitem", { name: "Leave chat", exact: true })
+      .click();
+    await leave
+      .getByRole("button", { name: "Leave chat", exact: true })
+      .click();
+    await expect(row).toHaveCount(0);
+    await expect(leave).toHaveCount(0);
+    expect(app.report.lifecyclePublications.map(({ kind }) => kind)).toEqual([
+      9021, 9022,
+    ]);
+    await openChat(page, app, shared);
+    await expect(article.locator("[data-message-id]")).toHaveCount(0);
+    app.setChannelMetadata(shared, [...tags, ["public"]]);
+    await openChat(page, app, shared);
+    await expect(join).toBeVisible();
+    await expect(row).toHaveCount(0);
+    expect(app.report.publications).toEqual([]);
+    expect(app.report.unexpected).toEqual([]);
+  });
 });