diff --git a/src/bundled/mentions/MentionCompletion.tsx b/src/bundled/mentions/MentionCompletion.tsx
index 1d0b5b314e..2a0578a189 100644
--- a/src/bundled/mentions/MentionCompletion.tsx
+++ b/src/bundled/mentions/MentionCompletion.tsx
@@ -394,8 +394,12 @@ export function MentionCompletion({
             retry: () => {
               teams.retry();
               model.directory.retry();
+              // Reread the agent library only when it failed: while a reload
+              // runs, shown rows that depend on it are disabled.
               void session.agentChoices.refresh(
-                !!inviteAgents || teams.includeLegacy,
+                (model.includeLegacy &&
+                  (agents.status === "error" || !!agents.error)) ||
+                  teams.includeLegacy,
               );
               void session.archives?.refresh();
               retry((value) => value + 1);
diff --git a/src/bundled/mentions/MentionPicker.tsx b/src/bundled/mentions/MentionPicker.tsx
index c09c9bd6dd..bf41048c98 100644
--- a/src/bundled/mentions/MentionPicker.tsx
+++ b/src/bundled/mentions/MentionPicker.tsx
@@ -181,6 +181,21 @@ export function MentionPicker({
   // Underline with the same rule that ranks mentions.
   const matched = (label: string) =>
     search.trim() ? matchPerson(label, search)?.positions : undefined;
+  // Agent rows may still arrive: the agent list is loading, or the chooser
+  // waits on a read of it (inviting, or the hold of README section 6) that
+  // the combined status misses once native inventory is ready. Members and a
+  // roster have their own status text.
+  const agentsLoading = agents.status === "loading" || model.agentsPending;
+  const agentsFailed = agents.status === "error" || !!agents.error;
+  // No results is only known once nothing is pending and the agent read has
+  // not failed: Retry may still bring rows.
+  const empty =
+    !!members &&
+    !model.pending &&
+    !agentsLoading &&
+    !agentsFailed &&
+    !candidates.length &&
+    !teams.choices.length;
   return (
     <PopoverRoot
       open={open && !disabled}
@@ -333,15 +348,15 @@ export function MentionPicker({
                 </Button>
               </>
             )}
-            {agents.status === "loading" && !candidates.length && (
+            {agentsLoading && !candidates.length && (
               <p role="status">Loading agents…</p>
             )}
-            {(agents.status === "error" || !!agents.error) && (
+            {agentsFailed && (
               <Button
                 type="button"
                 onClick={() =>
                   void session.agentChoices.refresh(
-                    !!inviteAgents || teams.includeLegacy,
+                    model.includeLegacy || teams.includeLegacy,
                   )
                 }
               >
@@ -519,9 +534,7 @@ export function MentionPicker({
                   onClick={() => chooseTeam(team)}
                 />
               ))}
-              {members && !candidates.length && !teams.choices.length && (
-                <p>No matching channel members.</p>
-              )}
+              {empty && <p>No matching channel members.</p>}
               {audience?.named && (
                 <p className="text-caption text-subtle">
                   Your message tags{" "}
diff --git a/src/bundled/mentions/README.md b/src/bundled/mentions/README.md
index 8fdce63fce..12fe7e3d91 100644
--- a/src/bundled/mentions/README.md
+++ b/src/bundled/mentions/README.md
@@ -75,7 +75,11 @@ archived and not read-only, the choice set is:
 1. the channel's members;
 2. the agents that the client offers for mention in this channel;
 3. the viewer's own agents from their other communities, which the client can
-   bring into this one (section 7); and
+   bring into this one (section 7), except one whose name equals, after
+   normalization (section 3), the name of one of the viewer's unarchived agents
+   in this community: that agent already has the name here. A query that is
+   the exact public key (Terms) of such an agent still includes it, because a
+   key has no namesakes (section 5); and
 4. people and agents found by a community directory search for the current query.
 
 Solo chats MUST NOT add directory people or agents from other communities. This
@@ -222,8 +226,8 @@ has no namesakes. Nor does a saved team with the same or a longer name keep it
 from selecting. The steps below then apply as for a name.
 
 The **local** choices are the ones known without the directory search: the
-channel's members and the agents the client offers for mention (section 1, items
-1 to 3, or a Solo chat's own agent list). The client selects:
+channel's members and the agents the client offers for mention (section 1,
+items 1 to 3, or a Solo chat's own agent list). The client selects:
 
 1. the exact name among the local choices, once every member's name is known
    or known to be absent; otherwise
@@ -234,6 +238,17 @@ channel's members and the agents the client offers for mention (section 1, items
 In both cases the choice must be shown and can still be chosen. Check against
 the whole set, not only the shown rows.
 
+Both steps apply this precedence. When a local choice in this community
+(section 1, item 1 or 2) has an alias or label equal to the query, the viewer's
+agents from their other communities (item 3) cannot be the exact name.
+Otherwise, when one of those agents has one, directory results cannot. So a
+member named `Jitter` selects although the viewer's agent `Jitter` from
+another community is also a choice. When nothing local in this community is
+named `Jitter`, that agent selects at once: a directory result named `Jitter`
+cannot make it ambiguous. In step 2, a local choice in this community and a
+directory result with the same name are still namesakes. Every choice's longer
+names still continue the query.
+
 Local choices show before directory results (section 6), so a unique local name
 selects at once: directory results cannot make it ambiguous, whether or not the
 search has found them yet. A longer directory name still blocks Space once the
@@ -303,9 +318,32 @@ mention is never a recipient or a reference (section 8).
 These rules keep a row from moving under the user's pointer or keyboard.
 
 - Members and offered agents SHOULD show without waiting for the directory.
+- The viewer's agents from their other communities (section 1, item 3) SHOULD
+  show only while the viewer's agents in this community are known from a
+  complete read, so that, once those are known, the name exception in section 1
+  does not disable a shown row. A failed or partial read is not evidence: it
+  may omit the agent here that has the name. Until such a read, a query that
+  matches (section 3) a name of one of the viewer's agents from other
+  communities holds them, and directory people with them, so those agents
+  still show before directory people. Its names are the ones its row has
+  without the directory search, including aliases cached in this community,
+  such as the profile name of an agent archived here; its exact public key
+  (Terms) holds it too, even when the name exception leaves it out of name
+  queries: only that read shows whether the key is one of the viewer's agents
+  here, which then has its row here. While the read runs, the agent list is
+  still loading (section 5), and a chooser SHOULD show that it is loading, not
+  that nothing matches, even when its agent list is otherwise ready; the same
+  holds while inviting agents waits for that list. Once it fails, the full
+  choice set stays unknown for that query: only the local step of section 5
+  applies, over the local choices the client has, a chooser SHOULD NOT say
+  that nothing matches, and a retry reads again. A client SHOULD start
+  loading the viewer's agents here when a composer that offers such agents
+  opens, so that this wait is rare.
 - A shown row MUST NOT move while the query and the open chooser stay the same.
   New rows are added only at the bottom. Directory people come after the rows
-  already shown.
+  already shown. Offered agents (section 1, item 2) that load after the list
+  is shown are added too, before the viewer's agents from other communities
+  and the directory people added with them.
 - A row that becomes unavailable stays in place and is disabled. Enter and Tab
   MUST NOT select it or fall through to Send.
 - A client MAY show at most 50 rows and ask the user to type more.
@@ -398,14 +436,14 @@ each choice supplies its own label.
 | --- | --- |
 | `matching` | Section 3. `expected` is the tier of `label` for `query` (0 to 3), or `null` when it does not match. |
 | `ranking` | Sections 3 and 4. `expected` is the full ordered key list. |
-| `space` | Section 5 exact name among one complete choice set. The local-first step is tested only in the desktop UI tests. `expected` is a key or `null`. |
+| `space` | Section 5 step 2 over one complete choice set, with its precedence. Members, choices with `offered` (section 1, item 2) and choices with `elsewhere` (item 3) are local; other non-members are directory results. The local-first step is tested only in the desktop UI tests. `expected` is a key or `null`. |
 | `query` | Section 2 syntax. `expected` is `{start, end, query}` or `null`. |
 | `admission` | Section 2 multi-word rule. `expected` is a boolean. |
 | `tags.write` | Section 8 writer. `expected` is the ordered `p` and `mention` tags, or an error class: `not_member`, `invalid`, or `too_many`. The sender is a member in addition to `members`. |
 | `tags.read` | Section 8 reader. `expected` is `{mentions, references}`. |
 
 Choice defaults: `label` is `name`, `aliases` is `[name]`, and `agent`, `owned`,
-and `managed` are false. `elsewhere` (the host of another community) is absent. `history` maps a key to recency (higher is newer).
+`managed` and `offered` are false. `elsewhere` (the host of another community) is absent. `history` maps a key to recency (higher is newer).
 `presence` maps a key to `online` or `away`; a missing key is unknown.
 
 Section 6 and the prompt in section 7 are interaction rules. Test them with
diff --git a/src/bundled/mentions/mention-candidates.test.ts b/src/bundled/mentions/mention-candidates.test.ts
index c530148856..f868669900 100644
--- a/src/bundled/mentions/mention-candidates.test.ts
+++ b/src/bundled/mentions/mention-candidates.test.ts
@@ -1,5 +1,11 @@
+import { npubEncode } from "nostr-tools/nip19";
 import { expect, it } from "vitest";
-import { directoryChanges, mentionCandidates } from "./mention-candidates";
+import {
+  directoryChanges,
+  elsewhereMatches,
+  mentionCandidates,
+  offeredElsewhere,
+} from "./mention-candidates";
 import type { ComposerSession } from "../../features/messages/composer-session";
 import {
   type NamePreference,
@@ -178,3 +184,88 @@ it("shows the verified name each row is not, and matches every verified name", (
     setNamePreference("username");
   }
 });
+
+it("holds an agent from another community for every name its row has without the directory", () => {
+  const far = key(7);
+  const session = fresh();
+  // Archived here under another name, it still takes its row from the other
+  // community, with the names cached here.
+  Object.assign(session, {
+    profiles: {
+      snapshot: () =>
+        new Map<string, unknown>([
+          ...profiles,
+          [
+            far,
+            {
+              name: "Old",
+              verified: {
+                displayName: "farh",
+                username: "farh",
+                fullName: "Faraday",
+              },
+            },
+          ],
+        ]),
+    },
+    agentChoices: {
+      snapshot: () => ({
+        identities: [...agents, { pubkey: far, name: "Renamed" }],
+      }),
+    },
+    archives: {
+      snapshot: () => ({ status: "ready", archived: [key(5), far] }),
+    },
+  });
+  const row = mentionCandidates(
+    session,
+    "c",
+    false,
+    undefined,
+    undefined,
+    elsewhere,
+  ).find((c) => c.recipient.pubkey === far);
+  expect(row?.elsewhere).toBe("other.example");
+  expect([...(row?.aliases ?? [])].sort()).toEqual(
+    ["Far", "Faraday", "Old", "Renamed", "farh"].sort(),
+  );
+  for (const name of row?.aliases ?? [])
+    expect(
+      elsewhereMatches(session, "c", false, undefined, elsewhere, name),
+    ).toBe(true);
+  // Its exact key names only it, as it does for Space.
+  for (const typed of [far, npubEncode(far), `nostr:${npubEncode(far)}`])
+    expect(
+      elsewhereMatches(session, "c", false, undefined, elsewhere, typed),
+    ).toBe(true);
+  for (const typed of ["Ada", key(3), npubEncode(key(3))])
+    expect(
+      elsewhereMatches(session, "c", false, undefined, elsewhere, typed),
+    ).toBe(false);
+});
+
+it("offers an agent from another community named like one of the owner's agents here only for its exact key, after a complete read", () => {
+  const namesake = {
+    pubkey: key(8),
+    name: " helper ",
+    relay: "wss://o.example",
+  };
+  const listed = [...elsewhere, namesake];
+  let complete = true;
+  const session = fresh();
+  Object.assign(session, {
+    agentChoices: { snapshot: () => ({ identities: agents, complete }) },
+  });
+  const offered = (query?: string) =>
+    offeredElsewhere(session, listed, query)?.map((agent) => agent.pubkey);
+  // "Helper" here already has the name.
+  for (const query of [undefined, "", "helper", "Helper", key(7)])
+    expect(offered(query)).toEqual([key(7)]);
+  // A key has no namesakes: it names only its owner.
+  const npub = npubEncode(key(8));
+  for (const typed of [key(8), key(8).toUpperCase(), npub, `nostr:${npub}`])
+    expect(offered(typed)).toEqual([key(7), key(8)]);
+  // A failed or partial read may omit the agent here that has its key.
+  complete = false;
+  expect(offered(key(8))).toEqual([]);
+});
diff --git a/src/bundled/mentions/mention-candidates.ts b/src/bundled/mentions/mention-candidates.ts
index daf1b2abb3..cefbea5608 100644
--- a/src/bundled/mentions/mention-candidates.ts
+++ b/src/bundled/mentions/mention-candidates.ts
@@ -8,6 +8,8 @@ import {
 import { knownAgentPubkeys } from "../../features/agents/known";
 import type { Agent } from "../../features/agents/service";
 import { communityHost } from "../../features/messages/community-host";
+import { matchPerson, normalizeName } from "../../features/search/person-match";
+import { typedPublicKey } from "../../shared/identity/public-key";
 import {
   allowsOutsideMentions,
   archivedMention,
@@ -71,6 +73,78 @@ type DirectoryPerson = MentionRecipient & {
 };
 type ElsewhereAgent = Pick<Agent, "pubkey" | "name" | "relay">;
 const none: readonly never[] = [];
+
+/**
+ * The owner's agents from their other communities that the chooser offers for
+ * `query` (README section 1): none named like one of the owner's unarchived
+ * agents here, which already has that name, except the one whose exact public
+ * key `query` is: a key names only its owner. Teams still reach them by key.
+ * None until a complete read lists the owner's agents here (`elsewhereMatches`):
+ * a failed or partial one may omit the agent here that has the name, or the
+ * key, which then takes its row here.
+ */
+export function offeredElsewhere(
+  session: ComposerSession,
+  elsewhere: readonly ElsewhereAgent[] | undefined,
+  query = "",
+) {
+  if (!elsewhere?.length) return elsewhere;
+  const agents = session.agentChoices.snapshot();
+  if (!agents.complete) return none;
+  const here = new Set(
+    agents.identities
+      .filter((agent) => !archivedMention(session, agent.pubkey))
+      .map((agent) => normalizeName(agent.name)),
+  );
+  const key = typedPublicKey(query);
+  return elsewhere.filter(
+    (agent) => agent.pubkey === key || !here.has(normalizeName(agent.name)),
+  );
+}
+
+/**
+ * Whether the chooser would offer here one of the owner's agents from other
+ * communities that `query` matches (any, for no query). Their name rule needs
+ * the owner's agents here, so the chooser loads those and holds such agents
+ * until they are known (README section 6). Meanwhile, for a query they match,
+ * the agent list is loading: Space waits as for invited agents. After a failed
+ * read only local choices here can take Space. An agent matches by the names
+ * its row has without the directory (`buildCandidates` aliases), such as the
+ * name cached here for one archived here, or by its exact public key
+ * (`matchingMentions`), which no name matches.
+ */
+export function elsewhereMatches(
+  session: ComposerSession,
+  channelId: string,
+  inviteAgents: boolean | undefined,
+  roster: readonly MentionRecipient[] | undefined,
+  elsewhere: readonly ElsewhereAgent[] | undefined,
+  query = "",
+) {
+  if (roster || inviteAgents || !elsewhere?.length) return false;
+  const channel = session.channels
+    .list()
+    .channels.find((c) => c.id === channelId);
+  const profiles = session.profiles.snapshot();
+  const here = session.agentChoices.snapshot().identities;
+  const key = typedPublicKey(query);
+  return availableMentionAgents(
+    channel,
+    elsewhere,
+    session.outbox?.supports(9000),
+  ).some((agent) => {
+    if (key !== undefined) return agent.pubkey === key;
+    const profile = profiles.get(agent.pubkey);
+    return [
+      agent.name,
+      profile?.name,
+      profile?.verified?.fullName,
+      profile?.verified?.username,
+      ...here.flatMap((a) => (a.pubkey === agent.pubkey ? [a.name] : [])),
+    ].some((name) => name !== undefined && !!matchPerson(name, query));
+  });
+}
+
 // Rows change only with their sources, not with each keystroke. Snapshots are
 // immutable, so identity is their revision; `joinable()` copies on each call.
 // Each directory array keeps its own rows: the chooser and its team rows pass
diff --git a/src/bundled/mentions/mention-ranking.test.ts b/src/bundled/mentions/mention-ranking.test.ts
index 17822818ab..f6766586ef 100644
--- a/src/bundled/mentions/mention-ranking.test.ts
+++ b/src/bundled/mentions/mention-ranking.test.ts
@@ -9,6 +9,7 @@ import {
   type MentionChoice,
 } from "./mention-ranking";
 import { fixtureChoice, mentionConformance } from "./mention-rules.conformance";
+import { spaceMention } from "./use-mention-choices";
 import { matchPerson, nameStarts } from "../../features/search/person-match";
 const choice = (
   key: string,
@@ -246,8 +247,21 @@ it.each(mentionConformance.ranking)(
 it.each(mentionConformance.space)(
   "conforms to the portable Space contract: $name",
   (fixture) => {
+    // Step 2 of section 5 over the complete choice set: members, offered
+    // agents and agents from other communities are local; other choices are
+    // directory results.
+    const choices = fixture.choices.map(fixtureChoice);
+    const local = new Set(
+      fixture.choices
+        .filter((c) => c.member || c.offered || c.elsewhere)
+        .map((c) => c.pubkey),
+    );
     expect(
-      exactMention(fixture.choices.map(fixtureChoice), fixture.query) ?? null,
+      spaceMention(choices, local, fixture.query, {
+        pending: false,
+        missingNames: true,
+        complete: true,
+      }) ?? null,
     ).toBe(fixture.expected);
   },
 );
diff --git a/src/bundled/mentions/mention-ranking.ts b/src/bundled/mentions/mention-ranking.ts
index 39fc26e59c..75a96548fb 100644
--- a/src/bundled/mentions/mention-ranking.ts
+++ b/src/bundled/mentions/mention-ranking.ts
@@ -252,6 +252,15 @@ export const continuedMention = (
   choices: readonly MentionChoice[],
   query: string,
 ) => continuingNames(choices, query).length > 0;
+/** Whether one of the choice's known names equals the query (README section 5). */
+export function namesQuery(choice: MentionChoice, query: string) {
+  const needle = normalized(query);
+  return (
+    !!needle &&
+    choice.aliases.length > 0 &&
+    choiceNames(choice).some((name) => normalized(name) === needle)
+  );
+}
 /**
  * Space is intent only for one exact key across the full, uncapped choice set.
  * Every choice can continue the name (`continuedMention`); only choices
diff --git a/src/bundled/mentions/mention-rules.conformance.ts b/src/bundled/mentions/mention-rules.conformance.ts
index 7c82b3b62d..6f55150b30 100644
--- a/src/bundled/mentions/mention-rules.conformance.ts
+++ b/src/bundled/mentions/mention-rules.conformance.ts
@@ -9,6 +9,7 @@ export type FixtureChoice = {
   aliases?: string[];
   member: boolean;
   agent?: boolean;
+  offered?: boolean;
   elsewhere?: string;
   owned?: boolean;
   managed?: boolean;
diff --git a/src/bundled/mentions/mention-rules.fixtures.json b/src/bundled/mentions/mention-rules.fixtures.json
index 8de74ff56f..70b175fd77 100644
--- a/src/bundled/mentions/mention-rules.fixtures.json
+++ b/src/bundled/mentions/mention-rules.fixtures.json
@@ -1,5 +1,5 @@
 {
-  "$comment": "Mention rules v3: semantic inputs, no signed events. Spec: README.md. Keys are lowercase 64-hex. Choice defaults: label = name, aliases = [name], agent/owned/managed = false. history maps key to recency (higher is more recent); presence maps key to online/away (missing is unknown). matching.expected is the tier (0 to 3) or null; ranking.expected is the full ordered key list; space.expected is a key or null. Expected outputs are literal, not generated by the code under test. A query may also be an exact public key (README Terms).",
+  "$comment": "Mention rules v3: semantic inputs, no signed events. Spec: README.md. Keys are lowercase 64-hex. Choice defaults: label = name, aliases = [name], agent/owned/managed/offered = false. history maps key to recency (higher is more recent); presence maps key to online/away (missing is unknown). matching.expected is the tier (0 to 3) or null; ranking.expected is the full ordered key list; space.expected is a key or null. Expected outputs are literal, not generated by the code under test. A query may also be an exact public key (README Terms).",
   "version": 3,
   "matching": [
     {
@@ -1382,6 +1382,134 @@
         }
       ],
       "expected": null
+    },
+    {
+      "name": "agent_from_another_community_does_not_make_a_name_here_ambiguous",
+      "query": "Jitter",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Jitter",
+          "member": true
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Jitter",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        }
+      ],
+      "expected": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    },
+    {
+      "name": "agent_offered_here_outside_the_channel_outranks_its_namesake_from_another_community",
+      "query": "Goose",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Goose",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "offered": true
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Goose",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        }
+      ],
+      "expected": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    },
+    {
+      "name": "agent_from_another_community_selects_when_nothing_here_has_the_name",
+      "query": "jitter",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Member",
+          "member": true
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Jitter",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        }
+      ],
+      "expected": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    },
+    {
+      "name": "agent_from_another_community_outranks_a_directory_namesake",
+      "query": "Jitter",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Jitter",
+          "member": false
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Jitter",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        }
+      ],
+      "expected": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    },
+    {
+      "name": "member_and_directory_namesake_stay_ambiguous_beside_an_agent_from_another_community",
+      "query": "Jitter",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Jitter",
+          "member": true
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Jitter",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        },
+        {
+          "pubkey": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+          "name": "Jitter",
+          "member": false
+        }
+      ],
+      "expected": null
+    },
+    {
+      "name": "exact_public_key_selects_an_agent_from_another_community_beside_its_namesake_here",
+      "query": "npub1hwamhwamhwamhwamhwamhwamhwamhwamhwamhwamhwamhwamhwasxw04hu",
+      "choices": [
+        {
+          "pubkey": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "name": "Jitter",
+          "member": true
+        },
+        {
+          "pubkey": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "name": "Jitter",
+          "member": false,
+          "agent": true,
+          "owned": true,
+          "elsewhere": "other.example.com"
+        }
+      ],
+      "expected": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
     }
   ],
   "query": [
diff --git a/src/bundled/mentions/resolve-space-mention.ts b/src/bundled/mentions/resolve-space-mention.ts
index 7446efb8fb..5d0ec27a2b 100644
--- a/src/bundled/mentions/resolve-space-mention.ts
+++ b/src/bundled/mentions/resolve-space-mention.ts
@@ -6,7 +6,11 @@ import { allowsOutsideMentions } from "../../features/messages/mention-admission
 import type { MentionRecipient } from "../../features/messages/mention-draft";
 import type { MentionRoster } from "../../features/messages/draft-mention-roster";
 import type { Agent } from "../../features/agents/service";
-import { mentionCandidates } from "./mention-candidates";
+import {
+  elsewhereMatches,
+  mentionCandidates,
+  offeredElsewhere,
+} from "./mention-candidates";
 import { continuingNames } from "./mention-ranking";
 import { namedCandidates, spaceMention } from "./use-mention-choices";
 import { teamBlocksSpace } from "./use-team-mentions";
@@ -30,7 +34,7 @@ export type SpaceMentionScope = {
   selected: readonly MentionRecipient[];
   /** Current saved names, also read after asynchronous directory resolution. */
   teamNames?: (() => readonly string[]) | undefined;
-  /** The owner's agents in their other communities, as the chooser offers them. */
+  /** The owner's agents in their other communities (`Agents.joinable()`). */
   elsewhere?: readonly Pick<Agent, "pubkey" | "name" | "relay">[] | undefined;
 };
 
@@ -127,14 +131,25 @@ async function resolve(
         "background",
       )
       .catch(() => {});
-  if (invite) {
+  // The chooser holds the owner's agents from other communities until a
+  // complete read lists the owner's agents here, for a name one of them
+  // matches; invited agents may be partial.
+  const elsewhereNamed = elsewhereMatches(
+    session,
+    channelId,
+    inviteAgents,
+    roster,
+    elsewhere,
+    name,
+  );
+  if (invite || elsewhereNamed) {
     const release = session.agentChoices.retain();
     try {
       session.agentChoices.ensure(true);
       await settled(
         session.agentChoices.subscribe,
         session.agentChoices.snapshot,
-        (agents) => !agents.pending || agents.status === "ready",
+        (agents) => !agents.pending || (invite && agents.status === "ready"),
         signal,
       );
     } finally {
@@ -144,16 +159,6 @@ async function resolve(
   const kit = fullSession(session)?.channelKit;
   if (teamBlocksSpace(kit?.snapshot() ?? { entries: [] }, name, teamNames?.()))
     return null;
-  const local = new Set(
-    mentionCandidates(
-      session,
-      channelId,
-      inviteAgents,
-      roster,
-      undefined,
-      elsewhere,
-    ).map((c) => c.recipient.pubkey),
-  );
   const profiles = session.profiles.snapshot();
   const unnamed = session.profiles.unnamed?.();
   const missingNames = channel?.members?.some(
@@ -168,6 +173,19 @@ async function resolve(
       teamBlocksSpace(kit?.snapshot() ?? { entries: [] }, query, teamNames?.())
     )
       return null;
+    // Read when deciding, as the chooser does on each render: a library read
+    // that lands during the directory lookup offers its agents here too.
+    const offered = offeredElsewhere(session, elsewhere, query);
+    const local = new Set(
+      mentionCandidates(
+        session,
+        channelId,
+        inviteAgents,
+        roster,
+        undefined,
+        offered,
+      ).map((c) => c.recipient.pubkey),
+    );
     const choices = namedCandidates(
       session,
       channelId,
@@ -175,7 +193,7 @@ async function resolve(
       roster,
       selected,
       people,
-      elsewhere,
+      offered,
     );
     const pubkey = spaceMention(choices, local, query, {
       pending: false,
@@ -211,6 +229,9 @@ async function resolve(
   // directory, as it does in the chooser.
   const direct = decide([], false, name);
   if (direct) return direct;
+  // A failed read keeps them held, and directory people with them: the full
+  // choice set stays unknown, as in the chooser.
+  if (elsewhereNamed && !session.agentChoices.snapshot().complete) return null;
   const outside =
     !roster &&
     !invite &&
diff --git a/src/bundled/mentions/use-mention-choices.ts b/src/bundled/mentions/use-mention-choices.ts
index 742bd0e106..25f46450a6 100644
--- a/src/bundled/mentions/use-mention-choices.ts
+++ b/src/bundled/mentions/use-mention-choices.ts
@@ -22,10 +22,13 @@ import { archivedMention } from "../../features/messages/mention-admission";
 import { mentionHistory } from "../../features/messages/mention-history";
 import {
   directoryChanges,
+  elsewhereMatches,
   managedByDetail,
   mentionCandidates,
+  offeredElsewhere,
 } from "./mention-candidates";
 import { useListedChannel } from "../../features/relay/listed-channel";
+import { typedPublicKey } from "../../shared/identity/public-key";
 import { useNamesRevision } from "../../features/identity-names/react";
 import {
   useVerifiedNames,
@@ -35,6 +38,7 @@ import {
 import {
   exactMention,
   matchingMentions,
+  namesQuery,
   rankMentions,
   type MentionChoice,
 } from "./mention-ranking";
@@ -213,13 +217,16 @@ export type SpaceEvidence = {
   pending: boolean;
   /** A member's name is neither known nor known to be absent. */
   missingNames: boolean | undefined;
-  /** The directory search for this query settled with no more pages. */
+  /** The full choice set is known: the directory search for this query
+   * settled with no more pages, and no agents from other communities are held. */
   complete: boolean;
 };
 /**
  * Space (README section 5): once every member is named, an exact local name
  * selects at once. Any other exact name needs the full choice set: while the
  * directory search runs, failed, or has more pages, a namesake may be missing.
+ * For one name, a local choice here outranks the owner's agents from other
+ * communities, and they outrank directory results.
  */
 export function spaceMention(
   all: readonly MentionChoice[],
@@ -229,11 +236,20 @@ export function spaceMention(
 ) {
   if (pending) return undefined;
   const choices = matchingMentions(all, query);
+  const isLocal = (c: MentionChoice) => local.has(c.recipient.pubkey);
+  const named = choices.filter((c) => namesQuery(c, query));
+  const among: (c: MentionChoice) => boolean = named.some(
+    (c) => isLocal(c) && !c.elsewhere,
+  )
+    ? (c) => !c.elsewhere
+    : named.some((c) => c.elsewhere)
+      ? (c) => !!c.elsewhere
+      : () => true;
   return (
     (missingNames
       ? undefined
-      : exactMention(choices, query, (c) => local.has(c.recipient.pubkey))) ??
-    (complete ? exactMention(choices, query) : undefined)
+      : exactMention(choices, query, (c) => isLocal(c) && among(c))) ??
+    (complete ? exactMention(choices, query, among) : undefined)
   );
 }
 /**
@@ -252,10 +268,31 @@ export function useMentionChoices(
   const draft = useContext(DraftMentionRoster);
   const roster = draft?.recipients;
   const selected = useContext(SelectedMentionContext);
-  const agents = useAgentChoices(session, !!invite && open);
   // The owner's agents in their other communities; the snapshot is the revision.
   const community = useContext(AgentsContext);
   const revision = useAgentsSnapshot(community);
+  // Offering them needs the owner's agents here for the name rule (README
+  // section 1): load those, as inviting agents does. A closed chooser loads
+  // them too: the composer's picker mounts with it, before the first `@`.
+  const includeLegacy =
+    (open && !!invite) ||
+    elsewhereMatches(session, channelId, invite, roster, community?.joinable());
+  const agents = useAgentChoices(session, includeLegacy);
+  // Until a complete read lists those, they are held, and directory people
+  // with them, for a query one of them matches (README section 6). Only a read
+  // in progress is loading: after a failure, local choices stay usable and
+  // Retry reads again.
+  const held =
+    open &&
+    !agents.complete &&
+    elsewhereMatches(
+      session,
+      channelId,
+      invite,
+      roster,
+      community?.joinable(),
+      query,
+    );
   const profiles = useSyncExternalStore(
     session.profiles.subscribe,
     session.profiles.snapshot,
@@ -328,6 +365,9 @@ export function useMentionChoices(
       ...carried.filter((person) => !known.has(person.pubkey)),
     ];
   }, [searched, carried]);
+  // Of the owner's agents from other communities, only an exact public key
+  // changes which are offered, so other keystrokes keep the choice set.
+  const typedKey = typedPublicKey(query);
   const current = useCallback(
     () =>
       namedCandidates(
@@ -337,9 +377,9 @@ export function useMentionChoices(
         roster,
         selected,
         people,
-        community?.joinable(),
+        offeredElsewhere(session, community?.joinable(), typedKey),
       ),
-    [session, channelId, invite, roster, selected, people, community],
+    [session, channelId, invite, roster, selected, people, community, typedKey],
   );
   // Keys known without the directory search: members and agent choices.
   const localKeys = useCallback(() => {
@@ -349,14 +389,14 @@ export function useMentionChoices(
       invite,
       roster,
       undefined,
-      community?.joinable(),
+      offeredElsewhere(session, community?.joinable(), typedKey),
     );
     const cached = keySets.get(local);
     if (cached) return cached;
     const keys = new Set(local.map((c) => c.recipient.pubkey));
     keySets.set(local, keys);
     return keys;
-  }, [session, channelId, invite, roster, community]);
+  }, [session, channelId, invite, roster, community, typedKey]);
   const { candidates, local } = useMemo(() => {
     // Source revisions invalidate the projection; selection reads them again synchronously.
     void profiles;
@@ -390,10 +430,17 @@ export function useMentionChoices(
     !roster &&
     (list.status === "idle" || list.status === "loading") &&
     !channel?.members;
+  // A read of the agent list that rows wait on: invited agents until the
+  // library lands, and held agents from other communities (README section 6).
+  // The combined agent status is ready once native inventory is, so it alone
+  // misses both. Not `pending`: with native inventory ready, inviting still
+  // lets Space tag a unique local name.
+  const agentsPending = agents.pending && (!!invite || held);
   const pending =
     membersPending ||
     !!draft?.pending ||
-    (!roster && !!invite && agents.pending && agents.status !== "ready");
+    (!roster && !!invite && agents.pending && agents.status !== "ready") ||
+    (held && agents.pending);
   let rows = same ? installed.rows : undefined;
   if (!same && installed) install(undefined);
   // Only choices the query can match; ranking reads no others.
@@ -449,12 +496,19 @@ export function useMentionChoices(
       (key) => session.presence?.status(key) ?? "unknown",
       MENTION_ROWS,
     );
-  // Ranked only when read: a full set of installed rows never needs outside choices.
+  // Rows that may arrive after the list installs: the owner's agents from
+  // other communities once no longer held, then directory people, which wait
+  // with them so that local rows stay above (README section 6). Ranked only
+  // when read: a full set of installed rows never needs outside choices.
   let outsideRows: readonly MentionChoice[] | undefined;
   const outside = () =>
-    (outsideRows ??= open
-      ? rank(matches.filter((c) => !local.has(c.recipient.pubkey)))
-      : []);
+    (outsideRows ??=
+      open && !held
+        ? [
+            ...rank(matches.filter((c) => c.elsewhere)),
+            ...rank(matches.filter((c) => !local.has(c.recipient.pubkey))),
+          ]
+        : []);
   // A member a completed read found no profile for has no name to be a namesake.
   const missingNames =
     open &&
@@ -476,10 +530,23 @@ export function useMentionChoices(
     }
   }
   if (rows && rows.length < MENTION_ROWS) {
-    // Append-only: late invited agents and directory pages never move shown rows.
+    // Append-only: late invited or offered agents and `outside` rows never
+    // move shown rows. Offered agents here come first: they are local.
     // Member-list changes keep their installed set until the query changes.
     const shown = new Set(rows.map((row) => row.recipient.pubkey));
-    const added = (invite ? rank(matches.filter((c) => c.agent)) : outside())
+    const added = (
+      invite
+        ? rank(matches.filter((c) => c.agent))
+        : [
+            ...rank(
+              matches.filter(
+                (c) =>
+                  !c.member && !c.elsewhere && local.has(c.recipient.pubkey),
+              ),
+            ),
+            ...outside(),
+          ]
+    )
       .filter((c) => !shown.has(c.recipient.pubkey))
       .slice(0, MENTION_ROWS - rows.length);
     if (added.length) {
@@ -501,6 +568,7 @@ export function useMentionChoices(
     }
   }
   const complete =
+    !held &&
     !directory.loading &&
     !directory.error &&
     !directory.more &&
@@ -530,10 +598,13 @@ export function useMentionChoices(
       managedBy,
       list,
       agents,
+      /** Whether this chooser reads the legacy agent library; Retry rereads it. */
+      includeLegacy,
       channel,
       roster,
       candidates,
       pending,
+      agentsPending,
       archives,
       spaceId: spaceMention(candidates, local, query, evidence),
       canSelect: (pubkey: string, space = false) => {
@@ -564,9 +635,11 @@ export function useMentionChoices(
     managedBy,
     list,
     agents,
+    includeLegacy,
     channel,
     roster,
     pending,
+    agentsPending,
     query,
     current,
     complete,
diff --git a/src/features/messages/MessageComposer.test.tsx b/src/features/messages/MessageComposer.test.tsx
index 39dd312962..c8ac0bcd7b 100644
--- a/src/features/messages/MessageComposer.test.tsx
+++ b/src/features/messages/MessageComposer.test.tsx
@@ -57,6 +57,7 @@ import { MENTION_RESOLVE_TIMEOUT_MS } from "../conversation/completion";
 import { bundledContribution } from "../../plugins/provenance";
 import { mentionQuery } from "../../bundled/mentions/mention-query";
 import { MentionCompletion } from "../../bundled/mentions/MentionCompletion";
+import { MentionPicker } from "../../bundled/mentions/MentionPicker";
 import type { MentionRecipient } from "./mention-draft";
 import type { AgentLibrarySnapshot } from "../agents/library";
 import { createAgentChoices } from "../agents/choices";
@@ -80,6 +81,7 @@ import { setEditWithUpArrowPreference } from "./edit-key-preference";
 import { createRelaySession, type RelaySession } from "../relay/session";
 import { keypair, metadata, roster, signed } from "../relay/testing";
 import type { EventTemplate } from "nostr-tools";
+import { npubEncode } from "nostr-tools/nip19";
 import type { RelayEvent } from "../relay/events";
 import type {
   ChannelMessage,
@@ -552,9 +554,11 @@ function mount(
     setLibrary(
       identities: AgentLibrarySnapshot["identities"],
       status: AgentLibrarySnapshot["status"] = "ready",
+      error?: string,
     ) {
       act(() => {
-        library = { ...library, identities, status };
+        const { error: _, ...rest } = library;
+        library = { ...rest, identities, status, ...(error ? { error } : {}) };
         for (const listener of libraryListeners) listener();
       });
     },
@@ -14761,7 +14765,14 @@ it("leaves Space literal beside a loaded longer member name and selects that nam
  * directory and every member named, so the first Space is undecided. Each
  * `people` read is held until the test releases it. */
 function mountDirectoryMention(
-  options: { agents?: Agents; channel?: object; session?: object } = {},
+  options: {
+    agents?: Agents;
+    channel?: object;
+    session?: object;
+    /** Native agent inventory; absent, the agent list has only the library. */
+    control?: LocalAgents;
+    inviteAgents?: boolean;
+  } = {},
 ) {
   const completions: readonly Contribution<ComposerCompletion>[] = [
     {
@@ -14786,8 +14797,9 @@ function mountDirectoryMention(
           subscribe: () => () => {},
         },
       },
+      ...(options.inviteAgents ? { inviteAgents: true } : {}),
     },
-    undefined,
+    options.control,
     undefined,
     options.agents,
   );
@@ -14870,13 +14882,51 @@ function elsewhereAgent(agent: MentionRecipient) {
   } as unknown as Agents;
 }
 
-it("returns a pending mention to prose when a member shares its name with the owner's agent from another community", async () => {
-  // The chooser counts the other community's agent as a local namesake, so
-  // Space holds a chip; the resolver must decide over the same set.
+it.each([
+  ["at once when every member is named", true],
+  ["once the pending name resolves", false],
+])(
+  "tags a member who shares its name with the owner's agent from another community, %s",
+  async (_, named) => {
+    // The other community's agent never makes a name here ambiguous, in the
+    // chooser or in the resolver.
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Mira" }),
+      channel: { channelType: "stream" },
+    });
+    h.setProfiles(
+      new Map([
+        [first.pubkey, { name: "Mira" }],
+        ...(named
+          ? [[second.pubkey, { name: "Another Member" }] as const]
+          : []),
+      ]),
+    );
+    await h.user.type(h.input(), "@mira");
+    await screen.findByRole("option", { name: /In oss\.example\.com/ });
+    await h.user.keyboard(" ");
+    if (!named) {
+      // A member's name still unknown keeps the chooser from deciding Space.
+      expect(h.chip("mira")).toHaveAttribute("aria-busy", "true");
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({ people: [], hasMore: false });
+    }
+    await waitFor(() => expect(h.input()).toHaveValue("@Mira "));
+    expect(h.chip("mira")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    await act(async () => {});
+    expect(h.messages.send).toHaveBeenCalledOnce();
+    expect(h.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
+  },
+);
+
+it("does not offer the owner's agent from another community when one of their agents here has its name", async () => {
   const h = mountDirectoryMention({
     agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Mira" }),
     channel: { channelType: "stream" },
   });
+  h.setLibrary([{ pubkey: first.pubkey, name: "Mira" }]);
   h.setProfiles(
     new Map([
       [first.pubkey, { name: "Mira" }],
@@ -14884,21 +14934,853 @@ it("returns a pending mention to prose when a member shares its name with the ow
     ]),
   );
   await h.user.type(h.input(), "@mira");
+  // Rows from other communities install with the members' rows.
+  await screen.findByRole("option", { name: /Mira/ });
+  expect(
+    screen.queryByRole("option", { name: /In oss\.example\.com/ }),
+  ).toBeNull();
+  await h.user.keyboard(" ");
+  await waitFor(() => expect(h.input()).toHaveValue("@Mira "));
+  expect(h.recipients()).toHaveLength(1);
+});
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "tags the owner's agent here that is not in the channel, not its namesake from another community, %s",
+  async (_, named) => {
+    // The owner's agents here have their names whether or not they are
+    // members, so the other community's namesake is never offered.
+    const goose = { pubkey: "f".repeat(64), name: "Goose" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Goose" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([goose]);
+    // A member's name still unknown keeps the chooser from deciding Space.
+    if (!named)
+      h.setProfiles(new Map([[first.pubkey, { name: "Other Member" }]]));
+    await h.user.type(h.input(), "@goose");
+    expect(
+      await screen.findByRole("option", { name: /Goose/ }),
+    ).toHaveAccessibleName(/Not in channel/);
+    expect(screen.getAllByRole("option")).toHaveLength(1);
+    await h.user.keyboard(" ");
+    if (!named) {
+      expect(h.chip("goose")).toHaveAttribute("aria-busy", "true");
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({ people: [], hasMore: false });
+    }
+    await waitFor(() => expect(h.input()).toHaveValue("@Goose "));
+    expect(h.chip("goose")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    // Not "Bring Goose into": the agent here is the recipient.
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      "Goose is not in this channel.",
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Send anyway" }));
+    await act(async () => {});
+    expect(h.messages.send).toHaveBeenCalledOnce();
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual([goose.pubkey]);
+  },
+);
+
+it("selects the owner's agent from another community on Space at once, while the search runs", async () => {
+  const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent(rocket),
+    channel: { channelType: "stream" },
+  });
+  await h.user.type(h.input(), "@rocket");
   await screen.findByRole("option", { name: /In oss\.example\.com/ });
+  await screen.findByText("Searching community…");
+  await h.user.keyboard(" ");
+  // A directory result found later could not outrank it.
+  expect(h.input()).toHaveValue("@Rocket ");
+  expect(h.chip("rocket")).toBeNull();
+  expect(h.recipients()).toHaveLength(1);
+  h.submit();
+  expect(await screen.findByRole("dialog")).toHaveTextContent(
+    /Bring Rocket into/,
+  );
+  expect(h.messages.send).not.toHaveBeenCalled();
+});
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "selects the owner's agent from another community over a same-named directory result, %s",
+  async (_, named) => {
+    const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+    const stranger = { pubkey: "d".repeat(64), name: "Rocket" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent(rocket),
+      channel: { channelType: "stream" },
+    });
+    // A member's name still unknown keeps the chooser from deciding Space.
+    if (!named)
+      h.setProfiles(new Map([[first.pubkey, { name: "Other Member" }]]));
+    await h.user.type(h.input(), "@rocket");
+    await screen.findByRole("option", { name: /In oss\.example\.com/ });
+    if (named) {
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({ people: [stranger], hasMore: false });
+      await screen.findByRole("option", { name: /Not in channel/ });
+    }
+    await h.user.keyboard(" ");
+    if (!named) {
+      expect(h.chip("rocket")).toHaveAttribute("aria-busy", "true");
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({ people: [stranger], hasMore: false });
+    }
+    await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+    expect(h.chip("rocket")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      /Bring Rocket into/,
+    );
+    expect(h.messages.send).not.toHaveBeenCalled();
+  },
+);
+
+it.each([
+  ["never shows it when one of theirs here has its name", true],
+  ["adds it below the shown rows once theirs here are known", false],
+])(
+  "holds the owner's agent from another community while their agents here load: %s",
+  async (_, namesake) => {
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Mira" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    h.setProfiles(
+      new Map([
+        [first.pubkey, { name: "Mira" }],
+        [second.pubkey, { name: "Another Member" }],
+      ]),
+    );
+    await h.user.type(h.input(), "@mira");
+    // The member's row installs without waiting.
+    await screen.findByRole("option", { name: /Mira/ });
+    await screen.findByText("Loading recipients…");
+    expect(screen.getAllByRole("option")).toHaveLength(1);
+    h.setLibrary(namesake ? [{ pubkey: first.pubkey, name: "Mira" }] : []);
+    await screen.findByText("Searching community…");
+    if (namesake) {
+      expect(screen.getAllByRole("option")).toHaveLength(1);
+      expect(
+        screen.queryByRole("option", { name: /No longer available/ }),
+      ).toBeNull();
+    } else
+      expect(screen.getAllByRole("option").at(-1)).toHaveAccessibleName(
+        /In oss\.example\.com/,
+      );
+  },
+);
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "adds the owner's agent here that loads after a longer member name shows, above directory people, and tags it, %s",
+  async (_, loaded) => {
+    // The owner's agent here is only in the library, so it loads after the
+    // member's row installs. Its namesake from another community is never
+    // offered.
+    const jitter = { pubkey: "f".repeat(64), name: "Jitter" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Jitter" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    h.setProfiles(
+      new Map([
+        [first.pubkey, { name: "Jitterbug" }],
+        [second.pubkey, { name: "Another Member" }],
+      ]),
+    );
+    await h.user.type(h.input(), "@jitter");
+    await screen.findByRole("option", { name: /Jitterbug/ });
+    await screen.findByText("Loading recipients…");
+    if (loaded) {
+      // The search settles first; its people wait with the held rows.
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({
+        people: [{ pubkey: "d".repeat(64), name: "Jitterbird" }],
+        hasMore: false,
+      });
+      expect(screen.getAllByRole("option")).toHaveLength(1);
+    } else {
+      await h.user.keyboard(" ");
+      expect(h.chip("jitter")).toHaveAttribute("aria-busy", "true");
+    }
+    h.setLibrary([jitter]);
+    if (loaded) {
+      await waitFor(() =>
+        expect(screen.getAllByRole("option")).toHaveLength(3),
+      );
+      const [member, here, found] = screen.getAllByRole("option");
+      expect(member).toHaveAccessibleName(/Jitterbug/);
+      expect(here).toHaveAccessibleName(/^JitterAgentNot in channel/);
+      expect(found).toHaveAccessibleName(/Jitterbird/);
+      await h.user.keyboard(" ");
+    }
+    await waitFor(() => expect(h.input()).toHaveValue("@Jitter "));
+    expect(h.chip("jitter")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      "Jitter is not in this channel.",
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Send anyway" }));
+    await act(async () => {});
+    expect(h.messages.send).toHaveBeenCalledOnce();
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual([jitter.pubkey]);
+  },
+);
+
+it.each([
+  ["Space", " "],
+  ["Enter", "{Enter}"],
+])(
+  "shows the owner's agent from another community above a namesake the search found while their agents here load, and %s picks it",
+  async (_, key) => {
+    const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+    const stranger = { pubkey: "d".repeat(64), name: "Rocket" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent(rocket),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    await h.user.type(h.input(), "@rocket");
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    // The search finds the stranger before the owner's agents here load.
+    await h.release({ people: [stranger], hasMore: false });
+    h.setLibrary([]);
+    await waitFor(() => expect(screen.getAllByRole("option")).toHaveLength(2));
+    const [top, below] = screen.getAllByRole("option");
+    expect(top).toHaveAccessibleName(/In oss\.example\.com/);
+    expect(below).toHaveAccessibleName(/Not in channel/);
+    await h.user.keyboard(key);
+    await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      /Bring Rocket into/,
+    );
+    expect(h.messages.send).not.toHaveBeenCalled();
+  },
+);
+
+/**
+ * The owner's agent Rocket from another community was archived here as Comet,
+ * the name cached here. The search finds a stranger named Comet. The owner's
+ * agents here are loading; `load()` lists the archived one.
+ */
+function mountCachedAlias() {
+  const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+  const archives = { status: "ready" as const, archived: [rocket.pubkey] };
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent(rocket),
+    channel: { channelType: "stream" },
+    session: {
+      archives: {
+        snapshot: () => archives,
+        subscribe: () => () => {},
+        state: (key: string) =>
+          key === rocket.pubkey ? "archived" : "not-archived",
+        ensure: async () => {},
+      },
+    },
+  });
+  h.setLibrary([], "loading");
+  h.setProfiles(
+    new Map([
+      [first.pubkey, { name: "Other Member" }],
+      [second.pubkey, { name: "Another Member" }],
+      [rocket.pubkey, { name: "Comet" }],
+    ]),
+  );
+  return {
+    ...h,
+    stranger: { pubkey: "d".repeat(64), name: "Comet" },
+    load: () => h.setLibrary([{ pubkey: rocket.pubkey, name: "Comet" }]),
+  };
+}
+
+it.each([
+  ["Space", " "],
+  ["Enter", "{Enter}"],
+])(
+  "holds a namesake the search found for the name cached here for the owner's agent from another community, and %s picks that agent",
+  async (_, key) => {
+    const h = mountCachedAlias();
+    await h.user.type(h.input(), "@comet");
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    await h.release({ people: [h.stranger], hasMore: false });
+    // The stranger waits with the owner's agent.
+    await screen.findByText("Loading recipients…");
+    expect(screen.queryByRole("option", { name: /Comet|Rocket/ })).toBeNull();
+    h.load();
+    await waitFor(() => expect(screen.getAllByRole("option")).toHaveLength(2));
+    const [top, below] = screen.getAllByRole("option");
+    expect(top).toHaveAccessibleName(/In oss\.example\.com/);
+    expect(below).toHaveAccessibleName(/Not in channel/);
+    await h.user.keyboard(key);
+    await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      /Bring Rocket into/,
+    );
+    expect(h.messages.send).not.toHaveBeenCalled();
+  },
+);
+
+it("settles a pending mention of the name cached here for the owner's agent from another community into that agent, not a namesake the search found", async () => {
+  const h = mountCachedAlias();
+  await h.user.type(h.input(), "@comet");
+  // The chooser is open and searching.
+  await waitFor(() => expect(h.people).toHaveBeenCalled());
   await h.user.keyboard(" ");
+  expect(h.chip("comet")).toHaveAttribute("aria-busy", "true");
+  h.load();
+  // Answers the chooser's search, and the resolver's had it read the directory.
+  await h.release({ people: [h.stranger], hasMore: false });
+  await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+  expect(h.chip("comet")).toBeNull();
+  h.submit();
+  expect(await screen.findByRole("dialog")).toHaveTextContent(
+    /Bring Rocket into/,
+  );
+});
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "tags a member while the owner's agents here load when no agent from another community matches, %s",
+  async (_, named) => {
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Rocket" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    h.setProfiles(
+      new Map([
+        [first.pubkey, { name: "Alice" }],
+        ...(named
+          ? [[second.pubkey, { name: "Another Member" }] as const]
+          : []),
+      ]),
+    );
+    await h.user.type(h.input(), "@alice");
+    await screen.findByRole("option", { name: /Alice/ });
+    // Only a query such an agent matches waits for the owner's agents here.
+    await screen.findByText("Searching community…");
+    await h.user.keyboard(" ");
+    if (named) expect(h.input()).toHaveValue("@Alice ");
+    else {
+      // A member's name still unknown keeps the chooser from deciding Space.
+      expect(h.chip("alice")).toHaveAttribute("aria-busy", "true");
+      await waitFor(() => expect(h.people).toHaveBeenCalled());
+      await h.release({ people: [], hasMore: false });
+      await waitFor(() => expect(h.input()).toHaveValue("@Alice "));
+    }
+    expect(h.chip("alice")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+  },
+);
+
+it("rereads the agent library on Retry when it failed and the owner has agents in other communities", async () => {
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Rocket" }),
+    channel: { channelType: "stream" },
+  });
+  h.setLibrary([], "error", "Could not read agent inventory.");
+  await h.user.type(h.input(), "@rocket");
+  await screen.findByText("Could not load agents. Retry to refresh.");
+  expect(h.session.agentLibrary.refresh).not.toHaveBeenCalled();
+  await h.user.click(screen.getByRole("option", { name: "Retry suggestions" }));
+  expect(h.session.agentLibrary.refresh).toHaveBeenCalledOnce();
+  h.setLibrary([]);
+  await waitFor(() =>
+    expect(
+      screen.queryByText("Could not load agents. Retry to refresh."),
+    ).toBeNull(),
+  );
+  expect(
+    screen.getByRole("option", { name: /In oss\.example\.com/ }),
+  ).toHaveAttribute("aria-disabled", "false");
+});
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "never offers the owner's agent from another community while reading their agents here fails, and tags their namesake here once Retry finds it, %s",
+  async (_, named) => {
+    // The owner's agent here is only in the library, which the failed read omits.
+    const jitter = { pubkey: "f".repeat(64), name: "Jitter" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Jitter" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "error", "Could not read agent inventory.");
+    // A member's name still unknown keeps the chooser from deciding Space.
+    if (!named)
+      h.setProfiles(new Map([[first.pubkey, { name: "Other Member" }]]));
+    await h.user.type(h.input(), "@jitter");
+    await screen.findByText("Could not load agents. Retry to refresh.");
+    expect(
+      screen.queryByRole("option", { name: /In oss\.example\.com/ }),
+    ).toBeNull();
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    // A settled search leaves the chooser nothing to wait for.
+    if (named) await h.release({ people: [], hasMore: false });
+    // The resolver first reads the members' names; hold it there.
+    const names = deferred<void>();
+    onTestFinished(() => names.resolve());
+    if (!named)
+      vi.mocked(h.session.profiles.ensure).mockImplementationOnce(
+        () => names.promise,
+      );
+    await h.user.keyboard(" ");
+    if (!named) {
+      expect(h.chip("jitter")).toHaveAttribute("aria-busy", "true");
+      await act(async () => names.resolve());
+      await h.release({ people: [], hasMore: false });
+    }
+    // Neither tags the other community's agent: the text stays prose.
+    await waitFor(() => expect(h.chip("jitter")).toBeNull());
+    expect(h.input()).toHaveValue("@jitter ");
+    expect(
+      screen.queryByRole("region", { name: "Explicit mentions" }),
+    ).toBeNull();
+    await h.user.keyboard("@jitter");
+    await screen.findByText("Could not load agents. Retry to refresh.");
+    await h.user.click(
+      screen.getByRole("option", { name: "Retry suggestions" }),
+    );
+    expect(h.session.agentLibrary.refresh).toHaveBeenCalledOnce();
+    h.setLibrary([jitter]);
+    // Only the owner's agent here. Its namesake was never shown, so no row
+    // is disabled.
+    expect(
+      await screen.findByRole("option", { name: /Jitter/ }),
+    ).toHaveAccessibleName(/Not in channel/);
+    expect(screen.getAllByRole("option")).toHaveLength(1);
+    await h.user.keyboard(" ");
+    if (!named) {
+      expect(h.chip("jitter")).toHaveAttribute("aria-busy", "true");
+      await h.release({ people: [], hasMore: false });
+    }
+    await waitFor(() => expect(h.input()).toHaveValue("@jitter @Jitter "));
+    expect(h.chip("jitter")).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    // Not "Bring Jitter into": the agent here is the recipient.
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      "Jitter is not in this channel.",
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Send anyway" }));
+    await act(async () => {});
+    expect(h.messages.send).toHaveBeenCalledOnce();
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual([jitter.pubkey]);
+  },
+);
+
+it.each([
+  ["from the chooser", true],
+  ["once the pending name resolves", false],
+])(
+  "keeps a namesake the search found from taking Space while reading the owner's agents here fails, %s",
+  async (_, named) => {
+    // Had the read listed them, the owner's own Jitter, here or in another
+    // community, would outrank this one: the full choice set is unknown.
+    const stranger = { pubkey: "d".repeat(64), name: "Jitter" };
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Jitter" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "error", "Could not read agent inventory.");
+    // A member's name still unknown keeps the chooser from deciding Space.
+    if (!named)
+      h.setProfiles(new Map([[first.pubkey, { name: "Other Member" }]]));
+    await h.user.type(h.input(), "@jitter");
+    await screen.findByText("Could not load agents. Retry to refresh.");
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    if (named) {
+      await h.release({ people: [stranger], hasMore: false });
+      // It waits with the other community's agent.
+      expect(
+        screen.queryByRole("option", { name: /Not in channel/ }),
+      ).toBeNull();
+    }
+    // The resolver first reads the members' names; hold it there.
+    const names = deferred<void>();
+    onTestFinished(() => names.resolve());
+    if (!named)
+      vi.mocked(h.session.profiles.ensure).mockImplementationOnce(
+        () => names.promise,
+      );
+    await h.user.keyboard(" ");
+    if (!named) {
+      expect(h.chip("jitter")).toHaveAttribute("aria-busy", "true");
+      await act(async () => names.resolve());
+      await h.release({ people: [stranger], hasMore: false });
+    }
+    await waitFor(() => expect(h.chip("jitter")).toBeNull());
+    expect(h.input()).toHaveValue("@jitter ");
+    expect(
+      screen.queryByRole("region", { name: "Explicit mentions" }),
+    ).toBeNull();
+  },
+);
+
+it("keeps the agent library on a Retry that does not need it", async () => {
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Rocket" }),
+    channel: { channelType: "stream" },
+    session: {
+      directMessages: {
+        people: vi.fn(() => Promise.reject(new Error("offline"))),
+      },
+    },
+  });
+  await h.user.type(h.input(), "@rocket");
+  await screen.findByText(
+    "Could not search community people. Retry to refresh.",
+  );
+  await h.user.click(screen.getByRole("option", { name: "Retry suggestions" }));
+  expect(h.session.agentLibrary.refresh).not.toHaveBeenCalled();
+  expect(
+    screen.getByRole("option", { name: /In oss\.example\.com/ }),
+  ).toHaveAttribute("aria-disabled", "false");
+});
+
+/** The composer's toolbar mention picker alone, as the bundled plugin mounts it. */
+const pickerOnly: MessageComposerProps["extensions"] = (() => {
+  const empty: [] = [];
+  const none = { snapshot: () => empty, subscribe: () => () => {} };
+  const picker: readonly Contribution<ComposerTool>[] = [
+    {
+      id: "picker",
+      key: "buzz.mentions/picker",
+      pluginId: "buzz.mentions",
+      revision: "1",
+      title: "Mentions",
+      component: (props) => (
+        <MentionPicker
+          session={props.session}
+          scope={props.scope}
+          channelId={props.channelId}
+          disabled={props.disabled}
+          inviteAgents={props.inviteAgents}
+          select={props.insertMention}
+        />
+      ),
+    },
+  ];
+  return {
+    tools: { snapshot: () => picker, subscribe: () => () => {} },
+    inline: none,
+    completions: none,
+  };
+})();
+
+it.each([
+  ["starts", "stream"],
+  ["does not start", "dm"],
+])(
+  "%s reading the owner's agents here when a %s composer mounts and the owner has agents in other communities",
+  (_, channelType) => {
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: "e".repeat(64), name: "Rocket" }),
+      channel: { channelType },
+    });
+    h.setLibrary([], "idle");
+    h.retarget({ extensions: pickerOnly });
+    // The composer's picker is mounted; nobody has typed `@`.
+    expect(
+      screen.getByRole("button", { name: "Mention a member" }),
+    ).toBeInTheDocument();
+    if (channelType === "stream")
+      expect(h.session.agentLibrary.refresh).toHaveBeenCalled();
+    else expect(h.session.agentLibrary.refresh).not.toHaveBeenCalled();
+  },
+);
+
+/** Native inventory is ready, so the agent list reads `ready` while the
+ * library that lists the owner's agents here still loads. */
+function mountNativeReadyHold() {
+  const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent(rocket),
+    channel: { channelType: "stream" },
+    control: localAgentsFixture(),
+  });
+  h.setLibrary([], "loading");
+  expect(h.session.agentChoices.snapshot().status).toBe("ready");
+  return h;
+}
+
+it("shows the toolbar picker loading, not empty, while the owner's agents here load with native inventory ready", async () => {
+  const h = mountNativeReadyHold();
+  h.retarget({ extensions: pickerOnly });
+  await h.user.click(screen.getByRole("button", { name: "Mention a member" }));
+  const search = screen.getByRole("searchbox", {
+    name: "Search community people and agents",
+  });
+  await waitFor(() => expect(search).toHaveFocus());
+  await h.user.type(search, "rocket");
+  expect(screen.getByText("Loading agents…")).toBeInTheDocument();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+  // The directory finds no one; the held agent is still to come.
   await waitFor(() => expect(h.people).toHaveBeenCalled());
   await h.release({ people: [], hasMore: false });
-  await waitFor(() => expect(h.chip("mira")).toBeNull());
-  expect(h.input()).toHaveValue("@mira ");
+  expect(screen.getByText("Loading agents…")).toBeInTheDocument();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+  h.setLibrary([]);
+  // Picker rows are buttons; the inline chooser's are options.
+  await screen.findByRole("button", { name: /Rocket.*In oss\.example\.com/ });
+  expect(screen.queryByText("Loading agents…")).toBeNull();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+});
+
+it("shows the inline chooser loading while the owner's agents here load with native inventory ready", async () => {
+  const h = mountNativeReadyHold();
+  await h.user.type(h.input(), "@rocket");
+  await screen.findByText("Loading recipients…");
+  await waitFor(() => expect(h.people).toHaveBeenCalled());
+  await h.release({ people: [], hasMore: false });
+  expect(screen.getByText("Loading recipients…")).toBeInTheDocument();
+  h.setLibrary([]);
+  await screen.findByRole("option", { name: /In oss\.example\.com/ });
+  expect(screen.queryByText("Loading recipients…")).toBeNull();
+});
+
+/** Open the toolbar picker and focus its search field. */
+async function openPicker(h: ReturnType<typeof mountDirectoryMention>) {
+  h.retarget({ extensions: pickerOnly });
+  await h.user.click(
+    screen.getByRole("button", { name: /^Mention a member( or agent)?$/ }),
+  );
+  const search = screen.getByRole("searchbox");
+  await waitFor(() => expect(search).toHaveFocus());
+  return search;
+}
+
+it("shows the toolbar picker loading, not empty, while inviting agents waits for the library with native inventory ready", async () => {
+  const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+  const h = mountDirectoryMention({
+    channel: { channelType: "stream" },
+    control: localAgentsFixture(),
+    inviteAgents: true,
+  });
+  h.setLibrary([], "loading");
+  expect(h.session.agentChoices.snapshot().status).toBe("ready");
+  const search = await openPicker(h);
+  expect(search).toHaveAccessibleName("Search members and agents");
+  await h.user.type(search, "rocket");
+  expect(screen.getByText("Loading agents…")).toBeInTheDocument();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+  h.setLibrary([rocket]);
+  await screen.findByRole("button", { name: /Rocket/ });
+  expect(screen.queryByText("Loading agents…")).toBeNull();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+});
+
+it("shows the toolbar picker's Retry, not empty, after the agent read fails", async () => {
+  const h = mountDirectoryMention({ channel: { channelType: "stream" } });
+  h.setLibrary([], "error", "Could not read agent inventory.");
+  const search = await openPicker(h);
+  await h.user.type(search, "rocket");
   expect(
-    screen.queryByRole("region", { name: "Explicit mentions" }),
-  ).toBeNull();
+    screen.getByRole("button", { name: "Retry agent list" }),
+  ).toBeInTheDocument();
+  expect(screen.queryByText("Loading agents…")).toBeNull();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+  // The read lands with no Rocket: now nothing matches.
+  h.setLibrary([]);
+  await screen.findByText("No matching channel members.");
+  expect(screen.queryByRole("button", { name: "Retry agent list" })).toBeNull();
+});
+
+it("does not say the toolbar picker is loading agents while channel membership loads", async () => {
+  const h = mountDirectoryMention({ channel: { channelType: "stream" } });
+  h.retarget({
+    session: {
+      ...h.session,
+      channels: {
+        ...h.session.channels,
+        list: () => ({ status: "loading", channels: [] }),
+        ensureList: () => {},
+      },
+    } as unknown as RelaySession,
+  });
+  await openPicker(h);
+  expect(
+    screen.getByText("Channel membership unavailable."),
+  ).toBeInTheDocument();
+  expect(screen.queryByText("Loading agents…")).toBeNull();
+  expect(screen.queryByText("No matching channel members.")).toBeNull();
+});
+
+it("settles a pending mention into the owner's agent from another community once their agents here load", async () => {
+  const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent(rocket),
+    channel: { channelType: "stream" },
+  });
+  h.setLibrary([], "loading");
+  await h.user.type(h.input(), "@rocket");
+  await screen.findByText("Loading recipients…");
+  await h.user.keyboard(" ");
+  expect(h.chip("rocket")).toHaveAttribute("aria-busy", "true");
+  // The directory read stays held: the name settles without it.
+  h.setLibrary([]);
+  await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+  expect(h.chip("rocket")).toBeNull();
   h.submit();
-  await act(async () => {});
-  expect(h.messages.send).toHaveBeenCalledOnce();
-  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual([]);
+  expect(await screen.findByRole("dialog")).toHaveTextContent(
+    /Bring Rocket into/,
+  );
+});
+
+const rocketKey = "e".repeat(64);
+/** Enter `@` and the key as a user would: hex and npub typed, a `nostr:` key
+ * pasted. Typed, the colon in `nostr:` selects or holds the name `nostr`
+ * before it, as closing punctuation does (mentions README section 5). */
+async function enterKey(
+  h: ReturnType<typeof mountDirectoryMention>,
+  typed: string,
+) {
+  if (!typed.startsWith("nostr:")) {
+    await h.user.type(h.input(), `@${typed}`);
+    return;
+  }
+  await h.user.type(h.input(), "@");
+  await h.user.paste(typed);
+}
+it.each([
+  ["hex key", rocketKey],
+  ["npub", npubEncode(rocketKey)],
+  ["nostr:npub", `nostr:${npubEncode(rocketKey)}`],
+])(
+  "settles a pending mention of the %s of the owner's agent from another community into it once their agents here load, after the directory found no one",
+  async (_, typed) => {
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: rocketKey, name: "Rocket" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    await enterKey(h, typed);
+    // Its key holds the agent as its name does; the author lookup finds
+    // no profile here first.
+    await screen.findByText("Loading recipients…");
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    await h.release({ people: [], hasMore: false });
+    expect(screen.queryByRole("option")).toBeNull();
+    await h.user.keyboard(" ");
+    expect(h.chip(typed)).toHaveAttribute("aria-busy", "true");
+    h.setLibrary([]);
+    await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+    expect(h.chip(typed)).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      /Bring Rocket into/,
+    );
+    expect(h.messages.send).not.toHaveBeenCalled();
+  },
+);
+
+it("shows the owner's agent from another community for its key once their agents here load, after the directory found no one, and Space tags it", async () => {
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent({ pubkey: rocketKey, name: "Rocket" }),
+    channel: { channelType: "stream" },
+  });
+  h.setLibrary([], "loading");
+  await h.user.type(h.input(), `@${rocketKey}`);
+  await screen.findByText("Loading recipients…");
+  await waitFor(() => expect(h.people).toHaveBeenCalled());
+  await h.release({ people: [], hasMore: false });
+  expect(screen.queryByRole("option")).toBeNull();
+  h.setLibrary([]);
+  await screen.findByRole("option", { name: /In oss\.example\.com/ });
+  expect(screen.getAllByRole("option")).toHaveLength(1);
+  await h.user.keyboard(" ");
+  await waitFor(() => expect(h.input()).toHaveValue("@Rocket "));
+  expect(h.recipients()).toHaveLength(1);
+  h.submit();
+  expect(await screen.findByRole("dialog")).toHaveTextContent(
+    /Bring Rocket into/,
+  );
+  expect(h.messages.send).not.toHaveBeenCalled();
 });
 
+// One of the owner's agents here is named like their agent from another
+// community, which name queries therefore never offer.
+const jitterHere = { pubkey: "f".repeat(64), name: "Jitter" };
+
+it("shows the owner's agent from another community for its key although one of theirs here has its name, and Space tags it", async () => {
+  const h = mountDirectoryMention({
+    agents: elsewhereAgent({ pubkey: rocketKey, name: "Jitter" }),
+    channel: { channelType: "stream" },
+  });
+  h.setLibrary([jitterHere]);
+  await h.user.type(h.input(), `@${rocketKey}`);
+  // A key has no namesakes, so the name rule does not hide it.
+  await screen.findByRole("option", { name: /In oss\.example\.com/ });
+  expect(screen.getAllByRole("option")).toHaveLength(1);
+  await h.user.keyboard(" ");
+  expect(h.input()).toHaveValue("@Jitter ");
+  expect(h.chip(rocketKey)).toBeNull();
+  expect(h.recipients()).toHaveLength(1);
+  h.submit();
+  // Not "Jitter is not in this channel.": the agent here is not the recipient.
+  expect(await screen.findByRole("dialog")).toHaveTextContent(
+    /Bring Jitter into/,
+  );
+  expect(h.messages.send).not.toHaveBeenCalled();
+});
+
+it.each([
+  ["hex key", rocketKey],
+  ["npub", npubEncode(rocketKey)],
+  ["nostr:npub", `nostr:${npubEncode(rocketKey)}`],
+])(
+  "settles a pending mention of the %s of the owner's agent from another community into it once their agents here load, although one of those has its name",
+  async (_, typed) => {
+    const h = mountDirectoryMention({
+      agents: elsewhereAgent({ pubkey: rocketKey, name: "Jitter" }),
+      channel: { channelType: "stream" },
+    });
+    h.setLibrary([], "loading");
+    await enterKey(h, typed);
+    await screen.findByText("Loading recipients…");
+    await waitFor(() => expect(h.people).toHaveBeenCalled());
+    await h.release({ people: [], hasMore: false });
+    await h.user.keyboard(" ");
+    expect(h.chip(typed)).toHaveAttribute("aria-busy", "true");
+    h.setLibrary([jitterHere]);
+    await waitFor(() => expect(h.input()).toHaveValue("@Jitter "));
+    expect(h.chip(typed)).toBeNull();
+    expect(h.recipients()).toHaveLength(1);
+    h.submit();
+    expect(await screen.findByRole("dialog")).toHaveTextContent(
+      /Bring Jitter into/,
+    );
+    expect(h.messages.send).not.toHaveBeenCalled();
+  },
+);
+
 it("settles a pending mention into the owner's agent from another community that is archived here, as Tab would", async () => {
   const rocket = { pubkey: "e".repeat(64), name: "Rocket" };
   const archives = { status: "ready" as const, archived: [rocket.pubkey] };
@@ -14915,6 +15797,8 @@ it("settles a pending mention into the owner's agent from another community that
       },
     },
   });
+  // Archived here, the agent does not keep its own row from being offered.
+  h.setLibrary([rocket]);
   // A member's name still unknown keeps the chooser from deciding Space.
   h.setProfiles(new Map([[first.pubkey, { name: "Other Member" }]]));
   await h.user.type(h.input(), "@rocket");