From 7455ba4c8ece5181795ae907cc98b6ecf1c23acd Mon Sep 17 00:00:00 2001
From: morgmart <98432065+morgmart@users.noreply.github.com>
Date: Tue, 3 Nov 2026 22:53:19 -0800
Subject: [PATCH] feat(members): add several people to a chat in one write

Squashes the reviewed branch (c5454d69d..e4dab006f) for rebasing onto
main: batch additions, a per-batch roster recheck, web signing, roster
rereads after any dispatch attempt, batch settlement once everyone it
names is settled, and leaving out anyone archived during the roster read.

Rebased onto main's guest and Solo member roles: a batch groups people
by the same role a single addition sends (an explicit Guest, Bot, or
Member for Solo and private channels), web signing accepts Guest
batches, Outbox Retry keeps a guest batch Guest and keeps single
retries receipt-only, Retry never joins a batch, and a Solo chat's
resolved no-role invitation stays with the single addition, which
reports a Guest outcome.

Signed-off-by: morgmart <98432065+morgmart@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 browser-host/channel-commands.mjs             |  34 +-
 browser-host/channel-commands.test.mjs        |  31 ++
 browser-host/relay-broker-api.test.mjs        |  36 +-
 docs/solo/sharing.md                          |   9 +
 src/bundled/channels/OutboxStatus.test.tsx    |  60 +++-
 src/bundled/channels/OutboxStatus.tsx         |  51 ++-
 src/features/channel-members/members.test.ts  | 339 +++++++++++++++++-
 src/features/channel-members/members.ts       | 299 +++++++++++++--
 .../channel-members/operations.test.ts        |  56 +++
 src/features/channel-members/operations.ts    |  43 ++-
 .../messages/MessageComposer.test.tsx         |  91 +++++
 src/features/messages/useBringAgents.tsx      |  20 +-
 .../messages/useNonmemberMentions.tsx         |  14 +-
 src/features/relay/channel-writes.ts          |   2 +
 src/features/relay/session.ts                 |  32 +-
 src/features/solo/share.test.ts               |  73 +++-
 src/features/solo/share.ts                    |  22 +-
 17 files changed, 1122 insertions(+), 90 deletions(-)

diff --git a/browser-host/channel-commands.mjs b/browser-host/channel-commands.mjs
index 973f874f1e..1748cce9ca 100644
--- a/browser-host/channel-commands.mjs
+++ b/browser-host/channel-commands.mjs
@@ -22,7 +22,7 @@ export function validChannelCommand(event) {
     if (clientId.length !== 2 || !uuid.test(clientId[1])) return false;
     tags = tags.slice(0, -1);
   }
-  const [h, p] = tags;
+  const [h] = tags;
   if (h?.length !== 2 || h[0] !== "h" || !uuid.test(h[1])) return false;
   if (event.kind === 9007) {
     const expected = ["h", "name", "visibility", "channel_type"];
@@ -85,19 +85,29 @@ export function validChannelCommand(event) {
           String(Number(ttlValue)) === ttlValue))
     );
   }
-  // An invitation may name the participant role, or the read-only guest role
-  // Bestie joins private channels with. It never names a role above member.
-  if (event.kind === 9000)
+  if (event.kind === 9000) {
+    // block/buzz#8575: up to 100 distinct `p` tags. An invitation may name
+    // the participant role, or the read-only guest role Bestie joins private
+    // channels with. Several people may share the Bot role a single agent
+    // enrollment already signs; one agent keeps that exact enrollment shape.
+    // Never an elevation.
+    const role = tags.at(-1)?.[0] === "role" ? tags.at(-1) : undefined;
+    const people = tags.slice(1, role ? -1 : undefined);
     return (
       event.content === "" &&
-      (tags.length === 2 ||
-        (tags.length === 3 &&
-          tags[2].length === 2 &&
-          tags[2][0] === "role" &&
-          (tags[2][1] === "member" || tags[2][1] === "guest"))) &&
-      p?.length === 2 &&
-      p[0] === "p" &&
-      /^[0-9a-f]{64}$/.test(p[1])
+      people.length >= 1 &&
+      people.length <= 100 &&
+      people.every(
+        (tag) =>
+          tag.length === 2 && tag[0] === "p" && /^[0-9a-f]{64}$/.test(tag[1]),
+      ) &&
+      new Set(people.map(([, key]) => key)).size === people.length &&
+      (!role ||
+        (role.length === 2 &&
+          (role[1] === "member" ||
+            role[1] === "guest" ||
+            (role[1] === "bot" && people.length > 1))))
     );
+  }
   return false;
 }
diff --git a/browser-host/channel-commands.test.mjs b/browser-host/channel-commands.test.mjs
index f9f6993a0d..806cd2daa8 100644
--- a/browser-host/channel-commands.test.mjs
+++ b/browser-host/channel-commands.test.mjs
@@ -131,6 +131,37 @@ it("accepts one trailing outbox identifier for invitations and rejects ambiguous
     expect(validChannelCommand(invite(tags))).toBe(false);
 });
 
+it("signs a batch invitation of up to 100 distinct people without elevating roles", () => {
+  const invite = (tags) => ({ kind: 9000, created_at: 1, content: "", tags });
+  const h = ["h", id],
+    client = ["client-id", id];
+  const people = (count) =>
+    Array.from({ length: count }, (_, index) => [
+      "p",
+      index.toString(16).padStart(64, "0"),
+    ]);
+  for (const role of [
+    [],
+    [["role", "member"]],
+    [["role", "guest"]],
+    [["role", "bot"]],
+  ])
+    expect(
+      validChannelCommand(invite([h, ...people(100), ...role, client])),
+    ).toBe(true);
+  for (const tags of [
+    [h, ...people(101)],
+    [h, ...people(2), people(1)[0]],
+    [h, ...people(2), ["role", "admin"]],
+    [h, ...people(2), ["role", "owner"]],
+    [h, ["role", "member"]],
+    [h, people(1)[0], ["role", "bot"]],
+    [h, people(2)[0], ["role", "member"], people(2)[1]],
+    [h, ["p", "a".repeat(64), "admin"], ...people(1)],
+  ])
+    expect(validChannelCommand(invite(tags))).toBe(false);
+});
+
 it("allows bounded ordinary stream creation and rejects malformed TTL", () => {
   const create = {
     kind: 9007,
diff --git a/browser-host/relay-broker-api.test.mjs b/browser-host/relay-broker-api.test.mjs
index 1d833c28c2..706dd7324a 100644
--- a/browser-host/relay-broker-api.test.mjs
+++ b/browser-host/relay-broker-api.test.mjs
@@ -1806,14 +1806,40 @@ test("member and guest additions work without channel creation, while role eleva
     expect(h.publications[2].tags).toEqual(
       expect.arrayContaining([["role", "guest"]]),
     );
-    for (const role of ["owner", "admin"]) {
-      const denied = await h.post("sign", {
+    // block/buzz#8575: one addition may name several people.
+    const people = [
+      ["p", "b".repeat(64)],
+      ["p", "c".repeat(64)],
+    ];
+    for (const role of [
+      [],
+      [["role", "member"]],
+      [["role", "guest"]],
+      [["role", "bot"]],
+    ]) {
+      const batchId = owner.outbox.send({
         kind: 9000,
         content: "",
-        created_at: 1700000000,
-        tags: [...tags, ["role", role]],
+        tags: [...tags, ...people, ...role],
       });
-      expect(denied.status).toBe(400);
+      await vi.waitFor(() =>
+        expect(
+          owner.local.snapshot().find((row) => row.event.id === batchId)
+            ?.delivery,
+        ).toBe("accepted"),
+      );
+    }
+    expect(h.publications).toHaveLength(7);
+    for (const role of ["owner", "admin"]) {
+      for (const named of [tags, [...tags, ...people]]) {
+        const denied = await h.post("sign", {
+          kind: 9000,
+          content: "",
+          created_at: 1700000000,
+          tags: [...named, ["role", role]],
+        });
+        expect(denied.status).toBe(400);
+      }
     }
   } finally {
     owner?.dispose();
diff --git a/docs/solo/sharing.md b/docs/solo/sharing.md
index da0f6725e9..f55e8d1a23 100644
--- a/docs/solo/sharing.md
+++ b/docs/solo/sharing.md
@@ -65,6 +65,15 @@ grant fails, the dialog shows the error and **Retry share**; a retry reads the
 channel again and grants only whoever is still missing. Grants already confirmed
 stay. With no channel selected, **Done** closes without writes.
 
+People added together (a share, a team, mentioned nonmembers or brought agents)
+go in one kind 9000 per role, at most 100 each, and the roster is read once after.
+A relay without batch support adds only the first person an event names, so the
+roster decides who was added; anyone else, or anyone with an earlier addition
+still pending, gets the single addition, which reports their own failure. A batch
+is never resent, and stays in Outbox until everyone it names is in the roster or
+has their own addition; its **Retry** checks each person again. See the
+relay's kind 9000 entry in block/buzz `NOSTR.md`.
+
 The sidebar's Shared mark is status only: it uses the verified current roster and
 cached non-agent evidence for an additional human. Unknown profiles remain
 unclassified; absence of the indicator is **not** a privacy promise. Clicking the
diff --git a/src/bundled/channels/OutboxStatus.test.tsx b/src/bundled/channels/OutboxStatus.test.tsx
index 04c17b89fa..e5f59f188b 100644
--- a/src/bundled/channels/OutboxStatus.test.tsx
+++ b/src/bundled/channels/OutboxStatus.test.tsx
@@ -44,11 +44,13 @@ const invitation = {
 function show(item: OutgoingEvent) {
   const retry = vi.fn();
   const add = vi.fn(async () => {});
+  const acknowledge = vi.fn(async () => {});
   const items = [item];
   const outbox = {
     snapshot: () => items,
     subscribe: () => () => {},
     retry,
+    acknowledge,
     dismiss: vi.fn(),
   } as unknown as Outbox;
   render(
@@ -59,7 +61,7 @@ function show(item: OutgoingEvent) {
     />,
   );
   fireEvent.click(screen.getByText("Outbox · 1 items"));
-  return { retry, add };
+  return { retry, add, acknowledge };
 }
 
 it("does not offer generic retry for guarded invitations from either profile or composer", () => {
@@ -177,6 +179,62 @@ it("retries a guest addition as a guest", async () => {
   );
 });
 
+it("retries a guest batch per person as guests, each as a new addition", async () => {
+  const { add } = show({
+    ...invitation,
+    event: {
+      ...invitation.event,
+      tags: [
+        ["h", "channel"],
+        ["p", "one"],
+        ["p", "two"],
+        ["role", "guest"],
+      ],
+    },
+    recovery: { key: "member-add:batch:operation", value: "1" },
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+  await waitFor(() =>
+    expect(add.mock.calls).toEqual([
+      ["channel", "one", { role: "guest" }],
+      ["channel", "two", { role: "guest" }],
+    ]),
+  );
+});
+
+it.each(["failed", "accepted"] as const)(
+  "retries a %s batch addition per person, never resending it",
+  async (delivery) => {
+    const { retry, add, acknowledge } = show({
+      ...invitation,
+      delivery,
+      event: {
+        ...invitation.event,
+        tags: [
+          ["h", "channel"],
+          ["p", "one"],
+          ["p", "two"],
+          ["role", "member"],
+        ],
+      },
+      recovery: { key: "member-add:batch:operation", value: "1" },
+    });
+    expect(screen.getByText(/Add 2 people/)).toBeVisible();
+    add.mockImplementation(async (...args: unknown[]) => {
+      if (args[1] === "two") throw new Error("Could not add two");
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+    expect(await screen.findByText(/Could not add two/)).toBeVisible();
+    expect(add.mock.calls).toEqual([
+      ["channel", "one", {}],
+      ["channel", "two", {}],
+    ]);
+    // Additions settle the batch once everyone is; Retry never clears it.
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(retry).not.toHaveBeenCalled();
+  },
+);
+
 it.each(
   (["failed", "unknown", "admitted"] as const).flatMap((failure) =>
     [false, true].map((restart) => ({ failure, restart })),
diff --git a/src/bundled/channels/OutboxStatus.tsx b/src/bundled/channels/OutboxStatus.tsx
index ce75595e4e..18cd71354a 100644
--- a/src/bundled/channels/OutboxStatus.tsx
+++ b/src/bundled/channels/OutboxStatus.tsx
@@ -6,6 +6,15 @@ import { RelayTimings } from "./RelayTimings";
 import { PRODUCT_FEEDBACK_KIND } from "../../features/relay/product-feedback";
 import type { Outbox } from "../../features/relay/outbox";
 import type { RelaySession } from "../../features/relay/session";
+import { isBatchAddition } from "../../features/channel-members/members";
+
+/** A batch names everyone its Retry re-adds. */
+function additionLabel(tags: readonly (readonly string[])[]) {
+  const people = tags.filter(([tag]) => tag === "p");
+  return people.length > 1
+    ? `Add ${people.length} people`
+    : `Add agent ${people[0]?.[1]?.slice(0, 12) ?? ""}`;
+}
 
 /** Delivery belongs to the session, including messages from other pages or a previous launch. */
 export function OutboxStatus({
@@ -39,7 +48,7 @@ export function OutboxStatus({
           <li key={item.event.id}>
             <span>
               {item.event.kind === 9000
-                ? `Add agent ${item.event.tags.find(([tag]) => tag === "p")?.[1]?.slice(0, 12) ?? ""}`
+                ? additionLabel(item.event.tags)
                 : item.event.content.slice(0, 100)}{" "}
               ·{" "}
               {
@@ -54,7 +63,10 @@ export function OutboxStatus({
             </span>{" "}
             {!isWorkflowOperation(item.event) &&
               !item.guarded &&
-              (item.delivery === "failed" || item.delivery === "unknown") && (
+              (item.delivery === "failed" ||
+                item.delivery === "unknown" ||
+                // A kept batch still names someone unsettled.
+                (isBatchAddition(item) && item.delivery !== "sending")) && (
                 <Button
                   type="button"
                   onClick={async () => {
@@ -67,23 +79,36 @@ export function OutboxStatus({
                         const channelId = item.event.tags.find(
                           ([tag]) => tag === "h",
                         )?.[1];
-                        const pubkey = item.event.tags.find(
-                          ([tag]) => tag === "p",
-                        )?.[1];
-                        if (!channelId || !pubkey)
+                        const pubkeys = item.event.tags.flatMap(
+                          ([tag, value]) =>
+                            tag === "p" && value ? [value] : [],
+                        );
+                        if (!channelId || !pubkeys.length)
                           throw new Error(
                             "Reopen Members to check this addition.",
                           );
-                        // A stale explicit role must never overwrite a newer admission.
-                        // A guest addition is retried as one, so it can finish
-                        // its own receipt and never sends a writing role.
+                        // A stale explicit role must never overwrite a newer
+                        // admission, so each person is checked again. A guest
+                        // addition is retried as one, so it never sends a
+                        // writing role. A single addition finishes only its own
+                        // receipt. A batch is never resumed, so each person it
+                        // names is added again; it clears once all are settled.
                         const guest = item.event.tags.some(
                           ([tag, value]) => tag === "role" && value === "guest",
                         );
-                        await memberAdditions.add(channelId, pubkey, {
-                          ...(guest ? { role: "guest" } : {}),
-                          retry: true,
-                        });
+                        const batch = isBatchAddition(item);
+                        const results = await Promise.allSettled(
+                          pubkeys.map((pubkey) =>
+                            memberAdditions.add(channelId, pubkey, {
+                              ...(guest ? { role: "guest" as const } : {}),
+                              ...(batch ? {} : { retry: true as const }),
+                            }),
+                          ),
+                        );
+                        const failed = results.find(
+                          (result) => result.status === "rejected",
+                        );
+                        if (failed) throw failed.reason;
                       } else outbox.retry(item.event.id);
                       setError(undefined);
                     } catch (reason) {
diff --git a/src/features/channel-members/members.test.ts b/src/features/channel-members/members.test.ts
index e97368f3a9..1be64c0b99 100644
--- a/src/features/channel-members/members.test.ts
+++ b/src/features/channel-members/members.test.ts
@@ -1,10 +1,14 @@
 import { afterEach, expect, it, vi } from "vitest";
-import { createRelaySession } from "../relay/session";
+import { createRelaySession, type RelaySession } from "../relay/session";
 import { PublishRejected, type OutgoingEvent } from "../relay/outbox";
 import { matchesEvent } from "../relay/projection";
 import { keypair, roster, signed } from "../relay/testing";
 import type { RelayEvent } from "../relay/events";
-import { addChannelMember, canAddMembers } from "./members";
+import {
+  addChannelMember,
+  addChannelMembersAtOnce,
+  canAddMembers,
+} from "./members";
 
 const cleanups: (() => void)[] = [];
 it.each([
@@ -982,6 +986,28 @@ it.each(["member", "admin"])(
     });
   },
 );
+it("leaves a recovered legacy Solo Guest to the single addition, outside any batch", async () => {
+  const t = setup("solo", "public", "guest");
+  await t.ready();
+  await savedNoRoleInvitation(t);
+  t.confirmPerson("guest");
+  await expect(t.managedAdd()).rejects.toThrow(/remove them in People/i);
+  t.restart();
+  await t.ready();
+  // This relay models only the person, so the others' batch leaves them be.
+  t.setApply(false);
+  // Requested in one turn, so the others share a batch.
+  const [guest] = await Promise.allSettled(
+    [t.person.pubkey, keypair().pubkey, keypair().pubkey].map((key) =>
+      t.session.memberAdditions.add(t.id, key),
+    ),
+  );
+  // Counting the Guest as added would hide that they can only read.
+  expect(guest).toMatchObject({ status: "rejected" });
+  expect(String((guest as PromiseRejectedResult).reason)).toMatch(
+    /remove them in People/i,
+  );
+});
 it("reports a recovered Guest and permits a fresh Member invite only after explicit removal", async () => {
   const t = setup("solo", "public", "guest");
   await t.ready();
@@ -1297,3 +1323,312 @@ it.each([false, true])(
     expect(t.records()[0]?.acknowledged).toBe(true);
   },
 );
+
+/** A private channel whose relay applies every `p` a kind:9000 names, or only
+ * the first, as a relay without batch support does. */
+function batchSetup(applyAll = true) {
+  const viewer = keypair(),
+    relay = keypair(),
+    agent = keypair();
+  const id = "33333333-3333-4333-8333-333333333333";
+  let members = [viewer.pubkey];
+  let clock = 1700000000;
+  let records: readonly OutgoingEvent[] = [];
+  const published: RelayEvent[] = [];
+  let onPublish = () => {};
+  let rosterReads = 0;
+  let failRosterRead = 0;
+  let rosterDown = false;
+  const publish = vi.fn(async (event: RelayEvent) => {
+    onPublish();
+    const named = event.tags.flatMap(([tag, value]) =>
+      tag === "p" && value ? [value] : [],
+    );
+    members = [...new Set([...members, ...named.slice(0, applyAll ? 100 : 1)])];
+    clock++;
+    published.push(event);
+  });
+  const owner = createRelaySession(
+    {
+      viewer: viewer.pubkey,
+      relayAuthor: relay.pubkey,
+      media: () => undefined,
+      readAgentLibrary: async () => ({
+        definitions: [],
+        identities: [{ pubkey: agent.pubkey, name: "Agent" }],
+      }),
+      writer: {
+        kinds: [9, 9000, 9007],
+        sign: async (template) => signed(viewer, template),
+        publish: async (event) => {
+          await publish(event);
+        },
+      },
+      query: async (filters) => {
+        if (filters.some((filter) => filter.kinds?.includes(39002)))
+          if (++rosterReads === failRosterRead || rosterDown)
+            throw new Error("Roster unavailable");
+        return [
+          signed(relay, {
+            kind: 39000,
+            content: "",
+            tags: [
+              ["d", id],
+              ["t", "stream"],
+              ["private"],
+              ["join_role", "guest"],
+              ["name", "Design"],
+            ],
+          }),
+          roster(relay, id, members, clock),
+        ].filter((event) =>
+          filters.some((filter) => matchesEvent(event, filter)),
+        );
+      },
+    },
+    {
+      outboxStorage: {
+        load: () => records,
+        save: (next) => {
+          records = structuredClone(next);
+        },
+      },
+    },
+  );
+  cleanups.push(() => owner.dispose());
+  return {
+    session: owner.session,
+    id,
+    agent,
+    published,
+    records: () => records,
+    members: () => members,
+    /** Runs as the relay receives each write, e.g. another owner's admission. */
+    onPublish(run: () => void) {
+      onPublish = run;
+    },
+    /** Fails the relay's nth roster read from now. */
+    failRosterRead(nth: number) {
+      failRosterRead = rosterReads + nth;
+    },
+    /** Fails every roster read until restored. */
+    rosterDown(down: boolean) {
+      rosterDown = down;
+    },
+    admit(key: string) {
+      members = [...members, key];
+      clock++;
+    },
+    async ready() {
+      owner.session.channels.ensureList();
+      await vi.waitFor(() =>
+        expect(owner.session.channels.list().status).toBe("ready"),
+      );
+      await owner.session.agentChoices.refresh();
+    },
+    addAll: (keys: readonly string[]) =>
+      Promise.all(
+        keys.map((key) => owner.session.memberAdditions.add(id, key)),
+      ),
+  };
+}
+const people = (count: number) =>
+  Array.from({ length: count }, () => keypair().pubkey);
+
+it("adds people requested together in one write per role and 100 people", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const humans = people(101);
+  await t.addAll([...humans, t.agent.pubkey]);
+  expect(
+    t.published.map((event) => [
+      event.tags.filter(([tag]) => tag === "p").length,
+      event.tags.find(([tag]) => tag === "role")?.[1],
+    ]),
+  ).toEqual([
+    [100, "member"],
+    [1, "member"],
+    [1, "bot"],
+  ]);
+  expect(t.members()).toEqual(
+    expect.arrayContaining([...humans, t.agent.pubkey]),
+  );
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("adds anyone a relay without batch support missed one at a time", async () => {
+  const t = batchSetup(false);
+  await t.ready();
+  const [first = "", second = "", third = ""] = people(3);
+  await t.addAll([first, second, third]);
+  expect(
+    t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    ),
+  ).toEqual([[first, second, third], [second], [third]]);
+  expect(t.members()).toEqual(expect.arrayContaining([first, second, third]));
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("leaves a pending single addition to resume, never batching its person again", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [earlier = "", fresh = "", other = ""] = people(3);
+  const id = t.session.outbox?.send(
+    {
+      kind: 9000,
+      content: "",
+      tags: [
+        ["h", t.id],
+        ["p", earlier],
+        ["role", "member"],
+      ],
+    },
+    { key: `member-add:${t.id}:${earlier}`, value: "1" },
+  );
+  await vi.waitFor(() => expect(t.published).toHaveLength(1));
+  await t.addAll([earlier, fresh, other]);
+  // The earlier write landed, so it is confirmed rather than sent again.
+  expect(t.published.map((event) => event.id)).toEqual([
+    id,
+    expect.any(String),
+  ]);
+  expect(t.published[1]?.tags.filter(([tag]) => tag === "p")).toEqual([
+    ["p", fresh],
+    ["p", other],
+  ]);
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("reads the roster again before a later write, so it never names someone admitted meanwhile", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  // Another owner admits the agent, at any role, while the people's write is held.
+  t.onPublish(() => {
+    t.onPublish(() => {});
+    t.admit(t.agent.pubkey);
+  });
+  await t.addAll([first, second, t.agent.pubkey]);
+  expect(t.published).toHaveLength(1);
+  expect(
+    t.published[0]?.tags.some(([, value]) => value === t.agent.pubkey),
+  ).toBe(false);
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("adds the rest one at a time when the roster can't be read again between writes", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  // The first read precedes the people's write; the second, before the agent's, fails.
+  t.failRosterRead(2);
+  await t.addAll([first, second, t.agent.pubkey]);
+  expect(
+    t.published.map((event) =>
+      event.tags.filter(([tag]) => tag === "p" || tag === "role"),
+    ),
+  ).toEqual([
+    [
+      ["p", first],
+      ["p", second],
+      ["role", "member"],
+    ],
+    [
+      ["p", t.agent.pubkey],
+      ["role", "bot"],
+    ],
+  ]);
+  expect(t.members()).toContain(t.agent.pubkey);
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("keeps a batch until everyone it names is in the roster or has their own addition", async () => {
+  const t = batchSetup(false);
+  await t.ready();
+  const [first = "", second = "", third = ""] = people(3);
+  // The relay adds only the first person; then no roster read succeeds, so
+  // nobody else gets a receipt of their own.
+  t.onPublish(() => {
+    t.onPublish(() => {});
+    t.rosterDown(true);
+  });
+  const failed = await Promise.allSettled([
+    t.session.memberAdditions.add(t.id, first),
+    t.session.memberAdditions.add(t.id, second),
+    t.session.memberAdditions.add(t.id, third),
+  ]);
+  expect(failed.every((result) => result.status === "rejected")).toBe(true);
+  expect(t.published).toHaveLength(1);
+  // The saved batch, which a restart restores, is everyone's only record.
+  const [batch] = t.records().filter((item) => !item.acknowledged);
+  expect(batch?.recovery?.key).toMatch(/^member-add:batch:/);
+  expect(batch?.event.id).toBe(t.published[0]?.id);
+  t.rosterDown(false);
+  await t.addAll([first, second, third]);
+  expect(t.members()).toEqual(expect.arrayContaining([first, second, third]));
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("reads the roster again after a write that couldn't be sent", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  const outbox = t.session.outbox;
+  if (!outbox) throw new Error("Outbox unavailable");
+  // Another owner admits the agent while the people's write fails to send.
+  const send = vi.fn<typeof outbox.send>(() => {
+    t.admit(t.agent.pubkey);
+    throw new Error("Outbox storage is full");
+  });
+  const session = Object.create(t.session, {
+    outbox: { value: Object.create(outbox, { send: { value: send } }) },
+  }) as RelaySession;
+  const added = await addChannelMembersAtOnce(
+    session,
+    t.id,
+    [first, second, t.agent.pubkey],
+    new Map(),
+    new AbortController().signal,
+  );
+  // The roster read before the agent's write omits it, so nothing else is sent.
+  expect(send).toHaveBeenCalledOnce();
+  expect(added.size).toBe(0);
+});
+
+it("leaves out someone archived while the roster is read", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = "", archived = ""] = people(3);
+  let hidden: readonly string[] = [];
+  const channelWrites = t.session.channelWrites;
+  const session = Object.create(t.session, {
+    archives: {
+      value: { ...t.session.archives, snapshot: () => ({ archived: hidden }) },
+    },
+    channelWrites: {
+      value: Object.create(channelWrites, {
+        refreshMembership: {
+          value: async (id: string) => {
+            const roster = await channelWrites.refreshMembership(id);
+            hidden = [archived];
+            return roster;
+          },
+        },
+      }),
+    },
+  }) as RelaySession;
+  await addChannelMembersAtOnce(
+    session,
+    t.id,
+    [first, second, archived],
+    new Map(),
+    new AbortController().signal,
+  );
+  expect(
+    t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    ),
+  ).toEqual([[first, second]]);
+});
diff --git a/src/features/channel-members/members.ts b/src/features/channel-members/members.ts
index b6a950826a..0292ffc6dd 100644
--- a/src/features/channel-members/members.ts
+++ b/src/features/channel-members/members.ts
@@ -1,7 +1,7 @@
 import { archiveHides } from "../relay/identity-archives";
 import type { RelaySession } from "../relay/session";
 import type { ChannelSummary } from "../relay/contracts";
-import type { LocalEvents } from "../relay/outbox";
+import type { LocalEvents, OutgoingEvent } from "../relay/outbox";
 import type { RelayEvent } from "../relay/events";
 
 const keyPattern = /^[0-9a-f]{64}$/;
@@ -47,6 +47,39 @@ export function canShareSoloChat(
   );
 }
 
+const channelOf = (session: RelaySession, channelId: string) =>
+  session.channels.list().channels.find((item) => item.id === channelId) ??
+  session.channels.get?.(channelId);
+
+const knownAgent = (session: RelaySession, pubkey: string) =>
+  session.agentChoices
+    .snapshot()
+    .identities.some((agent) => agent.pubkey === pubkey) ||
+  !!session.profiles.snapshot().get(pubkey)?.isAgent;
+
+/** An explicit Guest stays one; agents join as Bot. Solo sharing and
+ * private-channel invitations grant participation explicitly, independently
+ * of the admission default for public visitors. */
+function additionRole(
+  session: RelaySession,
+  channelId: string,
+  pubkey: string,
+  soloParticipant: boolean,
+  intent?: MemberAdditionIntent,
+) {
+  const current = channelOf(session, channelId);
+  return intent?.role
+    ? intent.role
+    : knownAgent(session, pubkey)
+      ? "bot"
+      : soloParticipant ||
+          (current?.visibility === "private" &&
+            (current.channelType === "stream" ||
+              current.channelType === "forum"))
+        ? "member"
+        : undefined;
+}
+
 /** Reuse the outbox's durable operation on retry, including an unknown result. */
 function waitForAddition(outbox: LocalEvents, id: string, signal: AbortSignal) {
   return new Promise<void>((resolve, reject) => {
@@ -81,6 +114,11 @@ function waitForAddition(outbox: LocalEvents, id: string, signal: AbortSignal) {
   });
 }
 
+const batchPrefix = "member-add:batch:";
+/** A batch addition is settled by the roster read after it, never resumed. */
+export const isBatchAddition = (item: OutgoingEvent) =>
+  !!item.recovery?.key.startsWith(batchPrefix);
+
 export type MemberAdditionIntent = {
   id?: string;
   confirmed?: boolean;
@@ -91,8 +129,20 @@ export type MemberAdditionIntent = {
   retry?: true;
 };
 
-/** Explicit single-person intent. Membership truth and pending writes stay session-owned. */
+/** Explicit single-person intent. Membership truth and pending writes stay
+ * session-owned. Whatever the outcome, settles the batches it may complete. */
 export async function addChannelMember(
+  ...args: Parameters<typeof addOneMember>
+) {
+  const [session, channelId] = args;
+  try {
+    await addOneMember(...args);
+  } finally {
+    await settleBatchAdditions(session, channelId);
+  }
+}
+
+async function addOneMember(
   session: RelaySession,
   channelId: string,
   pubkey: string,
@@ -106,9 +156,7 @@ export async function addChannelMember(
 ): Promise<void> {
   if (!keyPattern.test(pubkey))
     throw new Error("Choose a valid person or agent.");
-  const channel = () =>
-    session.channels.list().channels.find((item) => item.id === channelId) ??
-    session.channels.get?.(channelId);
+  const channel = () => channelOf(session, channelId);
   const checkAccess = () => {
     signal.throwIfAborted();
     if (
@@ -146,16 +194,21 @@ export async function addChannelMember(
   const saved = journal.snapshot();
   const pending = fresh
     ? undefined
-    : (saved.find(({ event, acknowledged }) =>
+    : (saved.find((item) =>
         intent.id
-          ? event.id === intent.id
-          : !acknowledged && matchesTarget(event),
+          ? item.event.id === intent.id
+          : !item.acknowledged &&
+            !isBatchAddition(item) &&
+            matchesTarget(item.event),
       ) ??
       // Keep a resolved legacy Guest outcome actionable after restart.
       (soloParticipant && channel()?.members?.includes(pubkey)
         ? saved.find(
-            ({ event, acknowledged }) =>
-              acknowledged && matchesTarget(event) && noRole(event),
+            (item) =>
+              item.acknowledged &&
+              !isBatchAddition(item) &&
+              matchesTarget(item.event) &&
+              noRole(item.event),
           )
         : undefined));
   // A saved addition finishes only with the role this one asks for.
@@ -180,10 +233,7 @@ export async function addChannelMember(
       soloParticipant &&
       !allowSoloAgents &&
       !recoveringSoloAgent &&
-      (session.agentChoices
-        .snapshot()
-        .identities.some((agent) => agent.pubkey === pubkey) ||
-        session.profiles.snapshot().get(pubkey)?.isAgent)
+      knownAgent(session, pubkey)
     )
       throw new Error(
         "Add agents by tagging them in the chat composer instead.",
@@ -262,7 +312,7 @@ export async function addChannelMember(
       if (intent.retry && recorded && !channel()?.members?.includes(pubkey))
         return;
       // A joined target still needs role reconciliation; never overwrite a Guest.
-      return addChannelMember(
+      return addOneMember(
         session,
         channelId,
         pubkey,
@@ -324,24 +374,13 @@ export async function addChannelMember(
   return confirmAddition(id);
 
   function invitation() {
-    const isAgent =
-      session.agentChoices
-        .snapshot()
-        .identities.some((agent) => agent.pubkey === pubkey) ||
-      session.profiles.snapshot().get(pubkey)?.isAgent;
-    const current = channel();
-    // Solo sharing and private-channel invitations grant participation explicitly,
-    // independently of the admission default for public visitors.
-    const role = intent.role
-      ? intent.role
-      : isAgent
-        ? "bot"
-        : soloParticipant ||
-            (current?.visibility === "private" &&
-              (current.channelType === "stream" ||
-                current.channelType === "forum"))
-          ? "member"
-          : undefined;
+    const role = additionRole(
+      session,
+      channelId,
+      pubkey,
+      soloParticipant,
+      intent,
+    );
     return {
       kind: 9000,
       content: "",
@@ -353,3 +392,197 @@ export async function addChannelMember(
     };
   }
 }
+
+/** A batch is the only durable record of the people it names until each is
+ * in the roster or has their own addition pending, so only then is it
+ * acknowledged. Batches still sending are left to their own sender. */
+export async function settleBatchAdditions(
+  session: RelaySession,
+  channelId: string,
+) {
+  const outbox = session.outbox;
+  if (!outbox) return;
+  const items = outbox
+    .snapshot()
+    .filter(
+      (item) =>
+        !item.acknowledged &&
+        item.event.kind === 9000 &&
+        item.event.tags.some(
+          ([tag, value]) => tag === "h" && value === channelId,
+        ),
+    );
+  const named = (item: OutgoingEvent) =>
+    item.event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : []));
+  const covered = new Set([
+    ...(channelOf(session, channelId)?.members ?? []),
+    ...items.filter((item) => !isBatchAddition(item)).flatMap(named),
+  ]);
+  for (const item of items)
+    if (
+      isBatchAddition(item) &&
+      item.delivery !== "sending" &&
+      named(item).every((key) => covered.has(key))
+    )
+      await outbox.acknowledge(item.event.id).catch(() => {});
+}
+
+/** Most people one kind:9000 may name; see the relay's put-user handler. */
+const batchLimit = 100;
+
+/**
+ * Adds people missing from a channel with one kind:9000 per role and at most
+ * 100 people, then reads the roster once. Returns everyone it shows, including
+ * people already there. A relay without batch support adds only the first
+ * person each event names. Best effort: only an abort or `beforeDispatch`
+ * throws. Everyone not returned is left to `addChannelMember`, which also says
+ * why they failed, as is anyone with an earlier single addition pending, so a
+ * stale role is never resent. A batch is never resumed and never blocks one;
+ * it stays in Outbox until everyone it names is settled.
+ */
+export async function addChannelMembersAtOnce(
+  session: RelaySession,
+  channelId: string,
+  people: readonly string[],
+  intents: ReadonlyMap<string, MemberAdditionIntent>,
+  signal: AbortSignal,
+  soloParticipant = false,
+  beforeDispatch?: () => void,
+  /** Receipts the single addition reads, including resolved ones. */
+  receipts?: LocalEvents,
+): Promise<ReadonlySet<string>> {
+  const confirmed = new Set<string>();
+  const outbox = session.outbox;
+  if (people.length < 2 || !outbox) return confirmed;
+  const allowed = () =>
+    soloParticipant
+      ? canShareSoloChat(session, channelOf(session, channelId))
+      : canAddMembers(session, channelOf(session, channelId));
+  const attempt = async <T>(work: () => T | Promise<T>) => {
+    try {
+      return await work();
+    } catch {
+      signal.throwIfAborted();
+      return undefined;
+    }
+  };
+  // Restored receipts count, so read them only once the outbox has loaded.
+  const loaded = await attempt(async () => {
+    await outbox.ready();
+    return true;
+  });
+  if (!loaded) return confirmed;
+  const singles = (receipts ?? outbox)
+    .snapshot()
+    .filter(
+      (item) =>
+        !isBatchAddition(item) &&
+        item.event.kind === 9000 &&
+        item.event.tags.some(
+          ([tag, value]) => tag === "h" && value === channelId,
+        ),
+    );
+  const named = (items: readonly OutgoingEvent[]) =>
+    new Set(
+      items.flatMap(({ event }) =>
+        event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+      ),
+    );
+  const pending = named(singles.filter((item) => !item.acknowledged));
+  // A Solo chat's resolved no-role invitation may have granted Guest, which
+  // only the single addition reconciles and reports.
+  const legacy = soloParticipant
+    ? named(
+        singles.filter(
+          (item) =>
+            item.acknowledged &&
+            !item.event.tags.some(([tag]) => tag === "role"),
+        ),
+      )
+    : new Set<string>();
+  // Anyone with a single addition pending, or whom one would refuse, stays
+  // with it: it alone may resume that write, and it reports why. Retry only
+  // finishes an existing receipt, so it never joins a batch.
+  const eligible = people.filter(
+    (key) =>
+      keyPattern.test(key) &&
+      !intents.get(key)?.id &&
+      !intents.get(key)?.retry &&
+      !pending.has(key) &&
+      !legacy.has(key) &&
+      !archiveHides(session.archives, key, session.viewer) &&
+      // A Solo chat's agents keep their own receipts, so a recovering share
+      // can finish its exact Bot grant.
+      !(soloParticipant && knownAgent(session, key)),
+  );
+  if (eligible.length < 2) return confirmed;
+  const before = allowed()
+    ? await attempt(() => session.channelWrites.refreshMembership(channelId))
+    : undefined;
+  signal.throwIfAborted();
+  if (!before || !allowed()) return confirmed;
+  const groups = new Map<string | undefined, string[]>();
+  for (const key of eligible)
+    if (!before.members?.includes(key)) {
+      const role = additionRole(
+        session,
+        channelId,
+        key,
+        soloParticipant,
+        intents.get(key),
+      );
+      groups.set(role, [...(groups.get(role) ?? []), key]);
+    }
+  let sent = false;
+  try {
+    let roster: ChannelSummary | undefined = before;
+    let dispatched = false;
+    // One missing person gains nothing from a batch; the single addition sends it.
+    if ([...groups.values()].flat().length > 1)
+      for (const [role, keys] of groups)
+        for (let start = 0; start < keys.length; start += batchLimit) {
+          // Each later write reads the roster again, so it never names someone
+          // admitted meanwhile, whose role an explicit one would overwrite.
+          if (dispatched)
+            roster = await attempt(() =>
+              session.channelWrites.refreshMembership(channelId),
+            );
+          if (!roster || !allowed()) break;
+          const recipients = keys.slice(start, start + batchLimit).filter(
+            (key) =>
+              !roster?.members?.includes(key) &&
+              // Archives may refresh during any read, as the single addition rechecks.
+              !archiveHides(session.archives, key, session.viewer),
+          );
+          if (!recipients.length) continue;
+          dispatched = true;
+          beforeDispatch?.();
+          const id = await attempt(() =>
+            outbox.send(
+              {
+                kind: 9000,
+                content: "",
+                tags: [
+                  ["h", channelId],
+                  ...recipients.map((key) => ["p", key]),
+                  ...(role ? [["role", role]] : []),
+                ],
+              },
+              { key: `${batchPrefix}${crypto.randomUUID()}`, value: "1" },
+            ),
+          );
+          if (!id) continue;
+          sent = true;
+          // A refusal or unknown result still leaves the roster to decide.
+          await attempt(() => waitForAddition(outbox, id, signal));
+        }
+    const after = sent
+      ? await attempt(() => session.channelWrites.refreshMembership(channelId))
+      : before;
+    for (const key of eligible)
+      if (after?.members?.includes(key)) confirmed.add(key);
+    return confirmed;
+  } finally {
+    await settleBatchAdditions(session, channelId);
+  }
+}
diff --git a/src/features/channel-members/operations.test.ts b/src/features/channel-members/operations.test.ts
index ff914e0b3f..aa0cfcf201 100644
--- a/src/features/channel-members/operations.test.ts
+++ b/src/features/channel-members/operations.test.ts
@@ -113,3 +113,59 @@ it("keeps Retry separate from a concurrent explicit Add and clears its flag afte
   await owner.add("channel", "person");
   expect(add).toHaveBeenCalledTimes(2);
 });
+
+it("batches additions to a channel requested in the same turn and adds the rest singly", async () => {
+  const add = vi.fn(async (_channel: string, _key: string) => {});
+  const addAtOnce = vi.fn(async () => new Set(["one", "two"]));
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    addAtOnce,
+  );
+  await Promise.all(
+    ["one", "two", "three"].map((key) => owner.add("channel", key)),
+  );
+  await owner.add("other", "four");
+  expect(addAtOnce).toHaveBeenCalledExactlyOnceWith(
+    "channel",
+    ["one", "two", "three"],
+    expect.any(Map),
+  );
+  // Whoever the roster didn't show, and a lone request, get a single addition.
+  expect(add.mock.calls.map(([channel, key]) => [channel, key])).toEqual([
+    ["channel", "three"],
+    ["other", "four"],
+  ]);
+  expect(owner.snapshot()).toEqual([]);
+});
+
+it("never batches a Retry, which may only finish its own receipt", async () => {
+  const add = vi.fn(async () => {});
+  const addAtOnce = vi.fn(async () => new Set(["one", "two"]));
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    addAtOnce,
+  );
+  await Promise.all(
+    ["one", "two"].map((key) => owner.add("channel", key, { retry: true })),
+  );
+  expect(addAtOnce).not.toHaveBeenCalled();
+  expect(add).toHaveBeenCalledTimes(2);
+});
+
+it("adds everyone singly when the batch fails", async () => {
+  const add = vi.fn(async () => {});
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    async () => {
+      throw new Error("Roster unavailable");
+    },
+  );
+  await Promise.all(["one", "two"].map((key) => owner.add("channel", key)));
+  expect(add).toHaveBeenCalledTimes(2);
+});
diff --git a/src/features/channel-members/operations.ts b/src/features/channel-members/operations.ts
index ec0a8295d0..bf4a09a513 100644
--- a/src/features/channel-members/operations.ts
+++ b/src/features/channel-members/operations.ts
@@ -21,11 +21,45 @@ export function createMemberAdditions(
     intent: MemberAdditionIntent,
   ) => Promise<void>,
   receipts?: LocalEvents,
+  /** Adds several people at once; returns who the roster then shows. */
+  addAtOnce?: (
+    channelId: string,
+    pubkeys: readonly string[],
+    intents: ReadonlyMap<string, MemberAdditionIntent>,
+  ) => Promise<ReadonlySet<string>>,
 ) {
   let snapshot: readonly Addition[] = [];
   const listeners = new Set<() => void>();
   const pending = new Map<string, Promise<void>>();
   const intents = new Map<string, MemberAdditionIntent>();
+  /** Additions to a channel requested in the same turn share one batch. */
+  const batches = new Map<
+    string,
+    {
+      people: Map<string, MemberAdditionIntent>;
+      shown: Promise<ReadonlySet<string>>;
+    }
+  >();
+  function batch(
+    channelId: string,
+    pubkey: string,
+    intent: MemberAdditionIntent,
+  ) {
+    let current = batches.get(channelId);
+    if (!current) {
+      const people = new Map<string, MemberAdditionIntent>();
+      const shown = Promise.resolve().then(() => {
+        batches.delete(channelId);
+        return people.size > 1 && addAtOnce
+          ? addAtOnce(channelId, [...people.keys()], people)
+          : new Set<string>();
+      });
+      current = { people, shown };
+      batches.set(channelId, current);
+    }
+    current.people.set(pubkey, intent);
+    return current.shown;
+  }
   const stopReceipts = trackMemberAdditionReceipts(receipts, () =>
     intents.values(),
   );
@@ -83,6 +117,11 @@ export function createMemberAdditions(
       if (options.retry) intent.retry = true;
       else delete intent.retry;
       let confirmed = previous?.confirmed ?? false;
+      // Retry only finishes an existing receipt, so it never joins a batch.
+      const shown =
+        confirmed || options.retry || !addAtOnce
+          ? undefined
+          : batch(channelId, pubkey, intent);
       const update = (item?: Addition) => {
         if (!signal.aborted)
           publish([
@@ -94,7 +133,9 @@ export function createMemberAdditions(
         .then(async () => {
           signal.throwIfAborted();
           if (!confirmed) {
-            await add(channelId, pubkey, intent);
+            if ((await shown?.catch(() => undefined))?.has(pubkey))
+              intent.confirmed = true;
+            else await add(channelId, pubkey, intent);
             confirmed = true;
           }
           signal.throwIfAborted();
diff --git a/src/features/messages/MessageComposer.test.tsx b/src/features/messages/MessageComposer.test.tsx
index d73478f6db..9429703bf7 100644
--- a/src/features/messages/MessageComposer.test.tsx
+++ b/src/features/messages/MessageComposer.test.tsx
@@ -8228,6 +8228,37 @@ it("Enter on a deliberately focused Invite adds a nonmember before sending", asy
   expect(h.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
 });
 
+it("invites mentioned nonmembers together so they share one addition", async () => {
+  const h = mount();
+  const held = deferred<void>();
+  const add = vi.fn(() => held.promise);
+  const list = {
+    status: "ready",
+    channels: [
+      { id: "channel", channelType: "stream", members: ["d".repeat(64)] },
+    ],
+  };
+  Object.assign(h.session, {
+    viewer: "d".repeat(64),
+    channels: { list: () => list, subscribeList: () => () => {} },
+    memberAdditions: { add },
+  });
+  act(() => {
+    h.commands().insertMention(first);
+    h.commands().insertMention(second);
+  });
+  fireEvent.submit(screen.getByRole("form"));
+  fireEvent.click(await screen.findByRole("button", { name: "Invite" }));
+  // Both are requested before either finishes.
+  await waitFor(() => expect(add).toHaveBeenCalledTimes(2));
+  expect(add.mock.calls).toEqual([
+    ["channel", first.pubkey],
+    ["channel", second.pubkey],
+  ]);
+  held.resolve();
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+});
+
 it.each([
   ["", false],
   [", taking it out of its archive here after a Remove", true],
@@ -8313,6 +8344,66 @@ it.each([
   },
 );
 
+it("brings several agents in, then adds them together", async () => {
+  const calls: string[] = [];
+  const join = vi.fn(async (key: string) => {
+    calls.push(`join ${key}`);
+    return { agent: {} as never, notes: [] };
+  });
+  const snapshot = { agents: [] };
+  const types: never[] = [];
+  const agents = {
+    snapshot: () => snapshot,
+    subscribe: () => () => {},
+    find: () => undefined,
+    types: () => types,
+    joinable: () =>
+      [first, second].map((person, index) => ({
+        key: person.pubkey,
+        pubkey: person.pubkey,
+        name: ["Honey", "Pollen"][index],
+        relay: "wss://oss.example.com",
+      })),
+    join,
+  } as unknown as Agents;
+  const h = mount({}, undefined, undefined, agents);
+  const held = deferred<void>();
+  const add = vi.fn((_channel: string, key: string) => {
+    calls.push(`add ${key}`);
+    return held.promise;
+  });
+  const list = {
+    status: "ready",
+    channels: [
+      { id: "channel", channelType: "stream", members: ["d".repeat(64)] },
+    ],
+  };
+  Object.assign(h.session, {
+    viewer: "d".repeat(64),
+    scope: `https://relay.example.test:${"d".repeat(64)}`,
+    channels: { list: () => list, subscribeList: () => () => {} },
+    memberAdditions: { add },
+  });
+  act(() => {
+    h.commands().insertMention(first);
+    h.commands().insertMention(second);
+  });
+  fireEvent.submit(screen.getByRole("form"));
+  fireEvent.click(
+    await screen.findByRole("button", { name: "Bring them here" }),
+  );
+  // Both are requested before either finishes, after every join.
+  await waitFor(() => expect(add).toHaveBeenCalledTimes(2));
+  expect(calls).toEqual([
+    `join ${first.pubkey}`,
+    `join ${second.pubkey}`,
+    `add ${first.pubkey}`,
+    `add ${second.pubkey}`,
+  ]);
+  held.resolve();
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+});
+
 it.each(["close", "escape", "enter"])(
   "%s preserves the captured draft and returns focus without adding or sending",
   async (action) => {
diff --git a/src/features/messages/useBringAgents.tsx b/src/features/messages/useBringAgents.tsx
index 80218982bb..758ce64947 100644
--- a/src/features/messages/useBringAgents.tsx
+++ b/src/features/messages/useBringAgents.tsx
@@ -68,13 +68,23 @@ export function useBringAgents(
             notes.push(...(await agents.join(agent.key)).notes);
           joined.add(agent.pubkey);
         }
-        if (canAdd && !added.has(agent.pubkey)) {
-          check();
-          await session.memberAdditions.add(channelId, agent.pubkey);
-          added.add(agent.pubkey);
-        }
       }
       check();
+      // Requested together, so they go to the relay together.
+      const results = await Promise.allSettled(
+        canAdd
+          ? request.agents
+              .filter((agent) => !added.has(agent.pubkey))
+              .map((agent) =>
+                session.memberAdditions
+                  .add(channelId, agent.pubkey)
+                  .then(() => added.add(agent.pubkey)),
+              )
+          : [],
+      );
+      const failed = results.find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
+      check();
       if (notes.length) setPending({ ...request, busy: false, reviewed: true });
       else request.finish([...added]);
     } catch (reason) {
diff --git a/src/features/messages/useNonmemberMentions.tsx b/src/features/messages/useNonmemberMentions.tsx
index 22b1f66ac3..9e0846cc0a 100644
--- a/src/features/messages/useNonmemberMentions.tsx
+++ b/src/features/messages/useNonmemberMentions.tsx
@@ -37,10 +37,16 @@ export function useNonmemberMentions(
     };
     setPending({ ...request, busy: true });
     try {
-      for (const person of request.people) {
-        check();
-        await session.memberAdditions.add(channelId, person.pubkey);
-      }
+      check();
+      // Requested together, so they go to the relay together.
+      const failed = (
+        await Promise.allSettled(
+          request.people.map((person) =>
+            session.memberAdditions.add(channelId, person.pubkey),
+          ),
+        )
+      ).find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
       check();
       request.finish([]);
     } catch (reason) {
diff --git a/src/features/relay/channel-writes.ts b/src/features/relay/channel-writes.ts
index 2223d2de67..9207199fcd 100644
--- a/src/features/relay/channel-writes.ts
+++ b/src/features/relay/channel-writes.ts
@@ -3,6 +3,7 @@ import { exactLifecycleTag } from "./channel-lifecycle-protocol";
 import { channelIdentityUnsupported, channelLabelTags } from "./channel-labels";
 import { SOLO_NAMED_LABEL, SOLO_LABEL } from "../solo/labels";
 import type { Outbox } from "./outbox";
+import { isBatchAddition } from "../channel-members/members";
 import { withdraw } from "./withdraw";
 import type { ChannelQueries, ChannelSummary } from "./contracts";
 import type { RelayReader } from "./reader";
@@ -494,6 +495,7 @@ export function createChannelWrites(
         return (
           item.event.kind === 9000 &&
           !item.acknowledged &&
+          !isBatchAddition(item) &&
           !["accepted", "seen"].includes(item.delivery) &&
           item.event.tags.some(
             ([name, value]) => name === "h" && value === id,
diff --git a/src/features/relay/session.ts b/src/features/relay/session.ts
index 8ef96810b2..ebd8b782e2 100644
--- a/src/features/relay/session.ts
+++ b/src/features/relay/session.ts
@@ -3,7 +3,10 @@ import type { LocalAgentSource } from "../agents/local-activity";
 import { createSoloPreferences, soloGroups } from "./solo-preferences";
 import { npubEncode } from "nostr-tools/nip19";
 import { createMemberAdditions } from "../channel-members/operations";
-import { addChannelMember } from "../channel-members/members";
+import {
+  addChannelMember,
+  addChannelMembersAtOnce,
+} from "../channel-members/members";
 import type { LocalAgents } from "../agents/local";
 import type { GitRead } from "../repos/git";
 import { repoDestinations } from "../repos/destinations";
@@ -2072,17 +2075,15 @@ export function createRelaySession(
       }
     },
   });
+  // A Solo chat admits people under its share rule; agents join by mention.
+  const solo = (channelId: string) =>
+    (
+      session.channels.list().channels.find((item) => item.id === channelId) ??
+      session.channels.get?.(channelId)
+    )?.channelType === "solo";
   const memberAdditions = createMemberAdditions(
     lifetime.signal,
     async (channelId, pubkey, intent): Promise<void> => {
-      // A Solo chat admits people under its share rule; agents join by mention.
-      const solo =
-        (
-          session.channels
-            .list()
-            .channels.find((item) => item.id === channelId) ??
-          session.channels.get?.(channelId)
-        )?.channelType === "solo";
       await addChannelMember(
         session,
         channelId,
@@ -2090,10 +2091,21 @@ export function createRelaySession(
         lifetime.signal,
         intent,
         writes?.local,
-        solo,
+        solo(channelId),
       );
     },
     writes?.local,
+    (channelId, pubkeys, intents) =>
+      addChannelMembersAtOnce(
+        session,
+        channelId,
+        pubkeys,
+        intents,
+        lifetime.signal,
+        solo(channelId),
+        undefined,
+        writes?.local,
+      ),
   );
   const recoverable = (
     subscribe: (listener: () => void) => () => void,
diff --git a/src/features/solo/share.test.ts b/src/features/solo/share.test.ts
index 6f0557f1af..f4494363b0 100644
--- a/src/features/solo/share.test.ts
+++ b/src/features/solo/share.test.ts
@@ -33,6 +33,7 @@ function setup() {
   let failLink = false;
   let chosenName: string | undefined;
   let rejectGrant = false;
+  let batches = false;
   let records: readonly import("../relay/outbox").OutgoingEvent[] = [];
   const publish = vi.fn(async (event: RelayEvent) => {
     if (event.kind === 9000 && rejectGrant)
@@ -40,10 +41,14 @@ function setup() {
     if (event.kind === 9 && failLink) throw new PublishRejected("Post denied");
     if (event.kind === 9000) {
       const id = event.tags.find(([tag]) => tag === "h")?.[1] ?? "";
+      // A relay without batch support adds only the first person named.
+      const named = event.tags.flatMap(([tag, value]) =>
+        tag === "p" ? [value ?? ""] : [],
+      );
       members.set(id, [
         ...new Set([
           ...(members.get(id) ?? []),
-          event.tags.find(([tag]) => tag === "p")?.[1] ?? "",
+          ...named.slice(0, batches ? named.length : 1),
         ]),
       ]);
     }
@@ -156,6 +161,9 @@ function setup() {
       query.mockImplementationOnce(async () => [archive]);
       await owner.session.archives.refresh();
     },
+    supportBatches: () => {
+      batches = true;
+    },
     rejectGrant: (value: boolean) => {
       rejectGrant = value;
     },
@@ -306,6 +314,69 @@ it("shares with a channel by granting only members missing from the chat, and po
   expect(t.published[0]?.tags).toContainEqual(["p", t.human.pubkey]);
 });
 
+it.each([true, false])(
+  "shares with several channel members in one grant (batch relay: %s)",
+  async (batchRelay) => {
+    const t = setup();
+    await t.ready();
+    if (batchRelay) t.supportBatches();
+    t.addDestination(t.human.pubkey);
+    t.addDestination(t.late.pubkey);
+    await shareChatsWithChannel(t.session, [chatId], channelId, {
+      signal: new AbortController().signal,
+    });
+    expect(t.members.get(chatId)).toEqual(
+      expect.arrayContaining([t.human.pubkey, t.late.pubkey]),
+    );
+    const named = t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    );
+    const [first, second] = named[0] ?? [];
+    expect(named).toEqual(
+      batchRelay
+        ? [[first, second]]
+        : // Whoever the batch missed gets a single grant.
+          [[first, second], [second]],
+    );
+    expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+  },
+);
+
+it("keeps each agent's grant to a Solo chat on its own receipt", async () => {
+  const t = setup();
+  await t.ready();
+  await t.setAgent();
+  t.supportBatches();
+  await grantSoloChatAccess(
+    t.session,
+    chatId,
+    [t.human.pubkey, t.bot.pubkey, t.late.pubkey],
+    new Map(),
+    new AbortController().signal,
+    () => {},
+    true,
+  );
+  expect(t.members.get(chatId)).toEqual(
+    expect.arrayContaining([t.human.pubkey, t.bot.pubkey, t.late.pubkey]),
+  );
+  // A recovering share can then finish the agent's exact Bot grant.
+  expect(
+    t.published.map((event) =>
+      event.tags.filter(([tag]) => tag === "p" || tag === "role"),
+    ),
+  ).toEqual([
+    [
+      ["p", t.human.pubkey],
+      ["p", t.late.pubkey],
+      ["role", "member"],
+    ],
+    [
+      ["p", t.bot.pubkey],
+      ["role", "bot"],
+    ],
+  ]);
+});
+
 it("retries a failed channel share without repeating confirmed grants", async () => {
   const t = setup();
   await t.ready();
diff --git a/src/features/solo/share.ts b/src/features/solo/share.ts
index 61834fcdfb..ddef8d797b 100644
--- a/src/features/solo/share.ts
+++ b/src/features/solo/share.ts
@@ -4,6 +4,7 @@ import {
 } from "../relay/channel-details-protocol";
 import {
   addChannelMember,
+  addChannelMembersAtOnce,
   canAddMembers,
   canShareSoloChat,
 } from "../channel-members/members";
@@ -37,7 +38,8 @@ export const soloChatLink = (id: string) =>
 export const soloChatLinkMessage = (id: string, name = id.slice(0, 8)) =>
   `[Chat: ${name.replace(/\s+/g, " ").replace(/[\\`[\]*_~<>&|]/g, "\\$&")}](${soloChatLink(id)})`;
 
-/** Exact selected people are grants to the chat, not the destination or its parent. */
+/** Exact selected people are grants to the chat, not the destination or its parent.
+ * Everyone goes in one batch first; anyone it didn't add gets a single addition. */
 export async function grantSoloChatAccess(
   session: RelaySession,
   channelId: string,
@@ -52,13 +54,27 @@ export async function grantSoloChatAccess(
 ) {
   if (people.length > 100 || new Set(people).size !== people.length)
     throw new Error("Choose at most 100 distinct recipients.");
+  const added = await addChannelMembersAtOnce(
+    session,
+    channelId,
+    people,
+    intents,
+    signal,
+    soloParticipant,
+    beforeDispatch,
+  );
   for (const key of people) {
     signal.throwIfAborted();
+    const intent = intents.get(key) ?? {};
+    intents.set(key, intent);
+    if (added.has(key)) {
+      intent.confirmed = true;
+      onConfirmed(key);
+      continue;
+    }
     // Channel audiences omit archived identities; direct selections still fail explicitly.
     if (skipArchived && archiveHides(session.archives, key, session.viewer))
       continue;
-    const intent = intents.get(key) ?? {};
-    intents.set(key, intent);
     await addChannelMember(
       session,
       channelId,