From 696a36aefc5b8fee46f805b6daed9d72d12e7ced Mon Sep 17 00:00:00 2001
From: webdevtodayjason <jason@webdevtoday.com>
Date: Fri, 24 Jul 2026 06:24:39 -0500
Subject: [PATCH 1/5] feat(desktop): show each agent's role in the @-mention
 selector

Surface the kind-0 about field as a one-line role/description under
agent rows in the mention autocomplete (#2699). Carried through the
Tauri profile summary path, resolved via the existing users-batch
delta cache for agents missing from the caller's profile lookup, and
rendered as a truncated single line that degrades to today's plain
"agent" label when about is empty.

Ports upstream/block#2706 onto the fork. Fork deviations from the
upstream diff, all mechanical conflict resolution, no behavior change:
- useMentions.ts hunks land in buildMentionCandidates.ts, where the
  fork already extracted candidate building out of useMentions.ts.
- The nostr_convert about-carrying test lands in nostr_convert/tests.rs,
  where the fork already moved `mod tests` into its own file.
- Every ported mapMentionCandidateToSuggestion call gains
  agentProvenanceReady: true, a fork-only required opt predating this
  port; the six ported assertions are otherwise unchanged.
- MentionAutocomplete.tsx keeps the fork's literal "agent" fallback
  (upstream carries an agentLabel var) and keeps showAgentProvenanceMarker
  inside the agent span -- both fork baseline shape, not upstream's.
- mentionSuggestionMapping.test.mjs is appended to, not created; the
  file already exists on zs/main.

Signed-off-by: webdevtodayjason <jason@webdevtoday.com>
Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
---
 desktop/playwright.config.ts                  |   1 +
 desktop/src-tauri/src/models.rs               |   8 +
 desktop/src-tauri/src/nostr_convert.rs        |   1 +
 desktop/src-tauri/src/nostr_convert/tests.rs  |  22 +++
 .../src/nostr_convert/user_search.rs          |  13 ++
 .../messages/lib/buildMentionCandidates.ts    |   4 +
 .../messages/lib/mentionCandidates.ts         |   4 +
 .../lib/mentionSuggestionMapping.test.mjs     |  85 ++++++++-
 .../messages/lib/mentionSuggestionMapping.ts  |  14 ++
 .../src/features/messages/lib/useMentions.ts  |  41 +++-
 .../messages/ui/MentionAutocomplete.tsx       |  18 +-
 desktop/src/features/profile/lib/identity.ts  |   2 +
 desktop/src/shared/api/tauriProfiles.ts       |   4 +-
 desktop/src/shared/api/types.ts               |   7 +
 desktop/src/testing/e2eBridge.ts              |   6 +
 .../mention-descriptions-screenshots.spec.ts  | 176 ++++++++++++++++++
 16 files changed, 397 insertions(+), 9 deletions(-)
 create mode 100644 desktop/tests/e2e/mention-descriptions-screenshots.spec.ts

diff --git a/desktop/playwright.config.ts b/desktop/playwright.config.ts
index 4a27ee671a6..0eed100b312 100644
--- a/desktop/playwright.config.ts
+++ b/desktop/playwright.config.ts
@@ -79,6 +79,7 @@ export default defineConfig({
         "**/mentions.spec.ts",
         "**/mention-spacing.spec.ts",
         "**/mention-clipboard.spec.ts",
+        "**/mention-descriptions-screenshots.spec.ts",
         "**/cloud-provenance.spec.ts",
         "**/team-mentions.spec.ts",
         "**/persistent-agent-audience.spec.ts",
diff --git a/desktop/src-tauri/src/models.rs b/desktop/src-tauri/src/models.rs
index 9693f1563ac..90e0b70e49b 100644
--- a/desktop/src-tauri/src/models.rs
+++ b/desktop/src-tauri/src/models.rs
@@ -50,6 +50,10 @@ pub struct UserProfileSummaryInfo {
     #[serde(default)]
     pub name: Option<String>,
     pub avatar_url: Option<String>,
+    /// Kind-0 `about` field — one-line role/description surfaced in the
+    /// @-mention selector for agents.
+    #[serde(default)]
+    pub about: Option<String>,
     pub nip05_handle: Option<String>,
     pub owner_pubkey: Option<String>,
     #[serde(default)]
@@ -67,6 +71,10 @@ pub struct UserSearchResultInfo {
     pub pubkey: String,
     pub display_name: Option<String>,
     pub avatar_url: Option<String>,
+    /// Kind-0 `about` field — one-line role/description surfaced in the
+    /// @-mention selector for agents.
+    #[serde(default)]
+    pub about: Option<String>,
     pub nip05_handle: Option<String>,
     pub owner_pubkey: Option<String>,
     #[serde(default)]
diff --git a/desktop/src-tauri/src/nostr_convert.rs b/desktop/src-tauri/src/nostr_convert.rs
index 51f648769d3..b7515422b6b 100644
--- a/desktop/src-tauri/src/nostr_convert.rs
+++ b/desktop/src-tauri/src/nostr_convert.rs
@@ -358,6 +358,7 @@ pub fn users_batch_from_events(
                 .map(str::to_string),
             name: v.get("name").and_then(Value::as_str).map(str::to_string),
             avatar_url: v.get("picture").and_then(Value::as_str).map(str::to_string),
+            about: v.get("about").and_then(Value::as_str).map(str::to_string),
             nip05_handle: v.get("nip05").and_then(Value::as_str).map(str::to_string),
             is_agent: owner_pubkey.is_some(),
             owner_pubkey,
diff --git a/desktop/src-tauri/src/nostr_convert/tests.rs b/desktop/src-tauri/src/nostr_convert/tests.rs
index 68d8cb7dcbb..9baee493774 100644
--- a/desktop/src-tauri/src/nostr_convert/tests.rs
+++ b/desktop/src-tauri/src/nostr_convert/tests.rs
@@ -278,6 +278,28 @@ fn users_batch_marks_valid_nip_oa_profiles_as_agents() {
     );
 }
 
+#[test]
+fn users_batch_carries_about_when_present() {
+    let with_about = ev(
+        0,
+        r#"{"display_name":"Bumble","about":"Researcher — deep dives & sourcing"}"#,
+        vec![],
+    );
+    let without_about = ev(0, r#"{"display_name":"Fizz"}"#, vec![]);
+    let pk_with = with_about.pubkey.to_hex();
+    let pk_without = without_about.pubkey.to_hex();
+
+    let resp = users_batch_from_events(
+        &[with_about, without_about],
+        &[pk_with.clone(), pk_without.clone()],
+    );
+    assert_eq!(
+        resp.profiles[&pk_with].about.as_deref(),
+        Some("Researcher — deep dives & sourcing")
+    );
+    assert_eq!(resp.profiles[&pk_without].about, None);
+}
+
 #[test]
 fn user_notes_builds_cursor_from_last() {
     let e1 = ev(1, "first", vec![]);
diff --git a/desktop/src-tauri/src/nostr_convert/user_search.rs b/desktop/src-tauri/src/nostr_convert/user_search.rs
index 43b4288abbb..334e9e22b0d 100644
--- a/desktop/src-tauri/src/nostr_convert/user_search.rs
+++ b/desktop/src-tauri/src/nostr_convert/user_search.rs
@@ -19,6 +19,7 @@ pub fn user_search_result_from_event(ev: &Event) -> UserSearchResultInfo {
             .or_else(|| v.get("name").and_then(Value::as_str))
             .map(str::to_string),
         avatar_url: v.get("picture").and_then(Value::as_str).map(str::to_string),
+        about: v.get("about").and_then(Value::as_str).map(str::to_string),
         nip05_handle: v.get("nip05").and_then(Value::as_str).map(str::to_string),
         is_agent: owner_pubkey.is_some(),
         owner_pubkey,
@@ -238,6 +239,18 @@ mod tests {
         assert_eq!(r.users[1].display_name.as_deref(), Some("B"));
     }
 
+    #[test]
+    fn user_search_result_carries_about_when_present() {
+        let with_about = ev(0, r#"{"name":"honey","about":"Writer bee"}"#, vec![]);
+        let without_about = ev(0, r#"{"name":"fizz"}"#, vec![]);
+
+        assert_eq!(
+            user_search_result_from_event(&with_about).about.as_deref(),
+            Some("Writer bee")
+        );
+        assert_eq!(user_search_result_from_event(&without_about).about, None);
+    }
+
     #[test]
     fn user_search_result_marks_valid_nip_oa_profile_as_agent() {
         let event = oa_profile_event(r#"{"display_name":"Mira"}"#);
diff --git a/desktop/src/features/messages/lib/buildMentionCandidates.ts b/desktop/src/features/messages/lib/buildMentionCandidates.ts
index 61373886352..f8467647728 100644
--- a/desktop/src/features/messages/lib/buildMentionCandidates.ts
+++ b/desktop/src/features/messages/lib/buildMentionCandidates.ts
@@ -117,6 +117,9 @@ export function buildMentionCandidates({
       role: current.role ?? candidate.role ?? null,
       secondaryLabel:
         current.secondaryLabel ?? candidate.secondaryLabel ?? null,
+      // `??` (not `?? null`) so both-undefined stays undefined — that is
+      // the "still unknown, resolve from the profile lookup" signal.
+      description: current.description ?? candidate.description,
       ownerPubkey:
         current.ownerPubkey ??
         candidate.ownerPubkey ??
@@ -219,6 +222,7 @@ export function buildMentionCandidates({
           relayAgentNamesByPubkey.has(pubkey),
         personaName: personaNameByPubkey.get(pubkey) ?? null,
         secondaryLabel: formatSearchUserSecondaryLabel(user),
+        description: user.about ?? null,
         ownerPubkey: user.ownerPubkey ?? null,
         isGlobalSearchResult: true,
         isManagedAgent: managedAgentNamesByPubkey.has(pubkey),
diff --git a/desktop/src/features/messages/lib/mentionCandidates.ts b/desktop/src/features/messages/lib/mentionCandidates.ts
index 659832deadf..f8259731968 100644
--- a/desktop/src/features/messages/lib/mentionCandidates.ts
+++ b/desktop/src/features/messages/lib/mentionCandidates.ts
@@ -44,6 +44,10 @@ export type MentionCandidate = {
   role?: ChannelRole | null;
   personaName?: string | null;
   secondaryLabel?: string | null;
+  /** Kind-0 `about` when already resolved at candidate-build time (e.g. from
+   * a user-search result). `undefined` means "unknown — resolve from the
+   * profile lookup at suggestion-mapping time"; `null` means "known absent". */
+  description?: string | null;
   ownerPubkey?: string | null;
   isAgent: boolean;
   isActiveAgent?: boolean;
diff --git a/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs b/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
index 599b59a8117..1b6d408cf1b 100644
--- a/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
+++ b/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
@@ -4,11 +4,12 @@ import test from "node:test";
 import { mapMentionCandidateToSuggestion } from "./mentionSuggestionMapping.ts";
 
 const OWNER = "a".repeat(64);
+const AGENT_PUBKEY = "b".repeat(64);
 
 function candidate(overrides = {}) {
   return {
     kind: "identity",
-    pubkey: "b".repeat(64),
+    pubkey: AGENT_PUBKEY,
     isAgent: true,
     isMember: true,
     ownerPubkey: OWNER,
@@ -16,6 +17,10 @@ function candidate(overrides = {}) {
   };
 }
 
+function agentCandidate(overrides = {}) {
+  return candidate(overrides);
+}
+
 function suggestion(overrides = {}, agentProvenanceReady = true) {
   return mapMentionCandidateToSuggestion({
     agentProvenanceReady,
@@ -25,6 +30,18 @@ function suggestion(overrides = {}, agentProvenanceReady = true) {
   });
 }
 
+function profileSummary(about) {
+  return {
+    displayName: "Bumble",
+    name: null,
+    avatarUrl: null,
+    about,
+    nip05Handle: null,
+    ownerPubkey: null,
+    isAgent: true,
+  };
+}
+
 test("labels Desktop-managed agent identities as managed here", () => {
   assert.equal(
     suggestion({ isManagedAgent: true }).agentProvenance,
@@ -58,3 +75,69 @@ test("does not attribute people or personas to a device", () => {
     undefined,
   );
 });
+
+test("agent description comes from the candidate when resolved at build time", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ description: "Researcher — deep dives" }),
+    label: "Bumble",
+    profiles: { [AGENT_PUBKEY]: profileSummary("stale profile about") },
+  });
+
+  assert.equal(result.description, "Researcher — deep dives");
+});
+
+test("agent description falls back to the profile lookup's about", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate(),
+    label: "Bumble",
+    profiles: { [AGENT_PUBKEY]: profileSummary("Researcher — deep dives") },
+  });
+
+  assert.equal(result.description, "Researcher — deep dives");
+});
+
+test("agent description is null when about is missing everywhere", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate(),
+    label: "Bumble",
+    profiles: { [AGENT_PUBKEY]: profileSummary(null) },
+  });
+
+  assert.equal(result.description, null);
+});
+
+test("non-agent suggestions never carry a description", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ isAgent: false }),
+    label: "Alice",
+    profiles: { [AGENT_PUBKEY]: profileSummary("A human bio") },
+  });
+
+  assert.equal(result.description, null);
+});
+
+test("multi-line about collapses to a single trimmed line", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({
+      description: "  Writer bee.\nDrafts docs\n\tand posts.  ",
+    }),
+    label: "Honey",
+  });
+
+  assert.equal(result.description, "Writer bee. Drafts docs and posts.");
+});
+
+test("whitespace-only about degrades to null (name-only row)", () => {
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ description: "   \n  " }),
+    label: "Fizz",
+  });
+
+  assert.equal(result.description, null);
+});
diff --git a/desktop/src/features/messages/lib/mentionSuggestionMapping.ts b/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
index b0983cee52d..18a98abf3db 100644
--- a/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
+++ b/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
@@ -19,6 +19,7 @@ export type MentionSuggestionCandidate = {
   isManagedAgent?: boolean;
   isMember: boolean;
   role?: ChannelRole | null;
+  description?: string | null;
   ownerPubkey?: string | null;
 };
 
@@ -44,6 +45,18 @@ export function mapMentionCandidateToSuggestion(opts: {
     ? formatOwnerLabel(candidate.ownerPubkey, currentPubkey, ownerProfiles)
     : null;
 
+  // Agent role line: prefer an `about` resolved at candidate-build time
+  // (search results), else fall back to the profile lookup like avatarUrl.
+  // Collapsed to a single line — the selector is a quick picker, not a
+  // profile card.
+  const rawDescription = candidate.isAgent
+    ? (candidate.description ??
+      (candidate.pubkey
+        ? profiles?.[normalizePubkey(candidate.pubkey)]?.about
+        : null))
+    : null;
+  const description = rawDescription?.replace(/\s+/g, " ").trim() || null;
+
   return {
     pubkey: candidate.pubkey,
     personaId: candidate.personaId ?? undefined,
@@ -77,6 +90,7 @@ export function mapMentionCandidateToSuggestion(opts: {
       candidate.isMember === false,
     ownerLabel,
     role: !candidate.isAgent && candidate.role === "admin" ? "admin" : null,
+    description,
   };
 }
 
diff --git a/desktop/src/features/messages/lib/useMentions.ts b/desktop/src/features/messages/lib/useMentions.ts
index 38e6ed2212f..085f8843bdc 100644
--- a/desktop/src/features/messages/lib/useMentions.ts
+++ b/desktop/src/features/messages/lib/useMentions.ts
@@ -320,6 +320,39 @@ export function useMentions(
   const ownerProfilesQuery = useUsersBatchQuery(ownerPubkeys, {
     enabled: ownerPubkeys.length > 0,
   });
+  // Agent candidates whose kind-0 `about` is not already known — neither
+  // resolved at candidate-build time (search results) nor present in the
+  // caller's profile lookup. Batch-resolve them so the selector can show a
+  // role line even for agents who haven't authored anything in the loaded
+  // timeline. The per-pubkey entry cache behind useUsersBatchQuery keeps
+  // repeat lookups off the network.
+  const agentProfilePubkeys = React.useMemo(
+    () => [
+      ...new Set(
+        mentionCandidates
+          .filter(
+            (candidate) =>
+              candidate.isAgent &&
+              candidate.pubkey &&
+              candidate.description === undefined &&
+              !profiles?.[candidate.pubkey],
+          )
+          .map((candidate) => candidate.pubkey as string),
+      ),
+    ],
+    [mentionCandidates, profiles],
+  );
+  const agentProfilesQuery = useUsersBatchQuery(agentProfilePubkeys, {
+    enabled: agentProfilePubkeys.length > 0,
+  });
+  const mentionProfiles = React.useMemo<UserProfileLookup | undefined>(() => {
+    const agentProfiles = agentProfilesQuery.data?.profiles;
+    if (!agentProfiles || Object.keys(agentProfiles).length === 0) {
+      return profiles;
+    }
+    // Caller-provided profiles win on conflict.
+    return { ...agentProfiles, ...profiles };
+  }, [agentProfilesQuery.data?.profiles, profiles]);
   const searchableNames = React.useMemo(
     () => uniqueAutocompleteLabels(mentionCandidatesWithTeams),
     [mentionCandidatesWithTeams],
@@ -386,7 +419,7 @@ export function useMentions(
           channelType: options?.channelType,
           currentPubkey,
           ownerProfiles: ownerProfilesQuery.data?.profiles,
-          profiles,
+          profiles: mentionProfiles,
         }),
       );
   }, [
@@ -394,10 +427,10 @@ export function useMentions(
     agentDirectoriesReady,
     currentPubkey,
     mentionCandidatesWithTeams,
+    mentionProfiles,
     mentionQuery,
     options?.channelType,
     ownerProfilesQuery.data?.profiles,
-    profiles,
   ]);
   const getDefaultAgentSuggestion = useDefaultAgentSuggestion({
     activePersonaIds,
@@ -846,7 +879,7 @@ export function useMentions(
             channelType: options?.channelType,
             currentPubkey,
             ownerProfiles: ownerProfilesQuery.data?.profiles,
-            profiles,
+            profiles: mentionProfiles,
             requireExact: exactMentionSpace,
           });
           if (exactMentionSpace && flushed?.type !== "match")
@@ -880,10 +913,10 @@ export function useMentions(
       currentPubkey,
       isMentionOpen,
       mentionCandidatesWithTeams,
+      mentionProfiles,
       mentionSelectedIndex,
       options?.channelType,
       ownerProfilesQuery.data?.profiles,
-      profiles,
       setSelected,
       suggestions,
     ],
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.tsx b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
index a380ac83a09..32e29ce87a4 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.tsx
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
@@ -31,6 +31,8 @@ export type MentionSuggestion = {
   notInChannel?: boolean;
   ownerLabel?: string | null;
   role?: string | null;
+  /** One-line agent role/description from the kind-0 `about` field. */
+  description?: string | null;
 };
 
 type MentionAutocompleteProps = {
@@ -344,13 +346,23 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                             team · {suggestion.teamMembers?.length ?? 0} agents
                           </span>
                         ) : suggestion.isAgent ? (
-                          <span className="inline-flex shrink-0 items-center gap-1">
+                          <span className="inline-flex min-w-0 items-center gap-1">
                             <Bot
                               aria-hidden="true"
-                              className="h-3.5 w-3.5"
+                              className="h-3.5 w-3.5 shrink-0"
                               data-testid="mention-agent-icon"
                             />
-                            agent
+                            {suggestion.description ? (
+                              <span
+                                className="min-w-0 truncate"
+                                data-testid="mention-agent-description"
+                                title={suggestion.description}
+                              >
+                                {suggestion.description}
+                              </span>
+                            ) : (
+                              "agent"
+                            )}
                             {showAgentProvenanceMarker ? (
                               <OtherSetupAgentMarker testId="mention-agent-provenance" />
                             ) : null}
diff --git a/desktop/src/features/profile/lib/identity.ts b/desktop/src/features/profile/lib/identity.ts
index d2e0a4fdd38..23e0a58a741 100644
--- a/desktop/src/features/profile/lib/identity.ts
+++ b/desktop/src/features/profile/lib/identity.ts
@@ -39,6 +39,7 @@ export function profileLookupsEqual(
       prev.displayName !== next.displayName ||
       prev.name !== next.name ||
       prev.avatarUrl !== next.avatarUrl ||
+      prev.about !== next.about ||
       prev.nip05Handle !== next.nip05Handle ||
       prev.ownerPubkey !== next.ownerPubkey ||
       prev.isAgent !== next.isAgent
@@ -80,6 +81,7 @@ export function mergeCurrentProfileIntoLookup(
       // lookup already resolved so mention aliases survive the merge.
       name: profiles?.[normalizePubkey(currentProfile.pubkey)]?.name ?? null,
       avatarUrl: currentProfile.avatarUrl,
+      about: profiles?.[normalizePubkey(currentProfile.pubkey)]?.about ?? null,
       nip05Handle: currentProfile.nip05Handle,
       isAgent: profiles?.[normalizePubkey(currentProfile.pubkey)]?.isAgent,
       ownerPubkey:
diff --git a/desktop/src/shared/api/tauriProfiles.ts b/desktop/src/shared/api/tauriProfiles.ts
index c8e52f51693..fc203e35f8b 100644
--- a/desktop/src/shared/api/tauriProfiles.ts
+++ b/desktop/src/shared/api/tauriProfiles.ts
@@ -18,7 +18,7 @@ type RawProfile = {
   has_profile_event?: boolean;
 };
 
-type RawUserProfileSummary = Omit<RawProfile, "pubkey" | "about"> & {
+type RawUserProfileSummary = Omit<RawProfile, "pubkey"> & {
   name?: string | null;
   is_agent?: boolean;
 };
@@ -54,6 +54,7 @@ function fromRawUserProfileSummary(
     displayName: profile.display_name,
     name: profile.name ?? null,
     avatarUrl: profile.avatar_url,
+    about: profile.about,
     nip05Handle: profile.nip05_handle,
     ownerPubkey: profile.owner_pubkey,
     isAgent: profile.is_agent ?? false,
@@ -65,6 +66,7 @@ function fromRawUserSearchResult(user: RawUserSearchResult): UserSearchResult {
     pubkey: user.pubkey,
     displayName: user.display_name,
     avatarUrl: user.avatar_url,
+    about: user.about,
     nip05Handle: user.nip05_handle,
     ownerPubkey: user.owner_pubkey,
     isAgent: user.is_agent ?? false,
diff --git a/desktop/src/shared/api/types.ts b/desktop/src/shared/api/types.ts
index b988843d60b..48128537a42 100644
--- a/desktop/src/shared/api/types.ts
+++ b/desktop/src/shared/api/types.ts
@@ -122,6 +122,9 @@ export type UserProfileSummary = {
    * `display_name` *or* `name` at send time). */
   name?: string | null;
   avatarUrl: string | null;
+  /** Kind-0 `about` — one-line role/description shown in the @-mention
+   * selector for agents. */
+  about?: string | null;
   nip05Handle: string | null;
   ownerPubkey: string | null;
   isAgent?: boolean;
@@ -136,6 +139,10 @@ export type UserSearchResult = {
   pubkey: string;
   displayName: string | null;
   avatarUrl: string | null;
+  /** Kind-0 `about` — one-line role/description shown in the @-mention
+   * selector for agents. Optional: synthetic results (e.g. locally known
+   * agents folded into search) omit it. */
+  about?: string | null;
   nip05Handle: string | null;
   ownerPubkey: string | null;
   isAgent: boolean;
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index d54c32e4c48..281c0adaf45 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -715,6 +715,7 @@ type RawUserProfileSummary = {
   display_name: string | null;
   name?: string | null;
   avatar_url: string | null;
+  about?: string | null;
   nip05_handle: string | null;
   owner_pubkey: string | null;
   is_agent?: boolean;
@@ -6948,6 +6949,7 @@ async function handleGetUsersBatch(
         display_name: profile.display_name,
         name: profile.name ?? null,
         avatar_url: profile.avatar_url,
+        about: profile.about,
         nip05_handle: profile.nip05_handle,
         owner_pubkey: profile.owner_pubkey,
         is_agent: profile.is_agent ?? false,
@@ -6973,6 +6975,7 @@ async function handleGetUsersBatch(
       display_name: content.display_name ?? content.name ?? null,
       name: content.name ?? null,
       avatar_url: content.picture ?? null,
+      about: content.about ?? null,
       nip05_handle: content.nip05 ?? null,
       owner_pubkey:
         ((ev.tags ?? []) as string[][]).find(
@@ -7002,6 +7005,7 @@ async function handleGetUsersBatch(
       display_name: profile.display_name,
       name: profile.name ?? null,
       avatar_url: profile.avatar_url,
+      about: profile.about,
       nip05_handle: profile.nip05_handle,
       owner_pubkey: profile.owner_pubkey,
       is_agent: profile.is_agent ?? false,
@@ -7059,6 +7063,7 @@ async function handleSearchUsers(
         pubkey: profile.pubkey,
         display_name: profile.display_name,
         avatar_url: profile.avatar_url,
+        about: profile.about,
         nip05_handle: profile.nip05_handle,
         owner_pubkey: profile.owner_pubkey,
         is_agent: profile.is_agent ?? false,
@@ -7085,6 +7090,7 @@ async function handleSearchUsers(
       pubkey: ev.pubkey ?? "",
       display_name: content.display_name ?? content.name ?? null,
       avatar_url: content.picture ?? null,
+      about: content.about ?? null,
       nip05_handle: content.nip05 ?? null,
       owner_pubkey:
         ((ev.tags ?? []) as string[][]).find(
diff --git a/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
new file mode 100644
index 00000000000..bd146c5840f
--- /dev/null
+++ b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
@@ -0,0 +1,176 @@
+import { expect, test } from "@playwright/test";
+
+import { waitForAnimations } from "../helpers/animations";
+import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
+
+const SHOTS = "test-results/mention-descriptions";
+
+// Distinct pubkeys — no overlap with bridge fixtures or other specs.
+const FIZZ_PUBKEY = "3a".repeat(32);
+const HONEY_PUBKEY = "3b".repeat(32);
+const BUMBLE_PUBKEY = "3c".repeat(32);
+const BUZZY_PUBKEY = "3d".repeat(32);
+const ATLAS_PUBKEY = "3e".repeat(32);
+
+const FIZZ_ABOUT = "Builder — implements features and fixes bugs";
+const HONEY_ABOUT = "Writer — drafts docs, posts, and summaries";
+const BUMBLE_ABOUT = "Researcher — deep dives, sourcing, and citations";
+const ATLAS_LONG_ABOUT =
+  "Operations copilot for the whole hive: triages incoming requests, " +
+  "routes work to the right specialist agent, keeps the runbook current, " +
+  "and escalates anything ambiguous to a human before acting on it";
+
+/** Locator scoped to the mention autocomplete dropdown inside the composer. */
+function autocomplete(page: import("@playwright/test").Page) {
+  return page
+    .getByTestId("message-composer")
+    .getByTestId("mention-autocomplete");
+}
+
+/** Full-page clip spanning the open dropdown down to the composer bottom. */
+async function shootComposerWithDropdown(
+  page: import("@playwright/test").Page,
+  path: string,
+) {
+  await waitForAnimations(page);
+  const dropdownBox = await autocomplete(page).boundingBox();
+  const composerBox = await page.getByTestId("message-composer").boundingBox();
+  if (!dropdownBox || !composerBox) {
+    throw new Error("composer or dropdown not visible for screenshot");
+  }
+  const top = Math.max(0, dropdownBox.y - 8);
+  await page.screenshot({
+    path,
+    clip: {
+      x: Math.max(0, composerBox.x - 8),
+      y: top,
+      width: composerBox.width + 16,
+      height: composerBox.y + composerBox.height + 8 - top,
+    },
+  });
+}
+
+test("mention selector shows each agent's kind-0 about as a role line", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    managedAgents: [
+      {
+        pubkey: FIZZ_PUBKEY,
+        name: "Fizz",
+        status: "stopped",
+        channelNames: ["general"],
+      },
+      {
+        pubkey: HONEY_PUBKEY,
+        name: "Honey",
+        status: "stopped",
+        channelNames: ["general"],
+      },
+      {
+        pubkey: BUMBLE_PUBKEY,
+        name: "Bumble",
+        status: "stopped",
+        channelNames: ["general"],
+      },
+      {
+        pubkey: BUZZY_PUBKEY,
+        name: "Buzzy",
+        status: "stopped",
+        channelNames: ["general"],
+      },
+    ],
+    searchProfiles: [
+      { pubkey: FIZZ_PUBKEY, displayName: "Fizz", about: FIZZ_ABOUT },
+      { pubkey: HONEY_PUBKEY, displayName: "Honey", about: HONEY_ABOUT },
+      { pubkey: BUMBLE_PUBKEY, displayName: "Bumble", about: BUMBLE_ABOUT },
+      // Buzzy has no `about` — exercises the name-only fallback row.
+      // bob is human — an `about` on a person must NOT render a role line.
+      {
+        pubkey: TEST_IDENTITIES.bob.pubkey,
+        displayName: "bob",
+        about: "A human bio that stays off the mention row",
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  await page.getByTestId("message-input").fill("@");
+
+  const dropdown = autocomplete(page);
+  await expect(dropdown).toBeVisible();
+
+  for (const [name, about] of [
+    ["Fizz", FIZZ_ABOUT],
+    ["Honey", HONEY_ABOUT],
+    ["Bumble", BUMBLE_ABOUT],
+  ] as const) {
+    const row = dropdown.locator("button", { hasText: name });
+    await expect(row.getByTestId("mention-agent-icon")).toBeVisible();
+    await expect(row.getByTestId("mention-agent-description")).toHaveText(
+      about,
+    );
+    await expect(row.getByText("managed by you")).toBeVisible();
+  }
+
+  // No `about` → today's exact row: bot icon + literal "agent" label.
+  const buzzyRow = dropdown.locator("button", { hasText: "Buzzy" });
+  await expect(buzzyRow.getByTestId("mention-agent-icon")).toBeVisible();
+  await expect(buzzyRow.getByText("agent", { exact: true })).toBeVisible();
+  await expect(buzzyRow.getByTestId("mention-agent-description")).toHaveCount(
+    0,
+  );
+
+  // Humans never get a role line, even with an `about` on their profile.
+  const bobRow = dropdown.locator("button", { hasText: "bob" });
+  await expect(bobRow).toBeVisible();
+  await expect(bobRow.getByTestId("mention-agent-description")).toHaveCount(0);
+
+  // Scroll the agent rows into frame — the list opens scrolled to the top
+  // where the viewer/member rows sit.
+  await dropdown.evaluate((el) => {
+    el.scrollTop = el.scrollHeight;
+  });
+  await shootComposerWithDropdown(page, `${SHOTS}/01-agent-role-lines.png`);
+});
+
+test("long about truncates to a single line beside the managed-by label", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    managedAgents: [
+      {
+        pubkey: ATLAS_PUBKEY,
+        name: "Atlas",
+        status: "stopped",
+        channelNames: ["general"],
+      },
+    ],
+    searchProfiles: [
+      { pubkey: ATLAS_PUBKEY, displayName: "Atlas", about: ATLAS_LONG_ABOUT },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  await page.getByTestId("message-input").fill("@Atlas");
+
+  const dropdown = autocomplete(page);
+  const atlasRow = dropdown.locator("button", { hasText: "Atlas" });
+  const description = atlasRow.getByTestId("mention-agent-description");
+  await expect(description).toBeVisible();
+  await expect(description).toHaveAttribute("title", ATLAS_LONG_ABOUT);
+  await expect(atlasRow.getByText("managed by you")).toBeVisible();
+
+  // The full text must overflow its one-line box — proof it truncates
+  // instead of wrapping or pushing the managed-by label out of the row.
+  const truncates = await description.evaluate(
+    (el) => el.scrollWidth > el.clientWidth,
+  );
+  expect(truncates).toBe(true);
+
+  await shootComposerWithDropdown(page, `${SHOTS}/02-long-about-truncates.png`);
+});

From e781309338a268af912aefaabdb7314667806ea9 Mon Sep 17 00:00:00 2001
From: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
Date: Fri, 4 Sep 2026 04:00:06 -0700
Subject: [PATCH 2/5] test(desktop): assert the mention hover popover shows the
 about bio

Gemini tester (harsh mode) flagged that UserProfilePopover renders
profile?.about?.trim() but no test asserted it. Add a smoke spec that
seeds an agent profile with an about bio, hovers its message, and
asserts the popover's user-profile-description testid shows the text.

Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
---
 desktop/tests/e2e/mentions.spec.ts | 37 ++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/desktop/tests/e2e/mentions.spec.ts b/desktop/tests/e2e/mentions.spec.ts
index a0503880d6c..1dcc5275b72 100644
--- a/desktop/tests/e2e/mentions.spec.ts
+++ b/desktop/tests/e2e/mentions.spec.ts
@@ -4691,6 +4691,43 @@ test("agent profile popover falls back to the owner's pubkey", async ({
   ).toHaveText("managed by 11111111…1111");
 });
 
+test("agent profile popover shows the about bio", async ({ page }) => {
+  await installMockBridge(page, {
+    searchProfiles: [
+      {
+        pubkey: OWNED_AGENT_PROFILE_PUBKEY,
+        displayName: "Pollen",
+        ownerPubkey: MOCK_VIEWER_PUBKEY,
+        about: "Pollinates the garden channel and tracks bloom schedules",
+        isAgent: true,
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await waitForMockLiveSubscription(page, "general");
+
+  await emitMockMessage(page, "general", "Pollen checking in.", {
+    pubkey: OWNED_AGENT_PROFILE_PUBKEY,
+  });
+  await waitForTimelineSettled(page);
+
+  const pollenMessage = page
+    .getByTestId("message-row")
+    .filter({ hasText: "Pollen checking in." })
+    .first();
+  await pollenMessage.locator("button").first().hover();
+
+  const profilePopover = page.locator(
+    '[data-testid="user-profile-popover"][data-state="open"]',
+  );
+  await expect(profilePopover).toBeVisible();
+  await expect(
+    profilePopover.getByTestId("user-profile-description"),
+  ).toHaveText("Pollinates the garden channel and tracks bloom schedules");
+});
+
 test("human profile popover does not show an owner", async ({ page }) => {
   await page.goto("/");
   await page.getByTestId("channel-general").click();

From a081bf242ca18146066dd414482db6c10a7cd96e Mon Sep 17 00:00:00 2001
From: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
Date: Fri, 4 Sep 2026 08:22:39 -0700
Subject: [PATCH 3/5] fix(desktop): bound the mention agent-profile fallback
 batch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sol audit on port/2706 found the new agent-profile fallback in
useMentions.ts batched every mentionable agent with an unknown `about`
into one unlimited get_users_batch call. On a composer with no scoped
`profiles` prop (New Message, Forum, project agent chat), the author
set is the whole mentionable-agent directory; the relay clamps a
limit-less filter to 100 rows, and a truncated page gets cached as
confirmed-missing for 10 minutes across the whole app.

- Extract the fallback's windowing and filtering into
  mentionFallbackWindow.ts (rankVisibleMentionCandidates,
  selectAgentProfileFallbackPubkeys): the batch is now drawn only from
  the ranked, visible MENTION_SUGGESTION_LIMIT (50) window, never the
  full candidate set, so every request stays under the relay's clamp.
  Re-ranking on each keystroke still brings an agent past the window
  into view with its own bounded request.
- Fix the accessible-description gap the audit flagged in
  MentionAutocomplete.tsx: the row's aria-label overrode the role line
  as unannounced descendant text; wire it via aria-describedby instead.
- Add mentionFallbackWindow.test.mjs (unit, >100 fake agents) and a
  New Message e2e regression (no `profiles` prop reaches the composer,
  so the fallback is the only thing that can resolve an about) —
  verified both fail when the fallback wiring is reverted.

Co-authored-by: Sol audit (GPT-5.6, xhigh)
Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
---
 .../lib/mentionFallbackWindow.test.mjs        | 113 +++++++++++++++++
 .../messages/lib/mentionFallbackWindow.ts     |  68 +++++++++++
 .../src/features/messages/lib/useMentions.ts  |  83 +++++++------
 .../messages/ui/MentionAutocomplete.tsx       |  11 ++
 .../mention-descriptions-screenshots.spec.ts  | 115 +++++++++++++++++-
 5 files changed, 350 insertions(+), 40 deletions(-)
 create mode 100644 desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
 create mode 100644 desktop/src/features/messages/lib/mentionFallbackWindow.ts

diff --git a/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs b/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
new file mode 100644
index 00000000000..bb5e2d88d16
--- /dev/null
+++ b/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { rankMentionCandidates } from "./mentionRanking.ts";
+import {
+  MENTION_SUGGESTION_LIMIT,
+  rankVisibleMentionCandidates,
+  selectAgentProfileFallbackPubkeys,
+} from "./mentionFallbackWindow.ts";
+
+function agentCandidate(n, overrides = {}) {
+  return {
+    displayName: `Agent${String(n).padStart(3, "0")}`,
+    isAgent: true,
+    isMember: false,
+    kind: "identity",
+    pubkey: `${n.toString(16).padStart(4, "0")}`.padEnd(64, "0"),
+    ...overrides,
+  };
+}
+
+test("bounds the fallback batch to MENTION_SUGGESTION_LIMIT even with 150 mentionable agents", () => {
+  // Production seam: useMentions.ts's agentProfilePubkeys calls exactly this
+  // function on exactly the output of rankVisibleMentionCandidates. A
+  // community with 150 mentionable agents and no caller-scoped `profiles`
+  // must never turn into a 150-author get_users_batch request — the relay
+  // clamps a limit-less filter to 100 rows, and a truncated page gets
+  // cached as confirmed-missing (see the docblock on
+  // selectAgentProfileFallbackPubkeys).
+  const candidates = Array.from({ length: 150 }, (_, i) => agentCandidate(i));
+  const visible = rankVisibleMentionCandidates(candidates, "", new Set());
+  assert.equal(visible.length, MENTION_SUGGESTION_LIMIT);
+
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, undefined);
+  assert.equal(pubkeys.length, MENTION_SUGGESTION_LIMIT);
+  // Every returned pubkey actually belongs to a candidate in the input —
+  // never a synthesized or out-of-window pubkey.
+  const visiblePubkeys = new Set(visible.map((r) => r.candidate.pubkey));
+  for (const pubkey of pubkeys) {
+    assert.ok(visiblePubkeys.has(pubkey));
+  }
+});
+
+test("an agent past the first page is excluded from the bare-query window but resolves once the query ranks it into view", () => {
+  const candidates = Array.from({ length: 150 }, (_, i) => agentCandidate(i));
+  const lastCandidate = candidates[149];
+
+  const bareVisible = rankVisibleMentionCandidates(candidates, "", new Set());
+  const barePubkeys = selectAgentProfileFallbackPubkeys(bareVisible, undefined);
+  assert.ok(
+    !barePubkeys.includes(lastCandidate.pubkey),
+    "the 150th agent should be outside the default-ranked first page",
+  );
+
+  // Narrowing the query to its exact display name ranks it first (an
+  // exact-match label always scores ahead of a mere prefix or substring
+  // match — see mentionRanking.ts's scoreMentionCandidateLabel) and brings
+  // it into the window, so it gets its own bounded request.
+  const narrowedVisible = rankVisibleMentionCandidates(
+    candidates,
+    lastCandidate.displayName,
+    new Set(),
+  );
+  const narrowedPubkeys = selectAgentProfileFallbackPubkeys(
+    narrowedVisible,
+    undefined,
+  );
+  assert.ok(narrowedPubkeys.includes(lastCandidate.pubkey));
+});
+
+test("excludes agents whose about is already known", () => {
+  const known = agentCandidate(1, { description: "Already known" });
+  const unknown = agentCandidate(2);
+  const visible = rankVisibleMentionCandidates([known, unknown], "", new Set());
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, undefined);
+  assert.deepEqual(pubkeys, [unknown.pubkey]);
+});
+
+test("excludes agents already covered by the caller's profiles prop", () => {
+  const covered = agentCandidate(1);
+  const uncovered = agentCandidate(2);
+  const visible = rankVisibleMentionCandidates(
+    [covered, uncovered],
+    "",
+    new Set(),
+  );
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, {
+    [covered.pubkey]: {
+      displayName: null,
+      name: null,
+      avatarUrl: null,
+      about: "Known via the caller",
+      nip05Handle: null,
+      ownerPubkey: null,
+    },
+  });
+  assert.deepEqual(pubkeys, [uncovered.pubkey]);
+});
+
+test("excludes non-agent candidates even when their description is unknown", () => {
+  const person = agentCandidate(1, { isAgent: false });
+  const agent = agentCandidate(2);
+  const visible = rankVisibleMentionCandidates([person, agent], "", new Set());
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, undefined);
+  assert.deepEqual(pubkeys, [agent.pubkey]);
+});
+
+test("dedupes repeated pubkeys in the ranked window", () => {
+  const agent = agentCandidate(1);
+  const ranked = rankMentionCandidates([agent, { ...agent }], "", new Set());
+  const pubkeys = selectAgentProfileFallbackPubkeys(ranked, undefined);
+  assert.deepEqual(pubkeys, [agent.pubkey]);
+});
diff --git a/desktop/src/features/messages/lib/mentionFallbackWindow.ts b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
new file mode 100644
index 00000000000..2d981742a35
--- /dev/null
+++ b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
@@ -0,0 +1,68 @@
+import type { UserProfileLookup } from "@/features/profile/lib/identity";
+import {
+  type MentionCandidateForRanking,
+  rankMentionCandidates,
+  type RankedMentionCandidate,
+} from "./mentionRanking";
+
+/**
+ * Cap on the mention picker's rendered suggestion list, and — via
+ * {@link rankVisibleMentionCandidates} — on the agent profile fallback batch
+ * in useMentions.ts's `agentProfilePubkeys`. The two must share one bound:
+ * on a surface with no scoped `profiles` prop the mentionable set can be a
+ * community's whole agent directory, and the relay's `get_users_batch`
+ * clamps a limit-less filter to 100 rows. Requesting every unknown agent in
+ * the directory risks a truncated page being cached as confirmed-missing.
+ * Keeping the fallback to this same 50-row window keeps every request under
+ * that clamp.
+ */
+export const MENTION_SUGGESTION_LIMIT = 50;
+
+/** Ranks `candidates` against `query` and cuts to {@link MENTION_SUGGESTION_LIMIT}. */
+export function rankVisibleMentionCandidates<
+  T extends MentionCandidateForRanking,
+>(
+  candidates: readonly T[],
+  query: string,
+  activePersonaIds: ReadonlySet<string>,
+): RankedMentionCandidate<T>[] {
+  return rankMentionCandidates(candidates, query, activePersonaIds).slice(
+    0,
+    MENTION_SUGGESTION_LIMIT,
+  );
+}
+
+export type AgentProfileFallbackCandidate = MentionCandidateForRanking & {
+  description?: string | null;
+};
+
+/**
+ * Agent pubkeys whose kind-0 `about` is not already known — neither
+ * resolved at candidate-build time (search results) nor present in the
+ * caller's profile lookup — drawn ONLY from the already-ranked, already-
+ * bounded visible window (`rankedVisibleCandidates`), never the full
+ * mentionable-agent set. Batch-resolving just this window lets the selector
+ * show a role line even for agents who haven't authored anything in the
+ * loaded timeline, without the unbounded-batch failure mode
+ * {@link MENTION_SUGGESTION_LIMIT} documents.
+ */
+export function selectAgentProfileFallbackPubkeys<
+  T extends AgentProfileFallbackCandidate,
+>(
+  rankedVisibleCandidates: readonly RankedMentionCandidate<T>[],
+  profiles: UserProfileLookup | undefined,
+): string[] {
+  return [
+    ...new Set(
+      rankedVisibleCandidates
+        .filter(
+          ({ candidate }) =>
+            candidate.isAgent &&
+            candidate.pubkey &&
+            candidate.description === undefined &&
+            !profiles?.[candidate.pubkey],
+        )
+        .map(({ candidate }) => candidate.pubkey as string),
+    ),
+  ];
+}
diff --git a/desktop/src/features/messages/lib/useMentions.ts b/desktop/src/features/messages/lib/useMentions.ts
index 085f8843bdc..452848c4616 100644
--- a/desktop/src/features/messages/lib/useMentions.ts
+++ b/desktop/src/features/messages/lib/useMentions.ts
@@ -54,7 +54,11 @@ import {
   type MentionPickerMode,
   useMentionSelection,
 } from "./useMentionSelection";
-import { rankMentionCandidates } from "./mentionRanking";
+import {
+  MENTION_SUGGESTION_LIMIT,
+  rankVisibleMentionCandidates,
+  selectAgentProfileFallbackPubkeys,
+} from "./mentionFallbackWindow";
 import { mapMentionCandidateToSuggestion } from "./mentionSuggestionMapping";
 import { getMentionMemberPubkeys } from "./mentionMemberPubkeys";
 import {
@@ -64,8 +68,7 @@ import {
   type MentionCandidate,
 } from "./mentionCandidates";
 import { buildMentionCandidates } from "./buildMentionCandidates";
-const MENTION_DEBOUNCE_MS = 120,
-  MENTION_SUGGESTION_LIMIT = 50;
+const MENTION_DEBOUNCE_MS = 120;
 type UseMentionsOptions = {
   channelType?: ChannelType | null;
   recentMentionPubkeys?: readonly string[];
@@ -320,27 +323,38 @@ export function useMentions(
   const ownerProfilesQuery = useUsersBatchQuery(ownerPubkeys, {
     enabled: ownerPubkeys.length > 0,
   });
+  // Candidates ranked against the in-progress query and cut to
+  // MENTION_SUGGESTION_LIMIT — the same window the picker renders. Empty
+  // while the picker is closed (`mentionQuery === null`). Shared below by
+  // the agent profile fallback and by `matchingSuggestions`, so both agree
+  // on exactly which candidates are visible. See mentionFallbackWindow.ts
+  // for why the fallback must stay bounded to this window.
+  const rankedVisibleMentionCandidates = React.useMemo(
+    () =>
+      mentionQuery === null
+        ? []
+        : rankVisibleMentionCandidates(
+            mentionCandidatesWithTeams,
+            mentionQuery,
+            activePersonaIds,
+          ),
+    [activePersonaIds, mentionCandidatesWithTeams, mentionQuery],
+  );
   // Agent candidates whose kind-0 `about` is not already known — neither
   // resolved at candidate-build time (search results) nor present in the
   // caller's profile lookup. Batch-resolve them so the selector can show a
   // role line even for agents who haven't authored anything in the loaded
   // timeline. The per-pubkey entry cache behind useUsersBatchQuery keeps
-  // repeat lookups off the network.
+  // repeat lookups off the network. See mentionFallbackWindow.ts's
+  // selectAgentProfileFallbackPubkeys for why this is bounded to
+  // `rankedVisibleMentionCandidates` rather than every mentionable agent.
   const agentProfilePubkeys = React.useMemo(
-    () => [
-      ...new Set(
-        mentionCandidates
-          .filter(
-            (candidate) =>
-              candidate.isAgent &&
-              candidate.pubkey &&
-              candidate.description === undefined &&
-              !profiles?.[candidate.pubkey],
-          )
-          .map((candidate) => candidate.pubkey as string),
+    () =>
+      selectAgentProfileFallbackPubkeys(
+        rankedVisibleMentionCandidates,
+        profiles,
       ),
-    ],
-    [mentionCandidates, profiles],
+    [rankedVisibleMentionCandidates, profiles],
   );
   const agentProfilesQuery = useUsersBatchQuery(agentProfilePubkeys, {
     enabled: agentProfilePubkeys.length > 0,
@@ -401,17 +415,9 @@ export function useMentions(
     },
     [],
   );
-  const matchingSuggestions = React.useMemo<MentionSuggestion[]>(() => {
-    if (mentionQuery === null) {
-      return [];
-    }
-    return rankMentionCandidates(
-      mentionCandidatesWithTeams,
-      mentionQuery,
-      activePersonaIds,
-    )
-      .slice(0, MENTION_SUGGESTION_LIMIT)
-      .map(({ candidate, label }) =>
+  const matchingSuggestions = React.useMemo<MentionSuggestion[]>(
+    () =>
+      rankedVisibleMentionCandidates.map(({ candidate, label }) =>
         mapMentionCandidateToSuggestion({
           agentProvenanceReady: agentDirectoriesReady,
           candidate,
@@ -421,17 +427,16 @@ export function useMentions(
           ownerProfiles: ownerProfilesQuery.data?.profiles,
           profiles: mentionProfiles,
         }),
-      );
-  }, [
-    activePersonaIds,
-    agentDirectoriesReady,
-    currentPubkey,
-    mentionCandidatesWithTeams,
-    mentionProfiles,
-    mentionQuery,
-    options?.channelType,
-    ownerProfilesQuery.data?.profiles,
-  ]);
+      ),
+    [
+      agentDirectoriesReady,
+      currentPubkey,
+      mentionProfiles,
+      options?.channelType,
+      ownerProfilesQuery.data?.profiles,
+      rankedVisibleMentionCandidates,
+    ],
+  );
   const getDefaultAgentSuggestion = useDefaultAgentSuggestion({
     activePersonaIds,
     agentProvenanceReady: agentDirectoriesReady,
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.tsx b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
index 32e29ce87a4..ee939b3efb2 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.tsx
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
@@ -281,6 +281,15 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
               suggestion.pubkey &&
                 lockedAgentPubkeys?.has(suggestion.pubkey.toLowerCase()),
             );
+            // The row's `aria-label` overrides all descendant text as the
+            // accessible name, so the role line below is otherwise announced
+            // to no one — the exact disambiguation it exists to provide
+            // (two same-named agents with different roles) is unavailable to
+            // screen-reader users without this.
+            const descriptionId =
+              suggestion.isAgent && suggestion.description
+                ? `mention-agent-description-${index}`
+                : undefined;
 
             return (
               <div
@@ -295,6 +304,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                 key={suggestionKey}
               >
                 <button
+                  aria-describedby={descriptionId}
                   aria-label={`Mention ${suggestion.displayName}`}
                   className={cn(
                     "flex min-w-0 flex-1 items-center gap-2 rounded-lg px-3 py-1.5 text-left",
@@ -356,6 +366,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                               <span
                                 className="min-w-0 truncate"
                                 data-testid="mention-agent-description"
+                                id={descriptionId}
                                 title={suggestion.description}
                               >
                                 {suggestion.description}
diff --git a/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
index bd146c5840f..8f8c41bc6ec 100644
--- a/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
+++ b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
@@ -1,7 +1,12 @@
 import { expect, test } from "@playwright/test";
 
 import { waitForAnimations } from "../helpers/animations";
-import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
+import {
+  installMockBridge,
+  openNewMessagePage,
+  TEST_IDENTITIES,
+} from "../helpers/bridge";
+import type { MockManagedAgentSeed } from "../../src/testing/e2eBridge";
 
 const SHOTS = "test-results/mention-descriptions";
 
@@ -112,6 +117,12 @@ test("mention selector shows each agent's kind-0 about as a role line", async ({
     await expect(row.getByTestId("mention-agent-description")).toHaveText(
       about,
     );
+    // The row's aria-label ("Mention Fizz") overrides descendant text as the
+    // accessible name, so the role line must reach screen readers through
+    // aria-describedby instead — assert the accessible description directly
+    // rather than only the visible text, or a regression that renders the
+    // text but drops the wiring would pass silently.
+    await expect(row).toHaveAccessibleDescription(about);
     await expect(row.getByText("managed by you")).toBeVisible();
   }
 
@@ -122,11 +133,13 @@ test("mention selector shows each agent's kind-0 about as a role line", async ({
   await expect(buzzyRow.getByTestId("mention-agent-description")).toHaveCount(
     0,
   );
+  await expect(buzzyRow).toHaveAccessibleDescription("");
 
   // Humans never get a role line, even with an `about` on their profile.
   const bobRow = dropdown.locator("button", { hasText: "bob" });
   await expect(bobRow).toBeVisible();
   await expect(bobRow.getByTestId("mention-agent-description")).toHaveCount(0);
+  await expect(bobRow).toHaveAccessibleDescription("");
 
   // Scroll the agent rows into frame — the list opens scrolled to the top
   // where the viewer/member rows sit.
@@ -163,6 +176,7 @@ test("long about truncates to a single line beside the managed-by label", async
   const description = atlasRow.getByTestId("mention-agent-description");
   await expect(description).toBeVisible();
   await expect(description).toHaveAttribute("title", ATLAS_LONG_ABOUT);
+  await expect(atlasRow).toHaveAccessibleDescription(ATLAS_LONG_ABOUT);
   await expect(atlasRow.getByText("managed by you")).toBeVisible();
 
   // The full text must overflow its one-line box — proof it truncates
@@ -174,3 +188,102 @@ test("long about truncates to a single line beside the managed-by label", async
 
   await shootComposerWithDropdown(page, `${SHOTS}/02-long-about-truncates.png`);
 });
+
+// Regression coverage for the agent-profile fallback in useMentions.ts
+// (agentProfilePubkeys / agentProfilesQuery / mentionProfiles). The tests
+// above drive ChannelScreen, whose `messageProfilePubkeys` already includes
+// every known agent, so those agents' `about` arrives through that OUTER
+// batch — the fallback never actually fires there. New Message's composer
+// (`NewMessageScreen.tsx`) is the fallback's real production seam: it
+// passes no `profiles` prop to `MessageComposer` at all, so any agent role
+// line here can only come from useMentions' own fallback batch.
+//
+// The numeric request bound (never more than MENTION_SUGGESTION_LIMIT
+// pubkeys, even with 150+ mentionable agents, and a past-the-window agent
+// still resolving once ranked into view) is covered directly and cheaply at
+// the unit level in mentionFallbackWindow.test.mjs, which exercises the
+// exact functions useMentions.ts calls. This spec proves the other half —
+// that useMentions.ts is actually wired to call them on a real composer
+// with no scoped `profiles` — through observable UI behavior only.
+const MANY_AGENTS_COUNT = 120;
+// Zero-padded to a fixed width so no agent's name is a substring of
+// another's (`Agent001` vs. `Agent010` vs. `Agent100`) — Playwright's
+// `hasText` matches substrings of the whole row, and these names are the
+// only thing that disambiguates one row from another.
+const agentName = (n: number) => `Agent${String(n).padStart(3, "0")}`;
+const FIRST_AGENT_NAME = agentName(1);
+const LAST_AGENT_NAME = agentName(MANY_AGENTS_COUNT);
+const LAST_AGENT_ABOUT = `Role ${MANY_AGENTS_COUNT}`;
+
+function manyAgentPubkey(index: number): string {
+  // 64 lowercase-hex chars, unique per index, distinct from every other
+  // fixture pubkey in this file and the shared bridge fixtures.
+  return `9f${index.toString(16).padStart(6, "0")}`.padEnd(64, "0");
+}
+
+const manyManagedAgents: MockManagedAgentSeed[] = Array.from(
+  { length: MANY_AGENTS_COUNT },
+  (_, i) => ({
+    pubkey: manyAgentPubkey(i),
+    name: agentName(i + 1),
+    status: "stopped",
+  }),
+);
+const manySearchProfiles = manyManagedAgents.map((agent, i) => ({
+  pubkey: agent.pubkey,
+  displayName: agent.name,
+  about: `Role ${i + 1}`,
+}));
+
+test("resolves an agent's about through the fallback batch on a composer with no profiles prop, bounded even past the ranked window", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    managedAgents: manyManagedAgents,
+    relayAgents: [],
+    searchProfiles: manySearchProfiles,
+  });
+  await page.goto("/");
+  await openNewMessagePage(page);
+
+  // New Message requires a recipient before the composer accepts input.
+  await page.getByTestId("new-dm-search").fill("charlie");
+  await page
+    .getByTestId(`new-dm-result-${TEST_IDENTITIES.charlie.pubkey}`)
+    .click();
+  await page.getByTestId("new-dm-search").press("Escape");
+  await expect(page.getByTestId("new-message-recipient-popover")).toBeHidden();
+
+  // A bare "@" keeps the mention query empty, which keeps global user
+  // search disabled (`canSearchGlobalPeople` requires non-empty text) — the
+  // fallback batch is the ONLY thing that can resolve an about here.
+  await page.getByTestId("message-input").fill("@");
+  const dropdown = autocomplete(page);
+  await expect(dropdown).toBeVisible();
+
+  // Ranked window caps at MENTION_SUGGESTION_LIMIT (50) even though 120
+  // agents are mentionable.
+  await expect(dropdown.locator("button")).toHaveCount(50);
+  await expect(
+    dropdown.locator("button", { hasText: LAST_AGENT_NAME }),
+  ).toHaveCount(0);
+
+  // A visible agent's role line resolved through the fallback. A bare "@"
+  // keeps global user search disabled (see above), so this text can only
+  // have come from useMentions' fallback batch — deleting that block drops
+  // this to the generic "agent" label and fails this assertion.
+  const firstRow = dropdown.locator("button", { hasText: FIRST_AGENT_NAME });
+  await expect(firstRow.getByTestId("mention-agent-description")).toHaveText(
+    "Role 1",
+  );
+
+  // Narrowing the query to the 120th agent's exact name ranks it first and
+  // brings it into the visible window — proof the bound doesn't strand an
+  // agent past the first page; it resolves once brought into view.
+  await page.getByTestId("message-input").fill(`@${LAST_AGENT_NAME}`);
+  const lastRow = dropdown.locator("button", { hasText: LAST_AGENT_NAME });
+  await expect(lastRow).toBeVisible();
+  await expect(lastRow.getByTestId("mention-agent-description")).toHaveText(
+    LAST_AGENT_ABOUT,
+  );
+});

From 72f49a69c8477d20496242a2be96332835d9d4fb Mon Sep 17 00:00:00 2001
From: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
Date: Fri, 4 Sep 2026 10:54:12 -0700
Subject: [PATCH 4/5] fix(desktop): address Sol audit findings on the mention
 agent-about picker

Cap the untrusted kind-0 `about` fed into the mention picker's role line
to 120 graphemes before it reaches the DOM (text node, title, and the
accessible description). Wire the verified "managed by <owner>" provenance
into aria-describedby alongside the agent's own bio, instead of only the
untrusted half. Cover profileLookupsEqual's about branch at both the
comparator and the useMessageProfiles hook that consumes it. Correct
mentionFallbackWindow.ts's docblock, which cited the wrong relay clamp
(100 instead of the actual DEFAULT_MAX_PAGE_LIMIT, 1000).

Rework the e2e request-bound regression test so it actually binds the
production seam: record every get_users_batch call from the first render
(a new startWithUsersBatchHeld mock config knob) so an unrelated app-shell
batch call can't pre-warm the per-pubkey cache and mask whether the
mention fallback's own request would have been bounded, and withhold the
past-window agent's about from search results (usersBatchOnlyPubkeys) so
its role line can only resolve through the fallback under test.

Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
---
 .../channels/ui/useMessageProfiles.test.mjs   |  98 +++++++++++++
 .../messages/lib/mentionFallbackWindow.ts     |  16 ++-
 .../lib/mentionSuggestionMapping.test.mjs     |  52 +++++++
 .../messages/lib/mentionSuggestionMapping.ts  |  34 ++++-
 .../messages/ui/MentionAutocomplete.test.mjs  |  68 +++++++++
 .../messages/ui/MentionAutocomplete.tsx       |  22 ++-
 .../features/profile/lib/identity.test.mjs    |   2 +
 desktop/src/testing/e2eBridge.ts              |  35 ++++-
 .../mention-descriptions-screenshots.spec.ts  | 136 +++++++++++++++---
 9 files changed, 433 insertions(+), 30 deletions(-)
 create mode 100644 desktop/src/features/channels/ui/useMessageProfiles.test.mjs

diff --git a/desktop/src/features/channels/ui/useMessageProfiles.test.mjs b/desktop/src/features/channels/ui/useMessageProfiles.test.mjs
new file mode 100644
index 00000000000..024ac5478e2
--- /dev/null
+++ b/desktop/src/features/channels/ui/useMessageProfiles.test.mjs
@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { JSDOM } from "jsdom";
+
+// Regression coverage for the `about` branch of `profileLookupsEqual`
+// (identity.ts) through its one production caller. `about` is what makes
+// the mention selector's role line pick up an about-only kind-0 update
+// (mentionSuggestionMapping.ts): the stabilized reference this hook returns
+// must be RELEASED (a new object identity) when only `about` changes, or
+// MessageRow's `prev.profiles === next.profiles` memo keeps rendering the
+// stale bio. See identity.test.mjs for the field-by-field coverage of
+// `profileLookupsEqual` itself.
+
+const dom = new JSDOM("<!doctype html><html><body></body></html>", {
+  url: "http://localhost",
+});
+
+before(() => {
+  Object.assign(globalThis, {
+    document: dom.window.document,
+    HTMLElement: dom.window.HTMLElement,
+    IS_REACT_ACT_ENVIRONMENT: true,
+    window: dom.window,
+  });
+});
+
+after(() => dom.window.close());
+
+const PUBKEY = "a".repeat(64);
+
+function profiles(about) {
+  return {
+    [PUBKEY]: {
+      displayName: "Ada",
+      name: null,
+      avatarUrl: null,
+      about,
+      nip05Handle: null,
+      ownerPubkey: null,
+      isAgent: true,
+    },
+  };
+}
+
+async function renderMessageProfiles(initialProps) {
+  const { renderHook } = await import("@testing-library/react");
+  const { useMessageProfiles } = await import("./useMessageProfiles.ts");
+
+  return renderHook((props) => useMessageProfiles(props), { initialProps });
+}
+
+const baseProps = {
+  channelMembers: undefined,
+  currentProfile: undefined,
+  currentPubkey: undefined,
+  managedAgents: [],
+  relayAgents: [],
+};
+
+test("releases the stabilized reference when only `about` changes", async () => {
+  const { result, rerender } = await renderMessageProfiles({
+    ...baseProps,
+    profiles: profiles("Researcher — deep dives"),
+  });
+
+  const first = result.current;
+  assert.equal(first[PUBKEY].about, "Researcher — deep dives");
+
+  rerender({ ...baseProps, profiles: profiles("Now doing something else") });
+
+  const second = result.current;
+  assert.notEqual(
+    second,
+    first,
+    "an about-only change must release the stabilized reference",
+  );
+  assert.equal(second[PUBKEY].about, "Now doing something else");
+});
+
+test("keeps the stabilized reference when no profile value actually changed", async () => {
+  const { result, rerender } = await renderMessageProfiles({
+    ...baseProps,
+    profiles: profiles("Researcher — deep dives"),
+  });
+
+  const first = result.current;
+
+  // A fresh `profiles` object with value-identical content — the shape a
+  // re-keyed `users-batch` query produces on typing churn.
+  rerender({ ...baseProps, profiles: profiles("Researcher — deep dives") });
+
+  assert.equal(
+    result.current,
+    first,
+    "a value-identical re-key must keep the stabilized reference",
+  );
+});
diff --git a/desktop/src/features/messages/lib/mentionFallbackWindow.ts b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
index 2d981742a35..efe8e817afa 100644
--- a/desktop/src/features/messages/lib/mentionFallbackWindow.ts
+++ b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
@@ -10,11 +10,17 @@ import {
  * {@link rankVisibleMentionCandidates} — on the agent profile fallback batch
  * in useMentions.ts's `agentProfilePubkeys`. The two must share one bound:
  * on a surface with no scoped `profiles` prop the mentionable set can be a
- * community's whole agent directory, and the relay's `get_users_batch`
- * clamps a limit-less filter to 100 rows. Requesting every unknown agent in
- * the directory risks a truncated page being cached as confirmed-missing.
- * Keeping the fallback to this same 50-row window keeps every request under
- * that clamp.
+ * community's whole agent directory. `get_users_batch` sends a `kind: 0`
+ * filter with no `limit` (desktop/src-tauri/src/commands/profile.rs), and
+ * the relay clamps a limit-less filter to `DEFAULT_MAX_PAGE_LIMIT` — 1,000
+ * rows (crates/buzz-db/src/store/event.rs), also the advertised NIP-11
+ * `max_limit` (crates/buzz-relay/src/nip11.rs). This bound is not sized
+ * against that 1,000-row ceiling; it is sized to match what the picker
+ * renders, so the fallback never fetches an about for an agent the user
+ * can't see. Requesting every unknown agent in the directory instead risks
+ * a truncated page (past 1,000 mentionable agents) being cached as
+ * confirmed-missing. Keeping the fallback to this same 50-row window keeps
+ * every request an order of magnitude under that clamp.
  */
 export const MENTION_SUGGESTION_LIMIT = 50;
 
diff --git a/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs b/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
index 1b6d408cf1b..b3c44681780 100644
--- a/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
+++ b/desktop/src/features/messages/lib/mentionSuggestionMapping.test.mjs
@@ -141,3 +141,55 @@ test("whitespace-only about degrades to null (name-only row)", () => {
 
   assert.equal(result.description, null);
 });
+
+test("an unbounded about is capped to 120 graphemes with an ellipsis", () => {
+  // A plausible non-hostile case: an agent whose `about` is its full system
+  // prompt. Also stands in for the relay's 256 KiB kind-0 content ceiling —
+  // this suite doesn't build a string that large, it proves the cap applies
+  // to any input longer than the bound, regardless of size.
+  const hugeAbout = "S".repeat(200_000);
+
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ description: hugeAbout }),
+    label: "Codex",
+  });
+
+  assert.equal(result.description?.length, 120);
+  assert.ok(result.description?.endsWith("…"));
+  assert.equal(result.description, `${"S".repeat(119)}…`);
+});
+
+test("an about exactly at the cap is left untouched", () => {
+  const exact = "A".repeat(120);
+
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ description: exact }),
+    label: "Codex",
+  });
+
+  assert.equal(result.description, exact);
+});
+
+test("description length cap counts graphemes, not UTF-16 code units", () => {
+  // Each family emoji is one grapheme cluster spanning multiple UTF-16 code
+  // units (ZWJ sequence) — a code-unit-based cap would truncate mid-cluster.
+  const family = "\u{1F468}‍\u{1F469}‍\u{1F467}‍\u{1F466}";
+  const about = family.repeat(130);
+
+  const result = mapMentionCandidateToSuggestion({
+    agentProvenanceReady: true,
+    candidate: agentCandidate({ description: about }),
+    label: "Codex",
+  });
+
+  assert.ok(result.description);
+  const graphemeCount = Array.from(
+    new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(
+      result.description,
+    ),
+  ).length;
+  assert.equal(graphemeCount, 120);
+  assert.ok(result.description.endsWith("…"));
+});
diff --git a/desktop/src/features/messages/lib/mentionSuggestionMapping.ts b/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
index 18a98abf3db..2758b719375 100644
--- a/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
+++ b/desktop/src/features/messages/lib/mentionSuggestionMapping.ts
@@ -8,6 +8,35 @@ import type { MentionCandidate, TeamMentionMember } from "./mentionCandidates";
 import { mentionCandidateLabel } from "./mentionCandidates";
 import { pickDefaultAgentCandidate } from "./mentionRanking";
 
+// Grapheme cap on the rendered role line. `about` is untrusted kind-0
+// content with no upstream length bound (the relay allows up to 256 KiB of
+// kind-0 content) — this is what keeps a hostile or merely verbose bio from
+// reaching the DOM (text node, `title` attribute, and the accessible
+// description) at full length. The full bio remains available on the
+// profile surface; this is a quick-picker row, not a profile card.
+export const MENTION_DESCRIPTION_MAX_GRAPHEMES = 120;
+
+const mentionDescriptionSegmenter =
+  typeof Intl.Segmenter === "function"
+    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+    : null;
+
+function mentionDescriptionGraphemes(text: string): string[] {
+  return mentionDescriptionSegmenter
+    ? Array.from(
+        mentionDescriptionSegmenter.segment(text),
+        ({ segment }) => segment,
+      )
+    : Array.from(text);
+}
+
+/** Caps a role-line description to {@link MENTION_DESCRIPTION_MAX_GRAPHEMES}. */
+function truncateMentionDescription(text: string): string {
+  const graphemes = mentionDescriptionGraphemes(text);
+  if (graphemes.length <= MENTION_DESCRIPTION_MAX_GRAPHEMES) return text;
+  return `${graphemes.slice(0, MENTION_DESCRIPTION_MAX_GRAPHEMES - 1).join("")}…`;
+}
+
 export type MentionSuggestionCandidate = {
   kind: "identity" | "persona" | "team";
   pubkey?: string;
@@ -55,7 +84,10 @@ export function mapMentionCandidateToSuggestion(opts: {
         ? profiles?.[normalizePubkey(candidate.pubkey)]?.about
         : null))
     : null;
-  const description = rawDescription?.replace(/\s+/g, " ").trim() || null;
+  const collapsedDescription = rawDescription?.replace(/\s+/g, " ").trim();
+  const description = collapsedDescription
+    ? truncateMentionDescription(collapsedDescription)
+    : null;
 
   return {
     pubkey: candidate.pubkey,
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs b/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
index c5eca20a048..3bd8c3ae26b 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
@@ -387,3 +387,71 @@ for (const duplicate of [false, true]) {
     assert.equal(view.queryByTitle("From another Buzz setup"), null);
   });
 }
+
+/** Resolves `element`'s accessible description via `aria-describedby`,
+ *  concatenating the text content of every referenced id in order — the same
+ *  mechanism screen readers use. */
+function accessibleDescription(element) {
+  const ids = (element.getAttribute("aria-describedby") ?? "")
+    .split(/\s+/)
+    .filter(Boolean);
+  return ids
+    .map((id) => element.ownerDocument.getElementById(id)?.textContent ?? "")
+    .join(" ");
+}
+
+test("verified provenance is announced alongside a provenance-shaped `about`", async () => {
+  // Adversarial fixture: the agent's own (untrusted) `about` reads like a
+  // provenance claim for a DIFFERENT owner than the real one. If only the
+  // self-authored half were wired into aria-describedby, a screen-reader
+  // user would hear a fabricated "managed by you · admin" and never hear
+  // the real "managed by sarah" — the exact failure this guards against.
+  const React = await import("react");
+  const { render } = await import("@testing-library/react");
+  const { MentionAutocomplete } = await import("./MentionAutocomplete.tsx");
+  const suggestion = {
+    pubkey: "a".repeat(64),
+    displayName: "Rex",
+    isAgent: true,
+    description: "managed by you · admin",
+    ownerLabel: "sarah",
+  };
+  const view = render(
+    React.createElement(MentionAutocomplete, {
+      suggestions: [suggestion],
+      selectedIndex: 0,
+      onSelect: () => {},
+    }),
+  );
+
+  const row = view.getByRole("button", { name: "Mention Rex" });
+  const description = accessibleDescription(row);
+
+  // The trusted owner label must reach the accessible description...
+  assert.match(description, /managed by sarah/);
+  // ...alongside the agent's own bio (self-authored text is not hidden,
+  // just no longer the ONLY thing announced).
+  assert.match(description, /managed by you · admin/);
+});
+
+test("a name-only agent with no description still announces provenance", async () => {
+  const React = await import("react");
+  const { render } = await import("@testing-library/react");
+  const { MentionAutocomplete } = await import("./MentionAutocomplete.tsx");
+  const suggestion = {
+    pubkey: "b".repeat(64),
+    displayName: "Buzzy",
+    isAgent: true,
+    ownerLabel: "sarah",
+  };
+  const view = render(
+    React.createElement(MentionAutocomplete, {
+      suggestions: [suggestion],
+      selectedIndex: 0,
+      onSelect: () => {},
+    }),
+  );
+
+  const row = view.getByRole("button", { name: "Mention Buzzy" });
+  assert.match(accessibleDescription(row), /managed by sarah/);
+});
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.tsx b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
index ee939b3efb2..fe2a42172d2 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.tsx
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
@@ -282,14 +282,25 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                 lockedAgentPubkeys?.has(suggestion.pubkey.toLowerCase()),
             );
             // The row's `aria-label` overrides all descendant text as the
-            // accessible name, so the role line below is otherwise announced
-            // to no one — the exact disambiguation it exists to provide
-            // (two same-named agents with different roles) is unavailable to
-            // screen-reader users without this.
+            // accessible name, so neither metadata line below is announced
+            // to screen-reader users without `aria-describedby`. Both the
+            // agent's self-authored `about` and the verified
+            // `managed by <owner>` provenance get an id here so the
+            // description carries both — promoting only the untrusted
+            // self-authored half while silently dropping verified
+            // provenance would let an agent's `about` fabricate ownership
+            // unchallenged.
             const descriptionId =
               suggestion.isAgent && suggestion.description
                 ? `mention-agent-description-${index}`
                 : undefined;
+            const provenanceId =
+              ownerLabel || suggestion.notInChannel
+                ? `mention-agent-provenance-${index}`
+                : undefined;
+            const describedBy =
+              [descriptionId, provenanceId].filter(Boolean).join(" ") ||
+              undefined;
 
             return (
               <div
@@ -304,7 +315,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                 key={suggestionKey}
               >
                 <button
-                  aria-describedby={descriptionId}
+                  aria-describedby={describedBy}
                   aria-label={`Mention ${suggestion.displayName}`}
                   className={cn(
                     "flex min-w-0 flex-1 items-center gap-2 rounded-lg px-3 py-1.5 text-left",
@@ -389,6 +400,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                         {ownerLabel || suggestion.notInChannel ? (
                           <span
                             className="min-w-0 truncate"
+                            id={provenanceId}
                             title={
                               ownerLabel && suggestion.notInChannel
                                 ? `managed by ${ownerLabel} · not in channel`
diff --git a/desktop/src/features/profile/lib/identity.test.mjs b/desktop/src/features/profile/lib/identity.test.mjs
index da0259a66fc..17aaa65e7fd 100644
--- a/desktop/src/features/profile/lib/identity.test.mjs
+++ b/desktop/src/features/profile/lib/identity.test.mjs
@@ -9,6 +9,7 @@ const OWNER_PUBKEY =
 const summary = (over = {}) => ({
   displayName: "Ada",
   avatarUrl: "https://x/a.png",
+  about: "Loves lace and lockets",
   nip05Handle: "ada@x",
   ownerPubkey: null,
   isAgent: false,
@@ -59,6 +60,7 @@ test("profileLookupsEqual: a changed field is not equal", () => {
   for (const field of [
     "displayName",
     "avatarUrl",
+    "about",
     "nip05Handle",
     "ownerPubkey",
     "isAgent",
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index 281c0adaf45..83a19321d83 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -460,6 +460,28 @@ type E2eConfig = {
      *  (e.g. `["link-preview-image"]` fails only the thumbnail, favicon survives). */
     linkPreviewUploadErrorFilenames?: string[];
     searchProfiles?: MockSearchProfileSeed[];
+    /** Pubkeys whose profile stays fully seeded (via `searchProfiles` or
+     *  managed/relay agent registration) but is withheld from `search_users`
+     *  results. Lets a spec isolate `get_users_batch` (which still resolves
+     *  these normally) from global user search, so an assertion that
+     *  depends on an `about` reaching the UI can only pass through the
+     *  batch fallback. */
+    usersBatchOnlyPubkeys?: string[];
+    /** Hold every `get_users_batch` call from the first render (equivalent
+     *  to calling `__BUZZ_E2E_HOLD_USERS_BATCH__(true)` before the app
+     *  could issue one). Without this, an app-shell-wide caller that
+     *  resolves before a spec's own interaction (e.g. the agent-observer
+     *  bridge's blanket profile sweep) can pre-warm `useUsersBatchQuery`'s
+     *  per-pubkey delta-fetch cache for the same pubkeys a later, narrower
+     *  caller wants — so the later caller's `useUsersBatchQuery` resolves
+     *  from cache and never issues its own IPC call, making a raw
+     *  `get_users_batch` call count unable to observe it at all. Starting
+     *  held keeps every caller's request recorded (`__BUZZ_E2E_COMMAND_
+     *  PAYLOADS__` still records a held call immediately) before any of
+     *  them can resolve and cache; release with
+     *  `__BUZZ_E2E_HOLD_USERS_BATCH__(false)` once every request of
+     *  interest has been recorded. */
+    startWithUsersBatchHeld?: boolean;
     updateAvailable?: boolean;
     updateChannelDelayMs?: number;
     updateDownloadDelayMs?: number;
@@ -2771,6 +2793,12 @@ function seedMockSearchProfiles(config?: E2eConfig) {
   }
 }
 
+function seedMockUsersBatchOnlyPubkeys(config?: E2eConfig) {
+  for (const pubkey of config?.mock?.usersBatchOnlyPubkeys ?? []) {
+    mockUsersBatchOnlyPubkeys.add(pubkey.toLowerCase());
+  }
+}
+
 function getMockProfileByPubkey(pubkey: string): RawProfile | null {
   const normalizedPubkey = pubkey.toLowerCase();
   const existing = mockProfiles.get(normalizedPubkey);
@@ -4159,6 +4187,9 @@ function handleGetRunApprovals(_args: { workflowId: string; runId: string }) {
   return { approvals: [] };
 }
 
+// Pubkeys withheld from `search_users` results — see `usersBatchOnlyPubkeys`.
+const mockUsersBatchOnlyPubkeys = new Set<string>();
+
 const mockProfiles = new Map<string, RawProfile>([
   [
     MOCK_IDENTITY_PUBKEY,
@@ -7037,6 +7068,7 @@ async function handleSearchUsers(
     const limit = args.limit ?? 8;
     const page = Math.max(Number(args.cursor ?? 1) || 1, 1);
     const allResults = listMockProfiles()
+      .filter((profile) => !mockUsersBatchOnlyPubkeys.has(profile.pubkey))
       .filter((profile) => {
         if (normalizedQuery.length === 0) {
           return true;
@@ -11325,7 +11357,7 @@ export function maybeInstallE2eTauriMocks() {
   deferredLinkPreviewMetadataQueue = [];
   deferredLinkPreviewUploadQueue = [];
   deferredThreadRepliesQueue = [];
-  holdUsersBatch = false;
+  holdUsersBatch = config.mock?.startWithUsersBatchHeld ?? false;
   heldUsersBatchReleases = [];
   cancelledMediaUploadIds = new Set<string>();
   for (const controller of mockMediaFetchControllers.values()) {
@@ -11370,6 +11402,7 @@ export function maybeInstallE2eTauriMocks() {
   resetMockPersonas(config);
   resetMockTeams(config);
   seedMockSearchProfiles(config);
+  seedMockUsersBatchOnlyPubkeys(config);
   resetMockWorkflows();
   resetMockMesh();
   resetMockUserStatuses();
diff --git a/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
index 8f8c41bc6ec..6205bac42d6 100644
--- a/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
+++ b/desktop/tests/e2e/mention-descriptions-screenshots.spec.ts
@@ -6,6 +6,8 @@ import {
   openNewMessagePage,
   TEST_IDENTITIES,
 } from "../helpers/bridge";
+import { MENTION_SUGGESTION_LIMIT } from "../../src/features/messages/lib/mentionFallbackWindow";
+import { MENTION_DESCRIPTION_MAX_GRAPHEMES } from "../../src/features/messages/lib/mentionSuggestionMapping";
 import type { MockManagedAgentSeed } from "../../src/testing/e2eBridge";
 
 const SHOTS = "test-results/mention-descriptions";
@@ -24,6 +26,15 @@ const ATLAS_LONG_ABOUT =
   "Operations copilot for the whole hive: triages incoming requests, " +
   "routes work to the right specialist agent, keeps the runbook current, " +
   "and escalates anything ambiguous to a human before acting on it";
+// mapMentionCandidateToSuggestion caps the role line to
+// MENTION_DESCRIPTION_MAX_GRAPHEMES before it ever reaches the DOM (a
+// documented bound on untrusted kind-0 `about` content — see
+// mentionSuggestionMapping.ts), so this fixture's `about` is deliberately
+// longer than that cap and every DOM assertion below expects the capped
+// text, not ATLAS_LONG_ABOUT itself. The component's own CSS truncation
+// (tested via scrollWidth below) is a second, independent bound on top of
+// this one — pixel clipping only, not a length cap.
+const ATLAS_CAPPED_ABOUT = `${ATLAS_LONG_ABOUT.slice(0, MENTION_DESCRIPTION_MAX_GRAPHEMES - 1)}…`;
 
 /** Locator scoped to the mention autocomplete dropdown inside the composer. */
 function autocomplete(page: import("@playwright/test").Page) {
@@ -118,22 +129,29 @@ test("mention selector shows each agent's kind-0 about as a role line", async ({
       about,
     );
     // The row's aria-label ("Mention Fizz") overrides descendant text as the
-    // accessible name, so the role line must reach screen readers through
-    // aria-describedby instead — assert the accessible description directly
-    // rather than only the visible text, or a regression that renders the
-    // text but drops the wiring would pass silently.
-    await expect(row).toHaveAccessibleDescription(about);
+    // accessible name, so both metadata halves must reach screen readers
+    // through aria-describedby instead — assert the accessible description
+    // directly rather than only the visible text, or a regression that
+    // renders the text but drops the wiring would pass silently. It carries
+    // the agent's own bio AND the verified "managed by you" provenance
+    // (space-joined, description first) — dropping either half is a
+    // regression: the self-authored bio is the disambiguating content this
+    // row exists to announce, and the provenance is what keeps that bio from
+    // reading as a verified ownership claim it isn't.
+    await expect(row).toHaveAccessibleDescription(`${about} managed by you`);
     await expect(row.getByText("managed by you")).toBeVisible();
   }
 
-  // No `about` → today's exact row: bot icon + literal "agent" label.
+  // No `about` → today's exact row: bot icon + literal "agent" label. The
+  // accessible description still carries the verified "managed by you"
+  // provenance even with no bio to announce alongside it.
   const buzzyRow = dropdown.locator("button", { hasText: "Buzzy" });
   await expect(buzzyRow.getByTestId("mention-agent-icon")).toBeVisible();
   await expect(buzzyRow.getByText("agent", { exact: true })).toBeVisible();
   await expect(buzzyRow.getByTestId("mention-agent-description")).toHaveCount(
     0,
   );
-  await expect(buzzyRow).toHaveAccessibleDescription("");
+  await expect(buzzyRow).toHaveAccessibleDescription("managed by you");
 
   // Humans never get a role line, even with an `about` on their profile.
   const bobRow = dropdown.locator("button", { hasText: "bob" });
@@ -175,8 +193,10 @@ test("long about truncates to a single line beside the managed-by label", async
   const atlasRow = dropdown.locator("button", { hasText: "Atlas" });
   const description = atlasRow.getByTestId("mention-agent-description");
   await expect(description).toBeVisible();
-  await expect(description).toHaveAttribute("title", ATLAS_LONG_ABOUT);
-  await expect(atlasRow).toHaveAccessibleDescription(ATLAS_LONG_ABOUT);
+  await expect(description).toHaveAttribute("title", ATLAS_CAPPED_ABOUT);
+  await expect(atlasRow).toHaveAccessibleDescription(
+    `${ATLAS_CAPPED_ABOUT} managed by you`,
+  );
   await expect(atlasRow.getByText("managed by you")).toBeVisible();
 
   // The full text must overflow its one-line box — proof it truncates
@@ -198,13 +218,17 @@ test("long about truncates to a single line beside the managed-by label", async
 // passes no `profiles` prop to `MessageComposer` at all, so any agent role
 // line here can only come from useMentions' own fallback batch.
 //
-// The numeric request bound (never more than MENTION_SUGGESTION_LIMIT
-// pubkeys, even with 150+ mentionable agents, and a past-the-window agent
-// still resolving once ranked into view) is covered directly and cheaply at
-// the unit level in mentionFallbackWindow.test.mjs, which exercises the
-// exact functions useMentions.ts calls. This spec proves the other half —
-// that useMentions.ts is actually wired to call them on a real composer
-// with no scoped `profiles` — through observable UI behavior only.
+// mentionFallbackWindow.test.mjs proves the selection helpers themselves are
+// bounded, but it imports them directly and never imports useMentions.ts —
+// it cannot prove useMentions.ts is actually wired to call them with a
+// bounded input on a real composer. This spec binds that seam: it asserts
+// the ACTUAL `get_users_batch` payloads useMentions.ts sends (recorded by
+// the mock bridge) never exceed MENTION_SUGGESTION_LIMIT pubkeys, even with
+// 120 mentionable agents, and that a past-the-window agent still resolves
+// once ranked into view — through observable UI behavior AND the recorded
+// IPC payload, not just the render count (which is capped separately by
+// `matchingSuggestions` and would stay 50 even if the batch request itself
+// regressed to unbounded).
 const MANY_AGENTS_COUNT = 120;
 // Zero-padded to a fixed width so no agent's name is a substring of
 // another's (`Agent001` vs. `Agent010` vs. `Agent100`) — Playwright's
@@ -235,6 +259,30 @@ const manySearchProfiles = manyManagedAgents.map((agent, i) => ({
   about: `Role ${i + 1}`,
 }));
 
+/** Reads every recorded `get_users_batch` call's `pubkeys` payload, narrowed
+ *  to calls made up entirely of this fixture's agent pubkeys (the
+ *  `manyAgentPubkey` `9f…` prefix) — the shape only a mention-picker
+ *  agent-profile request can have. The app shell also mounts an unrelated,
+ *  legitimately unbounded batch call on startup (the agent-observer
+ *  bridge's blanket relay-agent sweep, which pulls in non-agent identities
+ *  like the recipient-picker's search results too); this filter excludes it
+ *  by content rather than by timing, which stays correct across the whole
+ *  test regardless of when that unrelated call happens to settle. */
+async function fixtureAgentUsersBatchCalls(
+  page: import("@playwright/test").Page,
+) {
+  return page.evaluate(() =>
+    (window.__BUZZ_E2E_COMMAND_PAYLOADS__ ?? [])
+      .filter((entry) => entry.command === "get_users_batch")
+      .map((entry) => (entry.payload as { pubkeys?: string[] })?.pubkeys ?? [])
+      .filter(
+        (pubkeys) =>
+          pubkeys.length > 0 &&
+          pubkeys.every((pk) => pk.toLowerCase().startsWith("9f")),
+      ),
+  );
+}
+
 test("resolves an agent's about through the fallback batch on a composer with no profiles prop, bounded even past the ranked window", async ({
   page,
 }) => {
@@ -242,6 +290,25 @@ test("resolves an agent's about through the fallback batch on a composer with no
     managedAgents: manyManagedAgents,
     relayAgents: [],
     searchProfiles: manySearchProfiles,
+    // The 120th agent's `about` stays seeded (so `get_users_batch` resolves
+    // it normally) but withheld from `search_users` results. Without this,
+    // typing its exact name below would enable global user search, which
+    // would independently resolve its `about` through the search-result
+    // candidate path (buildMentionCandidates.ts) and let this test pass
+    // even if useMentions.ts's own fallback batch were deleted.
+    usersBatchOnlyPubkeys: [manyAgentPubkey(MANY_AGENTS_COUNT - 1)],
+    // Every `get_users_batch` caller (including the unrelated app-shell
+    // agent-observer sweep — see fixtureAgentUsersBatchCalls) starts
+    // pinned open. Without this, that sweep resolves before the composer
+    // ever mounts and pre-warms useUsersBatchQuery's per-pubkey delta-fetch
+    // cache for every one of these agents; the mention fallback's own call
+    // would then resolve entirely from cache and never reach
+    // `get_users_batch` at all, so a regression to the unbounded upstream
+    // form would leave zero recorded calls to inspect either way — a
+    // request-count assertion with nothing to bind to. Holding first keeps
+    // every caller's request recorded before any of them can resolve and
+    // populate that cache.
+    startWithUsersBatchHeld: true,
   });
   await page.goto("/");
   await openNewMessagePage(page);
@@ -256,7 +323,10 @@ test("resolves an agent's about through the fallback batch on a composer with no
 
   // A bare "@" keeps the mention query empty, which keeps global user
   // search disabled (`canSearchGlobalPeople` requires non-empty text) — the
-  // fallback batch is the ONLY thing that can resolve an about here.
+  // fallback batch is the ONLY thing that can resolve an about here. Row
+  // rendering does not wait on the batch resolving (only the role-line text
+  // inside each row does), so all 50 buttons appear even while every
+  // `get_users_batch` call is still held.
   await page.getByTestId("message-input").fill("@");
   const dropdown = autocomplete(page);
   await expect(dropdown).toBeVisible();
@@ -268,6 +338,26 @@ test("resolves an agent's about through the fallback batch on a composer with no
     dropdown.locator("button", { hasText: LAST_AGENT_NAME }),
   ).toHaveCount(0);
 
+  // The production request bound, captured before anything can resolve
+  // from cache: every `get_users_batch` call made up entirely of this
+  // fixture's agent pubkeys — the mention fallback's own request shape,
+  // isolated from the unrelated observer sweep by content (see
+  // fixtureAgentUsersBatchCalls) — carries at most
+  // MENTION_SUGGESTION_LIMIT pubkeys. A regression to the unbounded
+  // upstream form (requesting every mentionable agent) would still render
+  // 50 buttons (that cap comes from `matchingSuggestions`, not this
+  // request) but would fail this assertion.
+  const boundedWindowCalls = await fixtureAgentUsersBatchCalls(page);
+  expect(boundedWindowCalls.length).toBeGreaterThan(0);
+  for (const pubkeys of boundedWindowCalls) {
+    expect(pubkeys.length).toBeLessThanOrEqual(MENTION_SUGGESTION_LIMIT);
+  }
+
+  // Release every held call — including the observer sweep and the
+  // fallback batch just verified above — so the UI can settle and the rest
+  // of this test exercises normal (unheld) behavior.
+  await page.evaluate(() => window.__BUZZ_E2E_HOLD_USERS_BATCH__?.(false));
+
   // A visible agent's role line resolved through the fallback. A bare "@"
   // keeps global user search disabled (see above), so this text can only
   // have come from useMentions' fallback batch — deleting that block drops
@@ -279,11 +369,21 @@ test("resolves an agent's about through the fallback batch on a composer with no
 
   // Narrowing the query to the 120th agent's exact name ranks it first and
   // brings it into the visible window — proof the bound doesn't strand an
-  // agent past the first page; it resolves once brought into view.
+  // agent past the first page; it resolves once brought into view. Global
+  // people search is enabled by this non-empty query, but `about` still
+  // proves the fallback batch resolved it and not search: this pubkey is
+  // withheld from `search_users` results by `usersBatchOnlyPubkeys` above,
+  // so global search returns nothing for it — deleting useMentions.ts's
+  // fallback block drops this row to the generic "agent" label.
   await page.getByTestId("message-input").fill(`@${LAST_AGENT_NAME}`);
   const lastRow = dropdown.locator("button", { hasText: LAST_AGENT_NAME });
   await expect(lastRow).toBeVisible();
   await expect(lastRow.getByTestId("mention-agent-description")).toHaveText(
     LAST_AGENT_ABOUT,
   );
+
+  // The bound holds for this narrowed, newly-brought-into-view request too.
+  for (const pubkeys of await fixtureAgentUsersBatchCalls(page)) {
+    expect(pubkeys.length).toBeLessThanOrEqual(MENTION_SUGGESTION_LIMIT);
+  }
 });

From cf7d2bda065dc905f17e24d9c444850879742494 Mon Sep 17 00:00:00 2001
From: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
Date: Fri, 4 Sep 2026 15:22:00 -0700
Subject: [PATCH 5/5] fix(desktop): bound mention about at the seam, fix
 fallback and a11y gaps

Sol audit round 2 on port/2706 left three verified WARNs open:

- The batch/search DTOs (UserProfileSummaryInfo, UserSearchResultInfo)
  carried an untrusted kind-0 `about` with no cap before the frontend's
  120-grapheme render cap. Cap it at the boundary in
  nostr_convert::truncate_mention_about (512 bytes, char-boundary safe),
  applied in users_batch_from_events and user_search_result_from_event.
- selectAgentProfileFallbackPubkeys treated any profiles[pubkey] entry as
  proof `about` was known, so the synthetic entries
  mergeAgentNamesIntoProfiles/mergeMemberAgentFlagsIntoProfiles attach to
  every managed/relay/member agent (name fields, no `about` key)
  permanently suppressed the fallback for exactly the agents it exists to
  cover. Key off `about === undefined` instead, normalized like the
  mapper does.
- The name-collision branch in MentionAutocomplete nulls `ownerLabel` and
  falls back to the npub as the only trusted disambiguator, but the npub
  span had no id and was never wired into aria-describedby, so two
  same-name agents announced identically to screen readers. Give it an
  id and include it in describedBy.

Tests: 2 new Rust seam tests (byte cap + char-boundary safety) plus a
DTO-level truncation test on each converter, 2 new fallback-window unit
tests (synthetic-entry inclusion, normalized-key match), 2 new/extended
MentionAutocomplete a11y tests (npub wired into describedBy; disambiguator
still present when ownerLabel is nulled).

Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>
---
 desktop/src-tauri/src/models.rs               | 10 ++-
 desktop/src-tauri/src/nostr_convert.rs        | 40 ++++++++++-
 desktop/src-tauri/src/nostr_convert/tests.rs  | 47 +++++++++++++
 .../src/nostr_convert/user_search.rs          | 23 ++++++-
 .../lib/mentionFallbackWindow.test.mjs        | 40 +++++++++++
 .../messages/lib/mentionFallbackWindow.ts     | 17 ++++-
 .../messages/ui/MentionAutocomplete.test.mjs  | 68 +++++++++++++++++++
 .../messages/ui/MentionAutocomplete.tsx       | 18 ++++-
 8 files changed, 256 insertions(+), 7 deletions(-)

diff --git a/desktop/src-tauri/src/models.rs b/desktop/src-tauri/src/models.rs
index 90e0b70e49b..5e69dfeed11 100644
--- a/desktop/src-tauri/src/models.rs
+++ b/desktop/src-tauri/src/models.rs
@@ -51,7 +51,10 @@ pub struct UserProfileSummaryInfo {
     pub name: Option<String>,
     pub avatar_url: Option<String>,
     /// Kind-0 `about` field — one-line role/description surfaced in the
-    /// @-mention selector for agents.
+    /// @-mention selector for agents. Untrusted, and capped to
+    /// `nostr_convert::MENTION_ABOUT_MAX_BYTES` bytes at the point it is
+    /// built from the event (`nostr_convert::users_batch_from_events`), not
+    /// merely at render — see that constant's doc comment.
     #[serde(default)]
     pub about: Option<String>,
     pub nip05_handle: Option<String>,
@@ -72,7 +75,10 @@ pub struct UserSearchResultInfo {
     pub display_name: Option<String>,
     pub avatar_url: Option<String>,
     /// Kind-0 `about` field — one-line role/description surfaced in the
-    /// @-mention selector for agents.
+    /// @-mention selector for agents. Untrusted, and capped to
+    /// `nostr_convert::MENTION_ABOUT_MAX_BYTES` bytes at the point it is
+    /// built from the event (`nostr_convert::user_search_result_from_event`),
+    /// not merely at render — see that constant's doc comment.
     #[serde(default)]
     pub about: Option<String>,
     pub nip05_handle: Option<String>,
diff --git a/desktop/src-tauri/src/nostr_convert.rs b/desktop/src-tauri/src/nostr_convert.rs
index b7515422b6b..15e2ec6d51c 100644
--- a/desktop/src-tauri/src/nostr_convert.rs
+++ b/desktop/src-tauri/src/nostr_convert.rs
@@ -55,6 +55,42 @@ fn tags_named<'a>(event: &'a Event, name: &'a str) -> impl Iterator<Item = &'a [
     })
 }
 
+/// Byte cap applied to a kind:0 `about` before it crosses the Tauri IPC
+/// boundary in [`crate::models::UserProfileSummaryInfo`] and
+/// [`crate::models::UserSearchResultInfo`].
+///
+/// `about` is untrusted kind-0 content: the relay allows up to 256 KiB of
+/// kind-0 `content` (`MAX_EVENT_CONTENT_BYTES`,
+/// `crates/buzz-relay/src/handlers/ingest.rs`), and `get_users_batch` sends a
+/// batch filter with no limit, so a single batch response could otherwise
+/// carry hundreds of MiB of untrusted text across the IPC boundary and into
+/// the React Query cache. The frontend's 120-grapheme render cap
+/// (`MENTION_DESCRIPTION_MAX_GRAPHEMES`,
+/// `desktop/src/features/messages/lib/mentionSuggestionMapping.ts`) runs
+/// downstream of this and does not bound what crosses the seam. 512 bytes
+/// comfortably covers that render cap (grapheme clusters are a handful of
+/// bytes each in the common case) while cutting the untrusted payload from
+/// 256 KiB to 512 B per profile at the boundary itself.
+pub(crate) const MENTION_ABOUT_MAX_BYTES: usize = 512;
+
+/// Truncate `about` to at most [`MENTION_ABOUT_MAX_BYTES`] bytes on a UTF-8
+/// character boundary. Used by the mention-picker DTOs
+/// ([`crate::models::UserProfileSummaryInfo`],
+/// [`crate::models::UserSearchResultInfo`]); the full, uncapped `about`
+/// remains available on the `get_profile` detail path.
+pub(crate) fn truncate_mention_about(about: Option<String>) -> Option<String> {
+    about.map(|s| {
+        if s.len() <= MENTION_ABOUT_MAX_BYTES {
+            return s;
+        }
+        let mut end = MENTION_ABOUT_MAX_BYTES;
+        while end > 0 && !s.is_char_boundary(end) {
+            end -= 1;
+        }
+        s[..end].to_string()
+    })
+}
+
 /// Return the owner pubkey from a valid NIP-OA owner tag on a kind:0 profile.
 ///
 /// NIP-OA requires a valid event and exactly one well-formed `auth` tag whose
@@ -358,7 +394,9 @@ pub fn users_batch_from_events(
                 .map(str::to_string),
             name: v.get("name").and_then(Value::as_str).map(str::to_string),
             avatar_url: v.get("picture").and_then(Value::as_str).map(str::to_string),
-            about: v.get("about").and_then(Value::as_str).map(str::to_string),
+            about: truncate_mention_about(
+                v.get("about").and_then(Value::as_str).map(str::to_string),
+            ),
             nip05_handle: v.get("nip05").and_then(Value::as_str).map(str::to_string),
             is_agent: owner_pubkey.is_some(),
             owner_pubkey,
diff --git a/desktop/src-tauri/src/nostr_convert/tests.rs b/desktop/src-tauri/src/nostr_convert/tests.rs
index 9baee493774..2253ce011d8 100644
--- a/desktop/src-tauri/src/nostr_convert/tests.rs
+++ b/desktop/src-tauri/src/nostr_convert/tests.rs
@@ -300,6 +300,53 @@ fn users_batch_carries_about_when_present() {
     assert_eq!(resp.profiles[&pk_without].about, None);
 }
 
+#[test]
+fn users_batch_truncates_oversized_about_at_the_seam() {
+    // A batch response has no per-request limit (`get_users_batch` sends the
+    // filter with no `limit`) and a kind:0 `content` may reach 256 KiB
+    // (`MAX_EVENT_CONTENT_BYTES`), so the DTO must not carry the untrusted
+    // `about` verbatim across the Tauri IPC boundary — the frontend's
+    // 120-grapheme render cap runs downstream and does not bound this.
+    let oversized_about = "a".repeat(MENTION_ABOUT_MAX_BYTES * 4);
+    let event = ev(
+        0,
+        &format!(r#"{{"display_name":"Bumble","about":"{oversized_about}"}}"#),
+        vec![],
+    );
+    let pk = event.pubkey.to_hex();
+
+    let resp = users_batch_from_events(std::slice::from_ref(&event), std::slice::from_ref(&pk));
+
+    let capped = resp.profiles[&pk].about.as_deref().expect("about present");
+    assert!(
+        capped.len() <= MENTION_ABOUT_MAX_BYTES,
+        "capped about is {} bytes, expected <= {MENTION_ABOUT_MAX_BYTES}",
+        capped.len()
+    );
+    assert!(capped.len() < oversized_about.len());
+}
+
+#[test]
+fn truncate_mention_about_cuts_on_a_char_boundary() {
+    // Every grapheme here is a 4-byte UTF-8 scalar (outside the BMP), chosen
+    // so a naive byte-index slice would land mid-character and panic.
+    let about = "\u{1F600}".repeat(MENTION_ABOUT_MAX_BYTES); // far over the cap
+    let truncated = truncate_mention_about(Some(about)).expect("some");
+    assert!(truncated.len() <= MENTION_ABOUT_MAX_BYTES);
+    assert!(truncated.is_char_boundary(truncated.len()));
+    // Sanity: the result is still valid UTF-8 (would already panic above if not).
+    assert!(!truncated.is_empty());
+}
+
+#[test]
+fn truncate_mention_about_leaves_short_strings_untouched() {
+    assert_eq!(
+        truncate_mention_about(Some("short bio".to_string())).as_deref(),
+        Some("short bio")
+    );
+    assert_eq!(truncate_mention_about(None), None);
+}
+
 #[test]
 fn user_notes_builds_cursor_from_last() {
     let e1 = ev(1, "first", vec![]);
diff --git a/desktop/src-tauri/src/nostr_convert/user_search.rs b/desktop/src-tauri/src/nostr_convert/user_search.rs
index 334e9e22b0d..3bff7921f5b 100644
--- a/desktop/src-tauri/src/nostr_convert/user_search.rs
+++ b/desktop/src-tauri/src/nostr_convert/user_search.rs
@@ -19,7 +19,9 @@ pub fn user_search_result_from_event(ev: &Event) -> UserSearchResultInfo {
             .or_else(|| v.get("name").and_then(Value::as_str))
             .map(str::to_string),
         avatar_url: v.get("picture").and_then(Value::as_str).map(str::to_string),
-        about: v.get("about").and_then(Value::as_str).map(str::to_string),
+        about: super::truncate_mention_about(
+            v.get("about").and_then(Value::as_str).map(str::to_string),
+        ),
         nip05_handle: v.get("nip05").and_then(Value::as_str).map(str::to_string),
         is_agent: owner_pubkey.is_some(),
         owner_pubkey,
@@ -251,6 +253,25 @@ mod tests {
         assert_eq!(user_search_result_from_event(&without_about).about, None);
     }
 
+    #[test]
+    fn user_search_result_truncates_oversized_about_at_the_seam() {
+        // `search_users` is bounded to 500 rows (not unbounded like the batch
+        // command) but each row's `about` was still uncapped before crossing
+        // the IPC boundary — cap it here too, matching `users_batch`.
+        let oversized_about = "a".repeat(super::super::MENTION_ABOUT_MAX_BYTES * 4);
+        let event = ev(
+            0,
+            &format!(r#"{{"name":"honey","about":"{oversized_about}"}}"#),
+            vec![],
+        );
+
+        let capped = user_search_result_from_event(&event)
+            .about
+            .expect("about present");
+        assert!(capped.len() <= super::super::MENTION_ABOUT_MAX_BYTES);
+        assert!(capped.len() < oversized_about.len());
+    }
+
     #[test]
     fn user_search_result_marks_valid_nip_oa_profile_as_agent() {
         let event = oa_profile_event(r#"{"display_name":"Mira"}"#);
diff --git a/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs b/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
index bb5e2d88d16..40f4469041e 100644
--- a/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
+++ b/desktop/src/features/messages/lib/mentionFallbackWindow.test.mjs
@@ -97,6 +97,46 @@ test("excludes agents already covered by the caller's profiles prop", () => {
   assert.deepEqual(pubkeys, [uncovered.pubkey]);
 });
 
+test("includes an agent whose lookup entry exists but carries no about — the mergeAgentNamesIntoProfiles shape", () => {
+  // Production seam: mergeAgentNamesIntoProfiles (useChannelActivityTyping.ts)
+  // synthesizes a profile-lookup entry for every managed/relay agent with
+  // displayName / avatarUrl / nip05Handle / ownerPubkey / isAgent and NO
+  // `about` key at all — a real entry, not a hypothetical one. Treating
+  // entry presence as "about known" would suppress the fallback for exactly
+  // the agents it exists to cover; the fix must key off `about` being
+  // present, not the entry.
+  const candidate = agentCandidate(1);
+  const visible = rankVisibleMentionCandidates([candidate], "", new Set());
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, {
+    [candidate.pubkey]: {
+      displayName: "Bumble",
+      avatarUrl: null,
+      nip05Handle: null,
+      ownerPubkey: null,
+      isAgent: true,
+    },
+  });
+  assert.deepEqual(pubkeys, [candidate.pubkey]);
+});
+
+test("matches the caller's profiles lookup by normalized pubkey, like the mapper does", () => {
+  const candidate = agentCandidate(1, {
+    pubkey: agentCandidate(1).pubkey.toUpperCase(),
+  });
+  const visible = rankVisibleMentionCandidates([candidate], "", new Set());
+  const pubkeys = selectAgentProfileFallbackPubkeys(visible, {
+    [candidate.pubkey.toLowerCase()]: {
+      displayName: null,
+      name: null,
+      avatarUrl: null,
+      about: "Known via the caller, keyed lowercase",
+      nip05Handle: null,
+      ownerPubkey: null,
+    },
+  });
+  assert.deepEqual(pubkeys, []);
+});
+
 test("excludes non-agent candidates even when their description is unknown", () => {
   const person = agentCandidate(1, { isAgent: false });
   const agent = agentCandidate(2);
diff --git a/desktop/src/features/messages/lib/mentionFallbackWindow.ts b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
index efe8e817afa..21bc5b97c3a 100644
--- a/desktop/src/features/messages/lib/mentionFallbackWindow.ts
+++ b/desktop/src/features/messages/lib/mentionFallbackWindow.ts
@@ -1,4 +1,5 @@
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
+import { normalizePubkey } from "@/shared/lib/pubkey";
 import {
   type MentionCandidateForRanking,
   rankMentionCandidates,
@@ -51,6 +52,20 @@ export type AgentProfileFallbackCandidate = MentionCandidateForRanking & {
  * show a role line even for agents who haven't authored anything in the
  * loaded timeline, without the unbounded-batch failure mode
  * {@link MENTION_SUGGESTION_LIMIT} documents.
+ *
+ * Coverage is judged by `about` being present, not by the lookup entry
+ * existing: `mergeAgentNamesIntoProfiles` and `mergeMemberAgentFlagsIntoProfiles`
+ * (`useChannelActivityTyping.ts`) synthesize a profile-lookup entry for every
+ * managed/relay/member-flagged agent with `displayName` / `avatarUrl` /
+ * `nip05Handle` / `ownerPubkey` / `isAgent` and **no `about` key at all** —
+ * that entry is a real production shape, not a hypothetical one. Treating
+ * entry presence as "about known" (the old `!profiles?.[...]` check) skips
+ * those candidates permanently, so the fallback never runs the one time it
+ * would recover their role line. Checking `about === undefined` instead
+ * distinguishes "profile known, about absent" (skip — there is nothing to
+ * fetch) from "profile not fetched" (include). The key is normalized to
+ * match {@link mapMentionCandidateToSuggestion}'s lookup
+ * (`profiles?.[normalizePubkey(pubkey)]?.about`) in mentionSuggestionMapping.ts.
  */
 export function selectAgentProfileFallbackPubkeys<
   T extends AgentProfileFallbackCandidate,
@@ -66,7 +81,7 @@ export function selectAgentProfileFallbackPubkeys<
             candidate.isAgent &&
             candidate.pubkey &&
             candidate.description === undefined &&
-            !profiles?.[candidate.pubkey],
+            profiles?.[normalizePubkey(candidate.pubkey)]?.about === undefined,
         )
         .map(({ candidate }) => candidate.pubkey as string),
     ),
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs b/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
index 3bd8c3ae26b..410cf394521 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.test.mjs
@@ -275,6 +275,74 @@ test("collision npubs sit inline with agent metadata", async () => {
     assert.match(npub.className, /(?:^|\s)leading-none(?:\s|$)/);
     assert.match(agentMetadata?.className ?? "", /(?:^|\s)min-h-3\.5(?:\s|$)/);
   }
+
+  // The visible npub must also be wired into aria-describedby: it's the
+  // one channel a screen-reader user has to tell the two "Same Name" rows
+  // apart, so its id has to actually be referenced, not just present in
+  // the DOM.
+  const rows = view.getAllByRole("button", { name: "Mention Same Name" });
+  assert.equal(rows.length, 2);
+  for (const [index, row] of rows.entries()) {
+    assert.match(accessibleDescription(row), /npub1/);
+    assert.equal(
+      row.getAttribute("aria-describedby")?.includes(collisionNpubs[index].id),
+      true,
+    );
+  }
+});
+
+test("the collision npub still reaches the accessible description when the owner label is nulled", async () => {
+  // Reproduces the Sol-flagged gap directly: `hasNameCollision &&
+  // suggestion.agentProvenance` nulls `ownerLabel` in the collision branch
+  // (MentionAutocomplete.tsx), so the npub becomes the ONLY trusted
+  // disambiguator between two rows a screen reader would otherwise announce
+  // identically as "Mention Rex" with a self-authored-only description.
+  const React = await import("react");
+  const { render } = await import("@testing-library/react");
+  const { MentionAutocomplete } = await import("./MentionAutocomplete.tsx");
+  const suggestions = [
+    {
+      pubkey: "a".repeat(64),
+      displayName: "Rex",
+      isAgent: true,
+      ownerLabel: "you",
+      agentProvenance: "managed-elsewhere",
+      description: "managed by you · admin",
+    },
+    {
+      pubkey: "b".repeat(64),
+      displayName: "Rex",
+      isAgent: true,
+      ownerLabel: "you",
+      agentProvenance: "managed-elsewhere",
+      description: "managed by you · admin",
+    },
+  ];
+  const view = render(
+    React.createElement(MentionAutocomplete, {
+      suggestions,
+      selectedIndex: 0,
+      onSelect: () => {},
+    }),
+  );
+
+  const rows = view.getAllByRole("button", { name: "Mention Rex" });
+  assert.equal(rows.length, 2);
+  const descriptions = rows.map(accessibleDescription);
+
+  // Each row still names its trusted disambiguator (the npub) even though
+  // ownerLabel was nulled by the collision branch...
+  for (const description of descriptions) {
+    assert.match(description, /npub1/);
+  }
+  // ...alongside the self-authored bio, which is not hidden — just no
+  // longer the only thing announced.
+  for (const description of descriptions) {
+    assert.match(description, /managed by you · admin/);
+  }
+  // ...and the two rows are distinguishable from one another, which is the
+  // entire point of the npub existing in the collision branch.
+  assert.notEqual(descriptions[0], descriptions[1]);
 });
 
 test("does not intercept Tab from the editor", async () => {
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.tsx b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
index fe2a42172d2..b79a43e85ac 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.tsx
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
@@ -298,9 +298,22 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
               ownerLabel || suggestion.notInChannel
                 ? `mention-agent-provenance-${index}`
                 : undefined;
+            // In the name-collision branch `ownerLabel` is deliberately
+            // nulled above and the npub becomes the only trusted
+            // disambiguator between two rows that otherwise render and
+            // announce identically ("Mention Rex" for both). It needs the
+            // same treatment as `provenanceId`: without an id wired into
+            // `aria-describedby`, a screen-reader user hears two identical,
+            // self-authored-only descriptions and has no way to tell the
+            // agents apart, even though the sighted user sees the distinct
+            // npub.
+            const collisionNpubId = collisionNpub
+              ? `mention-collision-npub-${index}`
+              : undefined;
             const describedBy =
-              [descriptionId, provenanceId].filter(Boolean).join(" ") ||
-              undefined;
+              [descriptionId, provenanceId, collisionNpubId]
+                .filter(Boolean)
+                .join(" ") || undefined;
 
             return (
               <div
@@ -420,6 +433,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                           <span
                             className="-translate-y-0.5 shrink-0 font-mono leading-none"
                             data-testid="mention-collision-npub"
+                            id={collisionNpubId}
                             title={collisionNpub}
                           >
                             {truncatePubkey(collisionNpub)}